Grcov report - lib.rs

1

//! # CCSDS and ECSS packet standards implementations

2

//!

3

//! This crate contains generic implementations for various

4

//! CCSDS (Consultative Committee for Space Data Systems) and

5

//! ECSS (European Cooperation for Space Standardization) packet standards.

6

//! Currently, this includes the following components:

7

//!

8

//!  - Space Packet implementation according to

9

//!    [CCSDS Blue Book 133.0-B-2](https://public.ccsds.org/Pubs/133x0b2e1.pdf)

10

//!  - CCSDS File Delivery Protocol (CFDP) packet implementations according to

11

//!    [CCSDS Blue Book 727.0-B-5](https://public.ccsds.org/Pubs/727x0b5.pdf)

12

//!  - PUS Telecommand and PUS Telemetry implementation according to the

13

//!    [ECSS-E-ST-70-41C standard](https://ecss.nl/standard/ecss-e-st-70-41c-space-engineering-telemetry-and-telecommand-packet-utilization-15-april-2016/).

14

//!  - CUC (CCSDS Unsegmented Time Code) implementation according to

15

//!    [CCSDS 301.0-B-4 3.2](https://public.ccsds.org/Pubs/301x0b4e1.pdf)

16

//!  - CDS (CCSDS Day Segmented Time Code) implementation according to

17

//!    [CCSDS 301.0-B-4 3.3](https://public.ccsds.org/Pubs/301x0b4e1.pdf)

18

//!  - Some helper types to support ASCII timecodes as specified in

19

//!    [CCSDS 301.0-B-4 3.5](https://public.ccsds.org/Pubs/301x0b4e1.pdf)

20

//!

21

//! ## Features

22

//!

23

//! `spacepackets` supports various runtime environments and is also suitable for `no_std` environments.

24

//!

25

//! ### Default features

26

//!

27

//!  - [`std`](https://doc.rust-lang.org/std/): Enables functionality relying on the standard library.

28

//!  - [`alloc`](https://doc.rust-lang.org/alloc/): Enables features which operate on containers

29

//!     like [`alloc::vec::Vec`](https://doc.rust-lang.org/beta/alloc/vec/struct.Vec.html).

30

//!     Enabled by the `std` feature.

31

//!

32

//! ### Optional features

33

//!

34

//!  - [`serde`](https://serde.rs/): Adds `serde` support for most types by adding `Serialize` and

35

//!    `Deserialize` `derives.

36

//!  - [`chrono`](https://crates.io/crates/chrono): Add basic support for the `chrono` time library.

37

//!  - [`timelib`](https://crates.io/crates/time): Add basic support for the `time` time library.

38

//!  - [`defmt`](https://defmt.ferrous-systems.com/): Add support for the `defmt` by adding the

39

//!    [`defmt::Format`](https://defmt.ferrous-systems.com/format) derive on many types.

40

//!

41

//! ## Module

42

//!

43

//! This module contains helpers and data structures to generate Space Packets according to the

44

//! [CCSDS 133.0-B-2](https://public.ccsds.org/Pubs/133x0b2e1.pdf). This includes the

45

//! [SpHeader] class to generate the Space Packet Header component common to all space packets.

46

//!

47

//! ## Example

48

//!

49

//! ```rust

50

//! use spacepackets::SpHeader;

51

//! let sp_header = SpHeader::new_for_unseg_tc_checked(0x42, 12, 1).expect("error creating CCSDS TC header");

52

//! println!("{:?}", sp_header);

53

//! let mut ccsds_buf: [u8; 32] = [0; 32];

54

//! sp_header.write_to_be_bytes(&mut ccsds_buf).expect("Writing CCSDS TC header failed");

55

//! println!("{:x?}", &ccsds_buf[0..6]);

56

//! ```

57

#![no_std]

58

#![cfg_attr(docsrs, feature(doc_auto_cfg))]

59

#[cfg(feature = "alloc")]

60

extern crate alloc;

61

#[cfg(any(feature = "std", test))]

62

extern crate std;

63

64

use core::{

65

    fmt::{Debug, Display, Formatter},

66

    hash::Hash,

67

};

68

use crc::{Crc, CRC_16_IBM_3740};

69

use delegate::delegate;

70

71

#[cfg(feature = "std")]

72

use std::error::Error;

73

74

#[cfg(feature = "serde")]

75

use serde::{Deserialize, Serialize};

76

77

pub mod cfdp;

78

pub mod ecss;

79

pub mod seq_count;

80

pub mod time;

81

pub mod util;

82

83

mod private {

84

    pub trait Sealed {}

85

86

87

pub const CCSDS_HEADER_LEN: usize = core::mem::size_of::<crate::zc::SpHeader>();

88

89

/// CRC algorithm used by the PUS standard, the CCSDS TC standard and the CFDP standard.

90

pub const CRC_CCITT_FALSE: Crc<u16> = Crc::<u16>::new(&CRC_16_IBM_3740);

91

92

pub const MAX_APID: u16 = 2u16.pow(11) - 1;

93

pub const MAX_SEQ_COUNT: u16 = 2u16.pow(14) - 1;

94

95

/// Generic error type when converting to and from raw byte slices.

96

#[derive(Debug, Copy, Clone, PartialEq, Eq)]

97

#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]

98

#[cfg_attr(feature = "defmt", derive(defmt::Format))]

99

pub enum ByteConversionError {

100

    /// The passed slice is too small. Returns the passed slice length and expected minimum size

101

    ToSliceTooSmall {

102

        found: usize,

103

        expected: usize,

104

},

105

    /// The provider buffer is too small. Returns the passed slice length and expected minimum size

106

    FromSliceTooSmall {

107

        found: usize,

108

        expected: usize,

109

},

110

    /// The [zerocopy] library failed to write to bytes

111

    ZeroCopyToError,

112

    ZeroCopyFromError,

113

114

115

impl Display for ByteConversionError {

116

20

    fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {

117

20

        match self {

118

18

            ByteConversionError::ToSliceTooSmall { found, expected } => {

119

18

                write!(

120

18

f,

121

18

                    "target slice with size {} is too small, expected size of at least {}",

122

18

                    found, expected

123

18

124

125

2

            ByteConversionError::FromSliceTooSmall { found, expected } => {

126

2

                write!(

127

2

f,

128

2

                    "source slice with size {} too small, expected at least {} bytes",

129

2

                    found, expected

130

2

131

132

            ByteConversionError::ZeroCopyToError => {

133

                write!(f, "zerocopy serialization error")

134

135

            ByteConversionError::ZeroCopyFromError => {

136

                write!(f, "zerocopy deserialization error")

137

138

139

20

140

141

142

#[cfg(feature = "std")]

143

impl Error for ByteConversionError {}

144

145

/// CCSDS packet type enumeration.

146

#[derive(Debug, PartialEq, Eq, Copy, Clone)]

147

16

#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]

148

#[cfg_attr(feature = "defmt", derive(defmt::Format))]

149

pub enum PacketType {

150

    Tm = 0,

151

    Tc = 1,

152

153

154

impl TryFrom<u8> for PacketType {

155

    type Error = ();

156

157

60

    fn try_from(value: u8) -> Result<Self, Self::Error> {

158

60

        match value {

159

60

            x if x == PacketType::Tm as u8 => Ok(PacketType::Tm),

160

28

            x if x == PacketType::Tc as u8 => Ok(PacketType::Tc),

161

2

            _ => Err(()),

162

163

60

164

165

166

2

pub fn packet_type_in_raw_packet_id(packet_id: u16) -> PacketType {

167

2

    PacketType::try_from((packet_id >> 12) as u8 & 0b1).unwrap()

168

2

169

170

#[derive(Debug, PartialEq, Eq, Copy, Clone)]

171

16

#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]

172

#[cfg_attr(feature = "defmt", derive(defmt::Format))]

173

pub enum SequenceFlags {

174

    ContinuationSegment = 0b00,

175

    FirstSegment = 0b01,

176

    LastSegment = 0b10,

177

    Unsegmented = 0b11,

178

179

180

impl TryFrom<u8> for SequenceFlags {

181

    type Error = ();

182

183

52

    fn try_from(value: u8) -> Result<Self, Self::Error> {

184

52

        match value {

185

52

            x if x == SequenceFlags::ContinuationSegment as u8 => {

186

4

                Ok(SequenceFlags::ContinuationSegment)

187

188

48

            x if x == SequenceFlags::FirstSegment as u8 => Ok(SequenceFlags::FirstSegment),

189

46

            x if x == SequenceFlags::LastSegment as u8 => Ok(SequenceFlags::LastSegment),

190

44

            x if x == SequenceFlags::Unsegmented as u8 => Ok(SequenceFlags::Unsegmented),

191

2

            _ => Err(()),

192

193

52

194

195

196

/// Abstraction for the CCSDS Packet ID, which forms the last thirteen bits

197

/// of the first two bytes in the CCSDS primary header.

198

#[derive(Debug, Eq, Copy, Clone)]

199

8

#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]

200

#[cfg_attr(feature = "defmt", derive(defmt::Format))]

201

pub struct PacketId {

202

    pub ptype: PacketType,

203

    pub sec_header_flag: bool,

204

    apid: u16,

205

206

207

impl PartialEq for PacketId {

208

    #[inline]

209

38

    fn eq(&self, other: &Self) -> bool {

210

38

        self.raw().eq(&other.raw())

211

38

212

213

214

impl PartialOrd for PacketId {

215

    #[inline]

216

4

    fn partial_cmp(&self, other: &Self) -> Option<core::cmp::Ordering> {

217

4

        Some(self.cmp(other))

218

4

219

220

221

impl Ord for PacketId {

222

    #[inline]

223

6

    fn cmp(&self, other: &Self) -> core::cmp::Ordering {

224

6

        self.raw().cmp(&other.raw())

225

6

226

227

228

impl Hash for PacketId {

229

2

    fn hash<H: core::hash::Hasher>(&self, state: &mut H) {

230

2

        let raw = self.raw();

231

2

        raw.hash(state);

232

2

233

234

235

impl Default for PacketId {

236

    #[inline]

237

2

    fn default() -> Self {

238

2

        PacketId {

239

2

            ptype: PacketType::Tm,

240

2

            sec_header_flag: false,

241

2

            apid: 0,

242

2

243

2

244

245

246

impl PacketId {

247

    /// This constructor will panic if the passed APID exceeds [MAX_APID].

248

    /// Use the checked constructor variants to avoid panics.

249

    #[inline]

250

2

    pub const fn new_for_tc(sec_header: bool, apid: u16) -> Self {

251

2

        Self::new(PacketType::Tc, sec_header, apid)

252

2

253

254

    /// This constructor will panic if the passed APID exceeds [MAX_APID].

255

    /// Use the checked constructor variants to avoid panics.

256

    #[inline]

257

    pub const fn new_for_tm(sec_header: bool, apid: u16) -> Self {

258

        Self::new(PacketType::Tm, sec_header, apid)

259

260

261

    #[inline]

262

2

    pub fn new_for_tc_checked(sec_header: bool, apid: u16) -> Option<Self> {

263

2

        Self::new_checked(PacketType::Tc, sec_header, apid)

264

2

265

266

    #[inline]

267

2

    pub fn new_for_tm_checked(sec_header: bool, apid: u16) -> Option<Self> {

268

2

        Self::new_checked(PacketType::Tm, sec_header, apid)

269

2

270

271

    /// This constructor will panic if the passed APID exceeds [MAX_APID].

272

    /// Use the checked variants to avoid panics.

273

    #[inline]

274

138

    pub const fn new(ptype: PacketType, sec_header: bool, apid: u16) -> Self {

275

138

        if apid > MAX_APID {

276

            panic!("APID too large");

277

138

278

138

        PacketId {

279

138

            ptype,

280

138

            sec_header_flag: sec_header,

281

138

            apid,

282

138

283

138

284

285

    #[inline]

286

16

    pub fn new_checked(ptype: PacketType, sec_header_flag: bool, apid: u16) -> Option<PacketId> {

287

16

        if apid > MAX_APID {

288

2

            return None;

289

14

290

14

        Some(PacketId::new(ptype, sec_header_flag, apid))

291

16

292

293

    /// Set a new Application Process ID (APID). If the passed number is invalid, the APID will

294

    /// not be set and false will be returned. The maximum allowed value for the 11-bit field is

295

    /// 2047

296

    #[inline]

297

8

    pub fn set_apid(&mut self, apid: u16) -> bool {

298

8

        if apid > MAX_APID {

299

2

            return false;

300

6

301

6

        self.apid = apid;

302

6

        true

303

8

304

305

    #[inline]

306

4

    pub fn apid(&self) -> u16 {

307

4

        self.apid

308

4

309

310

    #[inline]

311

252

    pub fn raw(&self) -> u16 {

312

252

        ((self.ptype as u16) << 12) | ((self.sec_header_flag as u16) << 11) | self.apid

313

252

314

315

316

impl From<u16> for PacketId {

317

52

    fn from(raw_id: u16) -> Self {

318

52

        PacketId {

319

52

            ptype: PacketType::try_from(((raw_id >> 12) & 0b1) as u8).unwrap(),

320

52

            sec_header_flag: ((raw_id >> 11) & 0b1) != 0,

321

52

            apid: raw_id & 0x7FF,

322

52

323

52

324

325

326

/// Abstraction for the CCSDS Packet Sequence Control (PSC) field which is the

327

/// third and the fourth byte in the CCSDS primary header.

328

#[derive(Debug, PartialEq, Eq, Copy, Clone)]

329

8

#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]

330

#[cfg_attr(feature = "defmt", derive(defmt::Format))]

331

pub struct PacketSequenceCtrl {

332

    pub seq_flags: SequenceFlags,

333

    seq_count: u16,

334

335

336

impl PacketSequenceCtrl {

337

    /// This constructor panics if the sequence count exceeds [MAX_SEQ_COUNT].

338

    /// Use [Self::new_checked] to avoid panics.

339

    #[inline]

340

126

    pub const fn new(seq_flags: SequenceFlags, seq_count: u16) -> PacketSequenceCtrl {

341

126

        if seq_count > MAX_SEQ_COUNT {

342

            panic!("Sequence count too large");

343

126

344

126

        PacketSequenceCtrl {

345

126

            seq_flags,

346

126

            seq_count,

347

126

348

126

349

350

    /// Returns [None] if the passed sequence count exceeds [MAX_SEQ_COUNT].

351

    #[inline]

352

8

    pub fn new_checked(seq_flags: SequenceFlags, seq_count: u16) -> Option<PacketSequenceCtrl> {

353

8

        if seq_count > MAX_SEQ_COUNT {

354

2

            return None;

355

6

356

6

        Some(PacketSequenceCtrl::new(seq_flags, seq_count))

357

8

358

359

    #[inline]

360

86

    pub fn raw(&self) -> u16 {

361

86

        ((self.seq_flags as u16) << 14) | self.seq_count

362

86

363

364

    /// Set a new sequence count. If the passed number is invalid, the sequence count will not be

365

    /// set and false will be returned. The maximum allowed value for the 14-bit field is 16383.

366

    #[inline]

367

8

    pub fn set_seq_count(&mut self, ssc: u16) -> bool {

368

8

        if ssc > MAX_SEQ_COUNT {

369

4

            return false;

370

4

371

4

        self.seq_count = ssc;

372

4

        true

373

8

374

375

    #[inline]

376

2

    pub fn seq_count(&self) -> u16 {

377

2

        self.seq_count

378

2

379

380

381

impl From<u16> for PacketSequenceCtrl {

382

42

    fn from(raw_id: u16) -> Self {

383

42

        PacketSequenceCtrl {

384

42

            seq_flags: SequenceFlags::try_from(((raw_id >> 14) & 0b11) as u8).unwrap(),

385

42

            seq_count: raw_id & SSC_MASK,

386

42

387

42

388

389

390

macro_rules! sph_from_other {

391

    ($Self: path, $other: path) => {

392

        impl From<$other> for $Self {

393

114

            fn from(other: $other) -> Self {

394

114

                Self::from_composite_fields(

395

114

                    other.packet_id(),

396

114

                    other.psc(),

397

114

                    other.data_len(),

398

114

                    Some(other.ccsds_version()),

399

114

400

114

401

402

};

403

404

405

const SSC_MASK: u16 = 0x3FFF;

406

const VERSION_MASK: u16 = 0xE000;

407

408

/// Generic trait to access fields of a CCSDS space packet header according to CCSDS 133.0-B-2.

409

pub trait CcsdsPacket {

410

    fn ccsds_version(&self) -> u8;

411

    fn packet_id(&self) -> PacketId;

412

    fn psc(&self) -> PacketSequenceCtrl;

413

414

    /// Retrieve data length field

415

    fn data_len(&self) -> u16;

416

    /// Retrieve the total packet size based on the data length field

417

    #[inline]

418

64

    fn total_len(&self) -> usize {

419

64

        usize::from(self.data_len()) + CCSDS_HEADER_LEN + 1

420

64

421

422

    /// Retrieve 13 bit Packet Identification field. Can usually be retrieved with a bitwise AND

423

    /// of the first 2 bytes with 0x1FFF.

424

    #[inline]

425

4

    fn packet_id_raw(&self) -> u16 {

426

4

        self.packet_id().raw()

427

4

428

    /// Retrieve Packet Sequence Count

429

    #[inline]

430

4

    fn psc_raw(&self) -> u16 {

431

4

        self.psc().raw()

432

4

433

434

    /// Retrieve Packet Type (TM: 0, TC: 1).

435

    #[inline]

436

42

    fn ptype(&self) -> PacketType {

437

42

        // This call should never fail because only 0 and 1 can be passed to the try_from call

438

42

        self.packet_id().ptype

439

42

440

441

    #[inline]

442

10

    fn is_tm(&self) -> bool {

443

10

        self.ptype() == PacketType::Tm

444

10

445

446

    #[inline]

447

4

    fn is_tc(&self) -> bool {

448

4

        self.ptype() == PacketType::Tc

449

4

450

451

    /// Retrieve the secondary header flag. Returns true if a secondary header is present

452

    /// and false if it is not.

453

    #[inline]

454

32

    fn sec_header_flag(&self) -> bool {

455

32

        self.packet_id().sec_header_flag

456

32

457

458

    /// Retrieve Application Process ID.

459

    #[inline]

460

60

    fn apid(&self) -> u16 {

461

60

        self.packet_id().apid

462

60

463

464

    #[inline]

465

50

    fn seq_count(&self) -> u16 {

466

50

        self.psc().seq_count

467

50

468

469

    #[inline]

470

24

    fn sequence_flags(&self) -> SequenceFlags {

471

24

        // This call should never fail because the mask ensures that only valid values are passed

472

24

        // into the try_from function

473

24

        self.psc().seq_flags

474

24

475

476

477

pub trait CcsdsPrimaryHeader {

478

    fn from_composite_fields(

479

        packet_id: PacketId,

480

        psc: PacketSequenceCtrl,

481

        data_len: u16,

482

        version: Option<u8>,

483

    ) -> Self;

484

485

486

/// Space Packet Primary Header according to CCSDS 133.0-B-2.

487

///

488

/// # Arguments

489

///

490

/// * `version` - CCSDS version field, occupies the first 3 bits of the raw header. Will generally

491

///    be set to 0b000 in all constructors provided by this crate.

492

/// * `packet_id` - Packet Identifier, which can also be used as a start marker. Occupies the last

493

///    13 bits of the first two bytes of the raw header

494

/// * `psc` - Packet Sequence Control, occupies the third and fourth byte of the raw header

495

/// * `data_len` - Data length field occupies the fifth and the sixth byte of the raw header

496

#[derive(Debug, PartialEq, Eq, Copy, Clone)]

497

8

#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]

498

#[cfg_attr(feature = "defmt", derive(defmt::Format))]

499

pub struct SpHeader {

500

    pub version: u8,

501

    pub packet_id: PacketId,

502

    pub psc: PacketSequenceCtrl,

503

    pub data_len: u16,

504

505

506

pub type SpacePacketHeader = SpHeader;

507

508

impl Default for SpHeader {

509

    /// The default function sets the sequence flag field to [SequenceFlags::Unsegmented] and the

510

    /// data length to 0.

511

    #[inline]

512

    fn default() -> Self {

513

        SpHeader {

514

            version: 0,

515

            packet_id: PacketId::default(),

516

            psc: PacketSequenceCtrl {

517

                seq_flags: SequenceFlags::Unsegmented,

518

                seq_count: 0,

519

},

520

            data_len: 0,

521

522

523

524

525

impl SpHeader {

526

    #[inline]

527

    pub const fn new(packet_id: PacketId, psc: PacketSequenceCtrl, data_len: u16) -> Self {

528

        Self {

529

            version: 0,

530

            packet_id,

531

            psc,

532

            data_len,

533

534

535

536

    /// This constructor sets the sequence flag field to [SequenceFlags::Unsegmented] and the data

537

    /// length to 0.

538

///

539

    /// This constructor will panic if the APID exceeds [MAX_APID].

540

    #[inline]

541

2

    pub const fn new_from_apid(apid: u16) -> Self {

542

2

        SpHeader {

543

2

            version: 0,

544

2

            packet_id: PacketId::new(PacketType::Tm, false, apid),

545

2

            psc: PacketSequenceCtrl {

546

2

                seq_flags: SequenceFlags::Unsegmented,

547

2

                seq_count: 0,

548

2

},

549

2

            data_len: 0,

550

2

551

2

552

553

    /// Checked variant of [Self::new_from_apid].

554

    #[inline]

555

2

    pub fn new_from_apid_checked(apid: u16) -> Option<Self> {

556

2

        Some(SpHeader {

557

2

            version: 0,

558

2

            packet_id: PacketId::new_checked(PacketType::Tm, false, apid)?,

559

2

            psc: PacketSequenceCtrl {

560

2

                seq_flags: SequenceFlags::Unsegmented,

561

2

                seq_count: 0,

562

2

},

563

            data_len: 0,

564

})

565

2

566

567

    /// This constructor panics if the passed APID exceeds [MAX_APID] or the passed packet sequence

568

    /// count exceeds [MAX_SEQ_COUNT].

569

///

570

    /// The checked constructor variants can be used to avoid panics.

571

    #[inline]

572

118

    pub const fn new_from_fields(

573

118

        ptype: PacketType,

574

118

        sec_header: bool,

575

118

        apid: u16,

576

118

        seq_flags: SequenceFlags,

577

118

        seq_count: u16,

578

118

        data_len: u16,

579

118

    ) -> Self {

580

118

        if seq_count > MAX_SEQ_COUNT {

581

            panic!("Sequence count is too large");

582

118

583

118

        if apid > MAX_APID {

584

            panic!("APID is too large");

585

118

586

118

        Self {

587

118

            psc: PacketSequenceCtrl::new(seq_flags, seq_count),

588

118

            packet_id: PacketId::new(ptype, sec_header, apid),

589

118

            data_len,

590

118

            version: 0,

591

118

592

118

593

594

    /// Create a new Space Packet Header instance which can be used to create generic

595

    /// Space Packets.

596

///

597

    /// This will return [None] if the APID or sequence count argument

598

    /// exceed [MAX_APID] or [MAX_SEQ_COUNT] respectively. The version field is set to 0b000.

599

    #[inline]

600

112

    pub fn new_from_fields_checked(

601

112

        ptype: PacketType,

602

112

        sec_header: bool,

603

112

        apid: u16,

604

112

        seq_flags: SequenceFlags,

605

112

        seq_count: u16,

606

112

        data_len: u16,

607

112

    ) -> Option<Self> {

608

112

        if seq_count > MAX_SEQ_COUNT || apid > MAX_APID {

609

            return None;

610

112

611

112

        Some(SpHeader::new_from_fields(

612

112

            ptype, sec_header, apid, seq_flags, seq_count, data_len,

613

112

))

614

112

615

616

    /// Helper function for telemetry space packet headers. The packet type field will be

617

    /// set accordingly. The secondary header flag field is set to false.

618

    #[inline]

619

52

    pub fn new_for_tm_checked(

620

52

        apid: u16,

621

52

        seq_flags: SequenceFlags,

622

52

        seq_count: u16,

623

52

        data_len: u16,

624

52

    ) -> Option<Self> {

625

52

        Self::new_from_fields_checked(PacketType::Tm, false, apid, seq_flags, seq_count, data_len)

626

52

627

628

    /// Helper function for telemetry space packet headers. The packet type field will be

629

    /// set accordingly. The secondary header flag field is set to false.

630

    #[inline]

631

60

    pub fn new_for_tc_checked(

632

60

        apid: u16,

633

60

        seq_flags: SequenceFlags,

634

60

        seq_count: u16,

635

60

        data_len: u16,

636

60

    ) -> Option<Self> {

637

60

        Self::new_from_fields_checked(PacketType::Tc, false, apid, seq_flags, seq_count, data_len)

638

60

639

640

    /// This is an unchecked constructor which can panic on invalid input.

641

    #[inline]

642

2

    pub const fn new_for_tm(

643

2

        apid: u16,

644

2

        seq_flags: SequenceFlags,

645

2

        seq_count: u16,

646

2

        data_len: u16,

647

2

    ) -> Self {

648

2

        Self::new_from_fields(PacketType::Tm, false, apid, seq_flags, seq_count, data_len)

649

2

650

651

    /// This is an unchecked constructor which can panic on invalid input.

652

    #[inline]

653

4

    pub const fn new_for_tc(

654

4

        apid: u16,

655

4

        seq_flags: SequenceFlags,

656

4

        seq_count: u16,

657

4

        data_len: u16,

658

4

    ) -> Self {

659

4

        Self::new_from_fields(PacketType::Tc, false, apid, seq_flags, seq_count, data_len)

660

4

661

662

    /// Variant of [SpHeader::new_for_tm_checked] which sets the sequence flag field to [SequenceFlags::Unsegmented]

663

    #[inline]

664

50

    pub fn new_for_unseg_tm_checked(apid: u16, seq_count: u16, data_len: u16) -> Option<Self> {

665

50

        Self::new_for_tm_checked(apid, SequenceFlags::Unsegmented, seq_count, data_len)

666

50

667

668

    /// Variant of [SpHeader::new_for_tc_checked] which sets the sequence flag field to [SequenceFlags::Unsegmented]

669

    #[inline]

670

56

    pub fn new_for_unseg_tc_checked(apid: u16, seq_count: u16, data_len: u16) -> Option<Self> {

671

56

        Self::new_for_tc_checked(apid, SequenceFlags::Unsegmented, seq_count, data_len)

672

56

673

674

    /// Variant of [SpHeader::new_for_tc] which sets the sequence flag field to [SequenceFlags::Unsegmented].

675

///

676

    /// This is an unchecked constructor which can panic on invalid input.

677

    #[inline]

678

4

    pub const fn new_for_unseg_tc(apid: u16, seq_count: u16, data_len: u16) -> Self {

679

4

        Self::new_for_tc(apid, SequenceFlags::Unsegmented, seq_count, data_len)

680

4

681

682

    /// Variant of [SpHeader::new_for_tm] which sets the sequence flag field to [SequenceFlags::Unsegmented].

683

///

684

    /// This is an unchecked constructor which can panic on invalid input.

685

    #[inline]

686

    pub const fn new_for_unseg_tm(apid: u16, seq_count: u16, data_len: u16) -> Self {

687

        Self::new_for_tm(apid, SequenceFlags::Unsegmented, seq_count, data_len)

688

689

690

    delegate! {

691

        to self.packet_id {

692

            /// Returns [false] and fails if the APID exceeds [MAX_APID]

693

            #[inline]

694

6

            pub fn set_apid(&mut self, apid: u16) -> bool;

695

696

697

698

    delegate! {

699

        to self.psc {

700

            /// Returns [false] and fails if the sequence count exceeds [MAX_SEQ_COUNT]

701

            #[inline]

702

4

            pub fn set_seq_count(&mut self, seq_count: u16) -> bool;

703

704

705

706

    #[inline]

707

2

    pub fn set_seq_flags(&mut self, seq_flags: SequenceFlags) {

708

2

        self.psc.seq_flags = seq_flags;

709

2

710

711

    #[inline]

712

98

    pub fn set_sec_header_flag(&mut self) {

713

98

        self.packet_id.sec_header_flag = true;

714

98

715

716

    #[inline]

717

2

    pub fn clear_sec_header_flag(&mut self) {

718

2

        self.packet_id.sec_header_flag = false;

719

2

720

721

    #[inline]

722

86

    pub fn set_packet_type(&mut self, packet_type: PacketType) {

723

86

        self.packet_id.ptype = packet_type;

724

86

725

726

    /// Create a struct from a raw slice where the fields have network endianness (big).

727

    /// This function also returns the remaining part of the passed slice starting past the read

728

    /// CCSDS header.

729

38

    pub fn from_be_bytes(buf: &[u8]) -> Result<(Self, &[u8]), ByteConversionError> {

730

38

        if buf.len() < CCSDS_HEADER_LEN {

731

            return Err(ByteConversionError::FromSliceTooSmall {

732

                found: buf.len(),

733

                expected: CCSDS_HEADER_LEN,

734

});

735

38

736

38

        let zc_header = zc::SpHeader::from_bytes(&buf[0..CCSDS_HEADER_LEN])

737

38

            .ok_or(ByteConversionError::ZeroCopyFromError)?;

738

38

        Ok((Self::from(zc_header), &buf[CCSDS_HEADER_LEN..]))

739

38

740

741

    /// Write the header to a raw buffer using big endian format. This function returns the

742

    /// remaining part of the passed slice starting past the written CCSDS header.

743

52

    pub fn write_to_be_bytes<'a>(

744

52

        &self,

745

52

        buf: &'a mut [u8],

746

52

    ) -> Result<&'a mut [u8], ByteConversionError> {

747

52

        if buf.len() < CCSDS_HEADER_LEN {

748

            return Err(ByteConversionError::FromSliceTooSmall {

749

                found: buf.len(),

750

                expected: CCSDS_HEADER_LEN,

751

});

752

52

753

52

        let zc_header: zc::SpHeader = zc::SpHeader::from(*self);

754

52

        zc_header

755

52

            .to_bytes(&mut buf[0..CCSDS_HEADER_LEN])

756

52

            .ok_or(ByteConversionError::ZeroCopyToError)?;

757

52

        Ok(&mut buf[CCSDS_HEADER_LEN..])

758

52

759

760

    /// Create a vector containing the CCSDS header.

761

    #[cfg(feature = "alloc")]

762

2

    pub fn to_vec(&self) -> alloc::vec::Vec<u8> {

763

2

        let mut vec = alloc::vec![0; CCSDS_HEADER_LEN];

764

2

        // This can not fail.

765

2

        self.write_to_be_bytes(&mut vec[..]).unwrap();

766

2

vec

767

2

768

769

770

impl CcsdsPacket for SpHeader {

771

    #[inline]

772

86

    fn ccsds_version(&self) -> u8 {

773

86

        self.version

774

86

775

776

    #[inline]

777

208

    fn packet_id(&self) -> PacketId {

778

208

        self.packet_id

779

208

780

781

    #[inline]

782

152

    fn psc(&self) -> PacketSequenceCtrl {

783

152

        self.psc

784

152

785

786

    #[inline]

787

164

    fn data_len(&self) -> u16 {

788

164

        self.data_len

789

164

790

791

792

impl CcsdsPrimaryHeader for SpHeader {

793

    #[inline]

794

40

    fn from_composite_fields(

795

40

        packet_id: PacketId,

796

40

        psc: PacketSequenceCtrl,

797

40

        data_len: u16,

798

40

        version: Option<u8>,

799

40

    ) -> Self {

800

40

        let mut version_to_set = 0b000;

801

40

        if let Some(version) = version {

802

38

            version_to_set = version;

803

38

804

40

        SpHeader {

805

40

            version: version_to_set,

806

40

            packet_id,

807

40

            psc,

808

40

            data_len,

809

40

810

40

811

812

813

sph_from_other!(SpHeader, crate::zc::SpHeader);

814

815

pub mod zc {

816

    use crate::{CcsdsPacket, CcsdsPrimaryHeader, PacketId, PacketSequenceCtrl, VERSION_MASK};

817

    use zerocopy::byteorder::NetworkEndian;

818

    use zerocopy::{AsBytes, FromBytes, FromZeroes, Unaligned, U16};

819

820

    #[derive(FromBytes, FromZeroes, AsBytes, Unaligned, Debug)]

821

    #[repr(C)]

822

    pub struct SpHeader {

823

        version_packet_id: U16<NetworkEndian>,

824

        psc: U16<NetworkEndian>,

825

        data_len: U16<NetworkEndian>,

826

827

828

    impl SpHeader {

829

76

        pub fn new(

830

76

            packet_id: PacketId,

831

76

            psc: PacketSequenceCtrl,

832

76

            data_len: u16,

833

76

            version: Option<u8>,

834

76

        ) -> Self {

835

76

            let mut version_packet_id = packet_id.raw();

836

76

            if let Some(version) = version {

837

76

                version_packet_id = ((version as u16) << 13) | packet_id.raw()

838

839

76

            SpHeader {

840

76

                version_packet_id: U16::from(version_packet_id),

841

76

                psc: U16::from(psc.raw()),

842

76

                data_len: U16::from(data_len),

843

76

844

76

845

846

56

        pub fn from_bytes(slice: &[u8]) -> Option<Self> {

847

56

            SpHeader::read_from(slice)

848

56

849

850

52

        pub fn to_bytes(&self, slice: &mut [u8]) -> Option<()> {

851

52

            self.write_to(slice)

852

52

853

854

855

    impl CcsdsPacket for SpHeader {

856

        #[inline]

857

40

        fn ccsds_version(&self) -> u8 {

858

40

            ((self.version_packet_id.get() >> 13) as u8) & 0b111

859

40

860

861

        #[inline]

862

44

        fn packet_id(&self) -> PacketId {

863

44

            PacketId::from(self.packet_id_raw())

864

44

865

866

        #[inline]

867

40

        fn psc(&self) -> PacketSequenceCtrl {

868

40

            PacketSequenceCtrl::from(self.psc_raw())

869

40

870

871

        #[inline]

872

58

        fn data_len(&self) -> u16 {

873

58

            self.data_len.get()

874

58

875

876

        #[inline]

877

46

        fn packet_id_raw(&self) -> u16 {

878

46

            self.version_packet_id.get() & (!VERSION_MASK)

879

46

880

881

        #[inline]

882

40

        fn psc_raw(&self) -> u16 {

883

40

            self.psc.get()

884

40

885

886

887

    impl CcsdsPrimaryHeader for SpHeader {

888

76

        fn from_composite_fields(

889

76

            packet_id: PacketId,

890

76

            psc: PacketSequenceCtrl,

891

76

            data_len: u16,

892

76

            version: Option<u8>,

893

76

        ) -> Self {

894

76

            SpHeader::new(packet_id, psc, data_len, version)

895

76

896

897

898

    sph_from_other!(SpHeader, crate::SpHeader);

899

900

901

#[cfg(all(test, feature = "std"))]

902

pub(crate) mod tests {

903

    use std::collections::HashSet;

904

905

    #[allow(unused_imports)]

906

    use crate::ByteConversionError;

907

    #[cfg(feature = "serde")]

908

    use crate::CcsdsPrimaryHeader;

909

    use crate::{

910

        packet_type_in_raw_packet_id, zc, CcsdsPacket, PacketId, PacketSequenceCtrl, PacketType,

911

};

912

    use crate::{SequenceFlags, SpHeader};

913

    use alloc::vec;

914

    #[cfg(feature = "serde")]

915

    use core::fmt::Debug;

916

    use num_traits::pow;

917

    #[cfg(feature = "serde")]

918

    use postcard::{from_bytes, to_allocvec};

919

    #[cfg(feature = "serde")]

920

    use serde::{de::DeserializeOwned, Serialize};

921

922

    const CONST_SP: SpHeader = SpHeader::new(

923

        PacketId::new_for_tc(true, 0x36),

924

        PacketSequenceCtrl::new(SequenceFlags::ContinuationSegment, 0x88),

925

        0x90,

926

);

927

928

    const PACKET_ID_TM: PacketId = PacketId::new_for_tm(true, 0x22);

929

930

    #[cfg(feature = "serde")]

931

26

    pub(crate) fn generic_serde_test<T: Serialize + DeserializeOwned + PartialEq + Debug>(

932

26

        value: T,

933

26

) {

934

26

        let output: alloc::vec::Vec<u8> = to_allocvec(&value).unwrap();

935

26

        let output_converted_back: T = from_bytes(&output).unwrap();

936

26

        assert_eq!(output_converted_back, value);

937

26

938

939

    #[test]

940

    #[allow(clippy::assertions_on_constants)]

941

2

    fn verify_const_packet_id() {

942

2

        assert_eq!(PACKET_ID_TM.apid(), 0x22);

943

2

        assert!(PACKET_ID_TM.sec_header_flag);

944

2

        assert_eq!(PACKET_ID_TM.ptype, PacketType::Tm);

945

2

        let const_tc_id = PacketId::new_for_tc(true, 0x23);

946

2

        assert_eq!(const_tc_id.ptype, PacketType::Tc);

947

2

948

949

    #[test]

950

2

    fn test_default_packet_id() {

951

2

        let id_default = PacketId::default();

952

2

        assert_eq!(id_default.ptype, PacketType::Tm);

953

2

        assert_eq!(id_default.apid, 0x000);

954

2

        assert!(!id_default.sec_header_flag);

955

2

956

957

    #[test]

958

2

    fn test_packet_id_ctors() {

959

2

        let packet_id = PacketId::new_checked(PacketType::Tc, true, 0x1ff);

960

2

        assert!(packet_id.is_some());

961

2

        let packet_id = packet_id.unwrap();

962

2

        assert_eq!(packet_id.apid(), 0x1ff);

963

2

        assert_eq!(packet_id.ptype, PacketType::Tc);

964

2

        assert!(packet_id.sec_header_flag);

965

2

        let packet_id_tc = PacketId::new_for_tc_checked(true, 0x1ff);

966

2

        assert!(packet_id_tc.is_some());

967

2

        let packet_id_tc = packet_id_tc.unwrap();

968

2

        assert_eq!(packet_id_tc, packet_id);

969

2

        let packet_id_tm = PacketId::new_for_tm_checked(true, 0x2ff);

970

2

        assert!(packet_id_tm.is_some());

971

2

        let packet_id_tm = packet_id_tm.unwrap();

972

2

        assert!(packet_id_tm.sec_header_flag);

973

2

        assert_eq!(packet_id_tm.ptype, PacketType::Tm);

974

2

        assert_eq!(packet_id_tm.apid, 0x2ff);

975

2

976

977

    #[test]

978

2

    fn verify_const_sp_header() {

979

2

        assert!(CONST_SP.sec_header_flag());

980

2

        assert_eq!(CONST_SP.apid(), 0x36);

981

2

        assert_eq!(

982

2

            CONST_SP.sequence_flags(),

983

2

            SequenceFlags::ContinuationSegment

984

2

);

985

2

        assert_eq!(CONST_SP.seq_count(), 0x88);

986

2

        assert_eq!(CONST_SP.data_len, 0x90);

987

2

988

989

    #[test]

990

2

    fn test_seq_flag_helpers() {

991

2

        assert_eq!(

992

2

            SequenceFlags::try_from(0b00).expect("SEQ flag creation failed"),

993

2

            SequenceFlags::ContinuationSegment

994

2

);

995

2

        assert_eq!(

996

2

            SequenceFlags::try_from(0b01).expect("SEQ flag creation failed"),

997

2

            SequenceFlags::FirstSegment

998

2

);

999

2

        assert_eq!(

1000

2

            SequenceFlags::try_from(0b10).expect("SEQ flag creation failed"),

1001

2

            SequenceFlags::LastSegment

1002

2

);

1003

2

        assert_eq!(

1004

2

            SequenceFlags::try_from(0b11).expect("SEQ flag creation failed"),

1005

2

            SequenceFlags::Unsegmented

1006

2

);

1007

2

        assert!(SequenceFlags::try_from(0b100).is_err());

1008

2

1009

1010

    #[test]

1011

2

    fn test_packet_type_helper() {

1012

2

        assert_eq!(PacketType::try_from(0b00).unwrap(), PacketType::Tm);

1013

2

        assert_eq!(PacketType::try_from(0b01).unwrap(), PacketType::Tc);

1014

2

        assert!(PacketType::try_from(0b10).is_err());

1015

2

1016

1017

    #[test]

1018

2

    fn test_packet_id() {

1019

2

        let packet_id =

1020

2

            PacketId::new_checked(PacketType::Tm, false, 0x42).expect("Packet ID creation failed");

1021

2

        assert_eq!(packet_id.raw(), 0x0042);

1022

2

        let packet_id_from_raw = PacketId::from(packet_id.raw());

1023

2

        assert_eq!(

1024

2

            packet_type_in_raw_packet_id(packet_id.raw()),

1025

2

            PacketType::Tm

1026

2

);

1027

2

        assert_eq!(packet_id_from_raw, packet_id);

1028

2

        let packet_id_from_new = PacketId::new_checked(PacketType::Tm, false, 0x42).unwrap();

1029

2

        assert_eq!(packet_id_from_new, packet_id);

1030

2

1031

1032

    #[test]

1033

2

    fn test_invalid_packet_id() {

1034

2

        let packet_id_invalid = PacketId::new_checked(PacketType::Tc, true, 0xFFFF);

1035

2

        assert!(packet_id_invalid.is_none());

1036

2

1037

1038

    #[test]

1039

2

    fn test_invalid_apid_setter() {

1040

2

        let mut packet_id =

1041

2

            PacketId::new_checked(PacketType::Tm, false, 0x42).expect("Packet ID creation failed");

1042

2

        assert!(!packet_id.set_apid(0xffff));

1043

2

1044

1045

    #[test]

1046

2

    fn test_invalid_seq_count() {

1047

2

        let mut psc = PacketSequenceCtrl::new_checked(SequenceFlags::ContinuationSegment, 77)

1048

2

            .expect("PSC creation failed");

1049

2

        assert_eq!(psc.seq_count(), 77);

1050

2

        assert!(!psc.set_seq_count(0xffff));

1051

2

1052

1053

    #[test]

1054

2

    fn test_packet_seq_ctrl() {

1055

2

        let mut psc = PacketSequenceCtrl::new_checked(SequenceFlags::ContinuationSegment, 77)

1056

2

            .expect("PSC creation failed");

1057

2

        assert_eq!(psc.raw(), 77);

1058

2

        let psc_from_raw = PacketSequenceCtrl::from(psc.raw());

1059

2

        assert_eq!(psc_from_raw, psc);

1060

        // Fails because SSC is limited to 14 bits

1061

2

        assert!(!psc.set_seq_count(2u16.pow(15)));

1062

2

        assert_eq!(psc.raw(), 77);

1063

1064

2

        let psc_invalid = PacketSequenceCtrl::new_checked(SequenceFlags::FirstSegment, 0xFFFF);

1065

2

        assert!(psc_invalid.is_none());

1066

2

        let psc_from_new =

1067

2

            PacketSequenceCtrl::new_checked(SequenceFlags::ContinuationSegment, 77).unwrap();

1068

2

        assert_eq!(psc_from_new, psc);

1069

2

1070

1071

    #[test]

1072

    #[cfg(feature = "serde")]

1073

2

    fn test_serde_sph() {

1074

2

        let sp_header =

1075

2

            SpHeader::new_for_unseg_tc_checked(0x42, 12, 0).expect("Error creating SP header");

1076

2

        assert_eq!(sp_header.ccsds_version(), 0b000);

1077

2

        assert!(sp_header.is_tc());

1078

2

        assert!(!sp_header.sec_header_flag());

1079

2

        assert_eq!(sp_header.ptype(), PacketType::Tc);

1080

2

        assert_eq!(sp_header.seq_count(), 12);

1081

2

        assert_eq!(sp_header.apid(), 0x42);

1082

2

        assert_eq!(sp_header.sequence_flags(), SequenceFlags::Unsegmented);

1083

2

        assert_eq!(sp_header.data_len(), 0);

1084

2

        let output = to_allocvec(&sp_header).unwrap();

1085

2

        let sp_header: SpHeader = from_bytes(&output).unwrap();

1086

2

        assert_eq!(sp_header.version, 0b000);

1087

2

        assert!(!sp_header.packet_id.sec_header_flag);

1088

2

        assert_eq!(sp_header.ptype(), PacketType::Tc);

1089

2

        assert_eq!(sp_header.seq_count(), 12);

1090

2

        assert_eq!(sp_header.apid(), 0x42);

1091

2

        assert_eq!(sp_header.sequence_flags(), SequenceFlags::Unsegmented);

1092

2

        assert_eq!(sp_header.packet_id_raw(), 0x1042);

1093

2

        assert_eq!(sp_header.psc_raw(), 0xC00C);

1094

2

        assert_eq!(sp_header.ccsds_version(), 0b000);

1095

2

        assert_eq!(sp_header.data_len, 0);

1096

1097

2

        let sp_header =

1098

2

            SpHeader::new_for_unseg_tm_checked(0x7, 22, 36).expect("Error creating SP header");

1099

2

        assert_eq!(sp_header.ccsds_version(), 0b000);

1100

2

        assert!(sp_header.is_tm());

1101

2

        assert!(!sp_header.sec_header_flag());

1102

2

        assert_eq!(sp_header.ptype(), PacketType::Tm);

1103

2

        assert_eq!(sp_header.seq_count(), 22);

1104

2

        assert_eq!(sp_header.apid(), 0x07);

1105

2

        assert_eq!(sp_header.sequence_flags(), SequenceFlags::Unsegmented);

1106

2

        assert_eq!(sp_header.packet_id_raw(), 0x0007);

1107

2

        assert_eq!(sp_header.psc_raw(), 0xC016);

1108

2

        assert_eq!(sp_header.data_len(), 36);

1109

2

        assert_eq!(sp_header.ccsds_version(), 0b000);

1110

1111

2

        let from_comp_fields = SpHeader::from_composite_fields(

1112

2

            PacketId::new(PacketType::Tc, true, 0x42),

1113

2

            PacketSequenceCtrl::new(SequenceFlags::Unsegmented, 0x7),

1114

2

0,

1115

2

            None,

1116

2

);

1117

2

        assert_eq!(from_comp_fields.ptype(), PacketType::Tc);

1118

2

        assert_eq!(from_comp_fields.apid(), 0x42);

1119

2

        assert!(from_comp_fields.sec_header_flag());

1120

2

        assert_eq!(

1121

2

            from_comp_fields.sequence_flags(),

1122

2

            SequenceFlags::Unsegmented

1123

2

);

1124

2

        assert_eq!(from_comp_fields.seq_count(), 0x7);

1125

2

        assert_eq!(from_comp_fields.data_len(), 0);

1126

2

1127

1128

    #[test]

1129

2

    fn test_setters() {

1130

2

        let sp_header = SpHeader::new_for_tc_checked(0x42, SequenceFlags::Unsegmented, 25, 0);

1131

2

        assert!(sp_header.is_some());

1132

2

        let mut sp_header = sp_header.unwrap();

1133

2

        sp_header.set_apid(0x12);

1134

2

        assert_eq!(sp_header.apid(), 0x12);

1135

2

        sp_header.set_sec_header_flag();

1136

2

        assert!(sp_header.sec_header_flag());

1137

2

        sp_header.clear_sec_header_flag();

1138

2

        assert!(!sp_header.sec_header_flag());

1139

2

        assert_eq!(sp_header.ptype(), PacketType::Tc);

1140

2

        sp_header.set_packet_type(PacketType::Tm);

1141

2

        assert_eq!(sp_header.ptype(), PacketType::Tm);

1142

2

        sp_header.set_seq_count(0x45);

1143

2

        assert_eq!(sp_header.seq_count(), 0x45);

1144

2

1145

1146

    #[test]

1147

2

    fn test_tc_ctor() {

1148

2

        let sp_header = SpHeader::new_for_tc_checked(0x42, SequenceFlags::Unsegmented, 25, 0);

1149

2

        assert!(sp_header.is_some());

1150

2

        let sp_header = sp_header.unwrap();

1151

2

        verify_sp_fields(PacketType::Tc, &sp_header);

1152

2

1153

1154

    #[test]

1155

2

    fn test_tc_ctor_unseg() {

1156

2

        let sp_header = SpHeader::new_for_unseg_tc_checked(0x42, 25, 0);

1157

2

        assert!(sp_header.is_some());

1158

2

        let sp_header = sp_header.unwrap();

1159

2

        verify_sp_fields(PacketType::Tc, &sp_header);

1160

2

1161

1162

    #[test]

1163

2

    fn test_tc_ctor_unseg_const() {

1164

2

        let sp_header = SpHeader::new_for_unseg_tc(0x42, 25, 0);

1165

2

        verify_sp_fields(PacketType::Tc, &sp_header);

1166

2

1167

1168

    #[test]

1169

2

    fn test_tm_ctor() {

1170

2

        let sp_header = SpHeader::new_for_tm_checked(0x42, SequenceFlags::Unsegmented, 25, 0);

1171

2

        assert!(sp_header.is_some());

1172

2

        let sp_header = sp_header.unwrap();

1173

2

        verify_sp_fields(PacketType::Tm, &sp_header);

1174

2

1175

1176

    #[test]

1177

2

    fn test_tm_ctor_const() {

1178

2

        let sp_header = SpHeader::new_for_tm(0x42, SequenceFlags::Unsegmented, 25, 0);

1179

2

        verify_sp_fields(PacketType::Tm, &sp_header);

1180

2

1181

1182

    #[test]

1183

2

    fn test_tm_ctor_unseg() {

1184

2

        let sp_header = SpHeader::new_for_unseg_tm_checked(0x42, 25, 0);

1185

2

        assert!(sp_header.is_some());

1186

2

        let sp_header = sp_header.unwrap();

1187

2

        verify_sp_fields(PacketType::Tm, &sp_header);

1188

2

1189

1190

12

    fn verify_sp_fields(ptype: PacketType, sp_header: &SpHeader) {

1191

12

        assert_eq!(sp_header.ptype(), ptype);

1192

12

        assert_eq!(sp_header.sequence_flags(), SequenceFlags::Unsegmented);

1193

12

        assert_eq!(sp_header.apid(), 0x42);

1194

12

        assert_eq!(sp_header.seq_count(), 25);

1195

12

        assert_eq!(sp_header.data_len(), 0);

1196

12

1197

1198

    #[test]

1199

2

    fn test_zc_sph() {

1200

        use zerocopy::AsBytes;

1201

1202

2

        let sp_header = SpHeader::new_for_unseg_tc_checked(0x7FF, pow(2, 14) - 1, 0)

1203

2

            .expect("Error creating SP header");

1204

2

        assert_eq!(sp_header.ptype(), PacketType::Tc);

1205

2

        assert_eq!(sp_header.apid(), 0x7FF);

1206

2

        assert_eq!(sp_header.data_len(), 0);

1207

2

        assert_eq!(sp_header.ccsds_version(), 0b000);

1208

2

        assert!(sp_header.is_tc());

1209

2

        let sp_header_zc = zc::SpHeader::from(sp_header);

1210

2

        let slice = sp_header_zc.as_bytes();

1211

2

        assert_eq!(slice.len(), 6);

1212

2

        assert_eq!(slice[0], 0x17);

1213

2

        assert_eq!(slice[1], 0xFF);

1214

2

        assert_eq!(slice[2], 0xFF);

1215

2

        assert_eq!(slice[3], 0xFF);

1216

2

        assert_eq!(slice[4], 0x00);

1217

2

        assert_eq!(slice[5], 0x00);

1218

1219

2

        let mut slice = [0; 6];

1220

2

        sp_header_zc.write_to(slice.as_mut_slice());

1221

2

        assert_eq!(slice.len(), 6);

1222

2

        assert_eq!(slice[0], 0x17);

1223

2

        assert_eq!(slice[1], 0xFF);

1224

2

        assert_eq!(slice[2], 0xFF);

1225

2

        assert_eq!(slice[3], 0xFF);

1226

2

        assert_eq!(slice[4], 0x00);

1227

2

        assert_eq!(slice[5], 0x00);

1228

1229

2

        let mut test_vec = vec![0_u8; 6];

1230

2

        let slice = test_vec.as_mut_slice();

1231

2

        sp_header_zc.write_to(slice);

1232

2

        let slice = test_vec.as_slice();

1233

2

        assert_eq!(slice.len(), 6);

1234

2

        assert_eq!(slice[0], 0x17);

1235

2

        assert_eq!(slice[1], 0xFF);

1236

2

        assert_eq!(slice[2], 0xFF);

1237

2

        assert_eq!(slice[3], 0xFF);

1238

2

        assert_eq!(slice[4], 0x00);

1239

2

        assert_eq!(slice[5], 0x00);

1240

1241

2

        let sp_header = zc::SpHeader::from_bytes(slice);

1242

2

        assert!(sp_header.is_some());

1243

2

        let sp_header = sp_header.unwrap();

1244

2

        assert_eq!(sp_header.ccsds_version(), 0b000);

1245

2

        assert_eq!(sp_header.packet_id_raw(), 0x17FF);

1246

2

        assert_eq!(sp_header.apid(), 0x7FF);

1247

2

        assert_eq!(sp_header.ptype(), PacketType::Tc);

1248

2

        assert_eq!(sp_header.data_len(), 0);

1249

2

1250

1251

    #[test]

1252

2

    fn packet_id_ord_partial_ord() {

1253

2

        let packet_id_small = PacketId::from(1_u16);

1254

2

        let packet_id_larger = PacketId::from(2_u16);

1255

2

        assert!(packet_id_small < packet_id_larger);

1256

2

        assert!(packet_id_larger > packet_id_small);

1257

2

        assert_eq!(

1258

2

            packet_id_small.cmp(&packet_id_larger),

1259

2

            core::cmp::Ordering::Less

1260

2

);

1261

2

1262

1263

    #[test]

1264

2

    fn packet_id_hashable() {

1265

2

        let mut id_set = HashSet::new();

1266

2

        id_set.insert(PacketId::from(1_u16));

1267

2

1268

1269

    #[test]

1270

2

    fn sp_header_from_apid() {

1271

2

        let sp_header = SpHeader::new_from_apid(0x03);

1272

2

        assert_eq!(sp_header.apid(), 0x03);

1273

2

        assert_eq!(sp_header.data_len(), 0);

1274

2

1275

1276

    #[test]

1277

2

    fn sp_header_from_apid_checked() {

1278

2

        let sp_header = SpHeader::new_from_apid_checked(0x03).unwrap();

1279

2

        assert_eq!(sp_header.apid(), 0x03);

1280

2

        assert_eq!(sp_header.data_len(), 0);

1281

2

1282

1283

    #[cfg(feature = "defmt")]

1284

2

    fn is_defmt_format<T: defmt::Format>(_t: T) {}

1285

1286

    #[test]

1287

    #[cfg(feature = "defmt")]

1288

2

    fn test_defmt_format() {

1289

2

        is_defmt_format(ByteConversionError::ToSliceTooSmall {

1290

2

            found: 1,

1291

2

            expected: 2,

1292

2

});

1293

2

1294

1295

    #[test]

1296

2

    fn test_sp_header_as_vec() {

1297

2

        let sp_header = SpHeader::new_for_unseg_tc(0x42, 25, 1);

1298

2

        let sp_header_as_vec = sp_header.to_vec();

1299

2

        let sp_header_read_back = SpHeader::from_be_bytes(&sp_header_as_vec)

1300

2

            .expect("Error reading back SP header")

1301

2

.0;

1302

2

        assert_eq!(sp_header, sp_header_read_back);

1303

2

1304