Grcov report - words.rs

1

use crate::errors::{parity, Error, MessageError, Result, SubsystemError, TerminalError};

2

use crate::fields::*;

3

use crate::{flags::*, Header, Word};

4

5

/// Specifies the function that a remote terminal is to perform

6

///

7

/// This word is parsed from a packet that includes an initial service

8

/// sync flag. Only the active bus controller emits this word.[^1]

9

///

10

/// ## Example

11

///

12

/// ```rust

13

/// # use mil_std_1553b::*;

14

/// # fn main() -> Result<()> {

15

///     let word = CommandWord::new()

16

///         .with_address(Address::Value(16))

17

///         .with_subaddress(SubAddress::ModeCode(0))

18

///         .with_transmit_receive(TransmitReceive::Receive)

19

///         .with_mode_code(ModeCode::TransmitterShutdown)

20

///         .with_calculated_parity()

21

///         .build()?;

22

///

23

///     assert_eq!(word.subaddress(),SubAddress::ModeCode(0));

24

///     assert_eq!(word.mode_code(),ModeCode::TransmitterShutdown);

25

/// # Ok(())

26

/// # }

27

/// ```

28

///

29

/// [^1]: p30 [MIL-STD-1553 Tutorial](http://www.horntech.cn/techDocuments/MIL-STD-1553Tutorial.pdf)

30

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

31

pub struct CommandWord {

32

    /// Data of the word

33

    data: [u8; 2],

34

35

    /// Parity of the word

36

    parity: u8,

37

38

39

/// Sent in response to a valid message from the bus controller

40

///

41

/// This word is parsed from a packet that includes an initial service

42

/// sync flag. Status words are only transmitted by a remote terminal

43

/// in response to a message from the bus controller.[^1]

44

///

45

/// ## Example

46

///

47

/// ```rust

48

/// # use mil_std_1553b::*;

49

/// # fn main() -> Result<()> {

50

///     let word = StatusWord::new()

51

///         .with_address(Address::Value(16))

52

///         .with_service_request(ServiceRequest::Service)

53

///         .with_broadcast_received(BroadcastReceived::Received)

54

///         .with_calculated_parity()

55

///         .build()?;

56

///

57

///     assert_eq!(word.broadcast_received(),BroadcastReceived::Received);

58

///     assert_eq!(word.service_request(),ServiceRequest::Service);

59

/// # Ok(())

60

/// # }

61

/// ```

62

///

63

/// [^1]: p31 [MIL-STD-1553 Tutorial](http://www.horntech.cn/techDocuments/MIL-STD-1553Tutorial.pdf)

64

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

65

pub struct StatusWord {

66

    /// Data of the word

67

    data: [u8; 2],

68

69

    /// Parity of the word

70

    parity: u8,

71

72

73

/// Contains data that is being transmitted in a message.

74

///

75

/// This word is parsed from a packet that includes an initial data

76

/// sync flag. Data words can be transmitted by either a remote terminal

77

/// (transmit command) or a bus controller (receive command) and contain

78

/// two bytes of data each.[^1]

79

///

80

/// ## Example

81

///

82

/// ```rust

83

/// # use mil_std_1553b::*;

84

/// # fn main() -> Result<()> {

85

///     let word = DataWord::new()

86

///         .with_value(0b0100100001001001u16)

87

///         .with_calculated_parity()

88

///         .build()?;

89

///

90

///     assert_eq!(word.as_string(),Ok("HI"));

91

/// # Ok(())

92

/// # }

93

/// ```

94

///

95

/// [^1]: p31 [MIL-STD-1553 Tutorial](http://www.horntech.cn/techDocuments/MIL-STD-1553Tutorial.pdf)

96

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

97

pub struct DataWord {

98

    /// Data of the word

99

    data: [u8; 2],

100

101

    /// Parity of the word

102

    parity: u8,

103

104

105

impl CommandWord {

106

    /// Get the terminal address of this word

107

///

108

    /// See [Address](crate::flags::Address) for more information

109

    /// about this field.

110

4

    pub fn address(&self) -> Address {

111

4

        COMMAND_ADDRESS_FIELD.get(self)

112

4

113

114

    /// Set the terminal address of this word

115

///

116

    /// See [CommandWord::address] for

117

    /// more information.

118

///

119

    /// # Arguments

120

///

121

    /// * `value` - An [Address] to set

122

///

123

4

    pub fn set_address(&mut self, value: Address) {

124

4

        COMMAND_ADDRESS_FIELD.set(self, value.into());

125

4

126

127

    /// Constructor method to set the terminal address

128

///

129

    /// See [CommandWord::address] for

130

    /// more information.

131

///

132

    /// # Arguments

133

///

134

    /// * `value` - An [Address] to set

135

///

136

2

    pub fn with_address(mut self, value: Address) -> Self {

137

2

        self.set_address(value);

138

2

        self

139

2

140

141

    /// Get the subaddress of this word

142

///

143

    /// Values of 0b00000 and 0b11111 are interpreted as a flag that

144

    /// indicates that this command is carrying a mode code value.

145

///

146

    /// See [SubAddress](crate::flags::SubAddress) for more information

147

    /// about this field.

148

10

    pub fn subaddress(&self) -> SubAddress {

149

10

        COMMAND_SUBADDRESS_FIELD.get(self)

150

10

151

152

    /// Set the subaddress of this word

153

///

154

    /// See [CommandWord::subaddress] for

155

    /// more information.

156

///

157

    /// # Arguments

158

///

159

    /// * `value` - A [SubAddress] to set

160

///

161

10

    pub fn set_subaddress(&mut self, value: SubAddress) {

162

10

        COMMAND_SUBADDRESS_FIELD.set(self, value.into());

163

10

164

165

    /// Constructor method to set the subaddress

166

///

167

    /// See [CommandWord::subaddress] for

168

    /// more information.

169

///

170

    /// # Arguments

171

///

172

    /// * `value` - A [SubAddress] to set

173

///

174

2

    pub fn with_subaddress(mut self, value: SubAddress) -> Self {

175

2

        self.set_subaddress(value);

176

2

        self

177

2

178

179

    /// Get the direction of transmission

180

///

181

    /// See [TransmitReceive](crate::flags::TransmitReceive) enum for

182

    /// more information about this field.

183

12

    pub fn transmit_receive(&self) -> TransmitReceive {

184

12

        COMMAND_TRANSMIT_RECEIVE_FIELD.get(self)

185

12

186

187

    /// Set the direction of transmission

188

///

189

    /// See [TransmitReceive](crate::flags::TransmitReceive) enum for

190

    /// more information about this field.

191

///

192

    /// # Arguments

193

///

194

    /// * `value` - A [TransmitReceive] flag to set

195

///

196

12

    pub fn set_transmit_receive(&mut self, value: TransmitReceive) {

197

12

        COMMAND_TRANSMIT_RECEIVE_FIELD.set(self, value.into());

198

12

199

200

    /// Constructor method to set the direction of transmission

201

///

202

    /// See [TransmitReceive](crate::flags::TransmitReceive) enum for

203

    /// more information about this field.

204

///

205

    /// # Arguments

206

///

207

    /// * `value` - A [TransmitReceive] flag to set

208

///

209

2

    pub fn with_transmit_receive(mut self, value: TransmitReceive) -> Self {

210

2

        self.set_transmit_receive(value);

211

2

        self

212

2

213

214

    /// Get the mode code of this word

215

///

216

    /// This field should not be used if the subaddress isn't set to

217

    /// a ModeCode value. See [ModeCode](crate::flags::ModeCode) for

218

    /// more information about this field, or [SubAddress](crate::flags::SubAddress)

219

    /// for details about the ModeCode setting of the subaddress.

220

4

    pub fn mode_code(&self) -> ModeCode {

221

4

        COMMAND_MODE_CODE_FIELD.get(self)

222

4

223

224

    /// Set the mode code of this word

225

///

226

    /// This method sets the same bits that are used by the word count field.

227

    /// In order to be valid, users must also set the subaddress to a valid

228

    /// mode code value. See [CommandWord::mode_code] for more information.

229

///

230

    /// # Arguments

231

///

232

    /// * `value` - A [ModeCode] flag to set

233

///

234

4

    pub fn set_mode_code(&mut self, value: ModeCode) {

235

4

        COMMAND_MODE_CODE_FIELD.set(self, value.into());

236

4

237

238

    /// Constructor method to set the mode code

239

///

240

    /// This method sets the same bits that are used by the word count field.

241

    /// In order to be valid, users must also set the subaddress to a valid

242

    /// mode code value. See [CommandWord::mode_code] for more information.

243

///

244

    /// # Arguments

245

///

246

    /// * `value` - A [ModeCode] flag to set

247

///

248

2

    pub fn with_mode_code(mut self, value: ModeCode) -> Self {

249

2

        self.set_mode_code(value);

250

2

        self

251

2

252

253

    /// Get the number of data words associated with this word

254

///

255

    /// The word count is a value between 0 and 32 in command words

256

    /// that are not mode code commands. Mode code commands are

257

    /// identified using particular values of the subaddress field.

258

///

259

    /// See [SubAddress](crate::flags::SubAddress) for details about

260

    /// the ModeCode setting of the subaddress.

261

86

    pub fn word_count(&self) -> u8 {

262

86

        match COMMAND_WORD_COUNT_FIELD.get(self) {

263

6

            0 => 32u8,

264

80

            k => k as u8,

265

266

86

267

268

    /// Set the number of data words associated with this command

269

///

270

    /// The word count field is stored in the same bit position as the

271

    /// mode code value, and should only be used if the sub address is

272

    /// *not* set to a ModeCode value. See [CommandWord::word_count]

273

    /// for more information.

274

///

275

    /// Commands that are not mode code require some number of data

276

    /// words, and setting this field to `0` will indicate 32 data

277

    /// words. Any value given greater than 31 will be converted to

278

    /// `0`.

279

///

280

    /// # Arguments

281

///

282

    /// * `value` - A word count to set

283

///

284

12

    pub fn set_word_count(&mut self, mut value: u8) {

285

12

        if value > 31 {

286

6

            value = 0;

287

6

288

12

        COMMAND_WORD_COUNT_FIELD.set(self, value);

289

12

290

291

    /// Constructor method to set the number of data words

292

///

293

    /// See [CommandWord::set_word_count] for more information.

294

///

295

    /// # Arguments

296

///

297

    /// * `value` - A word count to set

298

///

299

6

    pub fn with_word_count(mut self, value: u8) -> Self {

300

6

        self.set_word_count(value);

301

6

        self

302

6

303

304

    /// Check if this word contains a mode code value

305

///

306

    /// See [CommandWord::mode_code]

307

    /// for more information.

308

    #[must_use = "Returned value is not used"]

309

6

    pub fn is_mode_code(&self) -> bool {

310

6

        self.subaddress().is_mode_code()

311

6

312

313

    /// Check if this word is being transmitted to a terminal

314

///

315

    /// See [CommandWord::transmit_receive]

316

    /// for more information.

317

    #[must_use = "Returned value is not used"]

318

4

    pub fn is_transmit(&self) -> bool {

319

4

        self.transmit_receive().is_transmit()

320

4

321

322

    /// Check if this word is being received by a terminal

323

///

324

    /// See [CommandWord::transmit_receive]

325

    /// for more information.

326

    #[must_use = "Returned value is not used"]

327

4

    pub fn is_receive(&self) -> bool {

328

4

        self.transmit_receive().is_receive()

329

4

330

331

    /// Get the data word count of the command word

332

    #[must_use = "Returned value is not used"]

333

72

    pub fn count(&self) -> usize {

334

72

        self.word_count() as usize

335

72

336

337

338

impl StatusWord {

339

    /// Get the terminal address of this word

340

///

341

    /// See [Address](crate::flags::Address) for more information

342

    /// about this field.

343

4

    pub fn address(&self) -> Address {

344

4

        STATUS_ADDRESS_FIELD.get(self)

345

4

346

347

    /// Set the terminal address of this word

348

///

349

    /// See [StatusWord::address] for

350

    /// more information.

351

///

352

    /// # Arguments

353

///

354

    /// * `value` - An [Address] to set

355

///

356

4

    pub fn set_address(&mut self, value: Address) {

357

4

        STATUS_ADDRESS_FIELD.set(self, value.into());

358

4

359

360

    /// Constructor method to set the terminal address

361

///

362

    /// See [StatusWord::address] for

363

    /// more information.

364

///

365

    /// # Arguments

366

///

367

    /// * `value` - An [Address] to set

368

///

369

2

    pub fn with_address(mut self, value: Address) -> Self {

370

2

        self.set_address(value);

371

2

        self

372

2

373

374

    /// Get Instrumentation flag of the status word

375

///

376

    /// **Most systems no longer use this flag, as the cost in reduced subaddress

377

    /// range is too high**.

378

///

379

    /// See [Instrumentation](crate::flags::Instrumentation) for

380

    /// more information.

381

4

    pub fn instrumentation(&self) -> Instrumentation {

382

4

        STATUS_INSTRUMENTATION_FIELD.get(self)

383

4

384

385

    /// Set Instrumentation flag of the status word

386

///

387

    /// See [StatusWord::instrumentation] for

388

    /// more information.

389

///

390

    /// # Arguments

391

///

392

    /// * `value` - An [Instrumentation] flag to set

393

///

394

4

    pub fn set_instrumentation(&mut self, value: Instrumentation) {

395

4

        STATUS_INSTRUMENTATION_FIELD.set(self, value.into());

396

4

397

398

    /// Constructor method to set Instrumentation flag

399

///

400

    /// See [StatusWord::instrumentation] for

401

    /// more information.

402

///

403

    /// # Arguments

404

///

405

    /// * `value` - An [Instrumentation] flag to set

406

///

407

2

    pub fn with_instrumentation(mut self, value: Instrumentation) -> Self {

408

2

        self.set_instrumentation(value);

409

2

        self

410

2

411

412

    /// Get Service Request flag of the status word

413

///

414

    /// See [ServiceRequest](crate::flags::ServiceRequest) for

415

    /// more information.

416

4

    pub fn service_request(&self) -> ServiceRequest {

417

4

        STATUS_SERVICE_REQUEST_FIELD.get(self)

418

4

419

420

    /// Set Service Request flag of the status word

421

///

422

    /// See [StatusWord::service_request] for

423

    /// more information.

424

///

425

    /// # Arguments

426

///

427

    /// * `value` - A [ServiceRequest] flag to set

428

///

429

4

    pub fn set_service_request(&mut self, value: ServiceRequest) {

430

4

        STATUS_SERVICE_REQUEST_FIELD.set(self, value.into());

431

4

432

433

    /// Constructor method to set the Service Request flag

434

///

435

    /// See [StatusWord::service_request] for

436

    /// more information.

437

///

438

    /// # Arguments

439

///

440

    /// * `value` - A [ServiceRequest] flag to set

441

///

442

2

    pub fn with_service_request(mut self, value: ServiceRequest) -> Self {

443

2

        self.set_service_request(value);

444

2

        self

445

2

446

447

    /// Get the value of the reserved portion of the status word

448

///

449

    /// See [Reserved](crate::flags::Reserved) for

450

    /// more information.

451

4

    pub fn reserved(&self) -> Reserved {

452

4

        STATUS_RESERVED_FIELD.get(self)

453

4

454

455

    /// Set the value of the reserved portion of the status word

456

///

457

    /// See [StatusWord::reserved] for

458

    /// more information.

459

///

460

    /// # Arguments

461

///

462

    /// * `value` - A [Reserved] value to set

463

///

464

4

    pub fn set_reserved(&mut self, value: Reserved) {

465

4

        STATUS_RESERVED_FIELD.set(self, value.into());

466

4

467

468

    /// Constructor method to set the value of the reserved field

469

///

470

    /// See [StatusWord::reserved] for

471

    /// more information.

472

///

473

    /// # Arguments

474

///

475

    /// * `value` - A [Reserved] value to set

476

///

477

2

    pub fn with_reserved(mut self, value: Reserved) -> Self {

478

2

        self.set_reserved(value);

479

2

        self

480

2

481

482

    /// Get the Broadcast Command flag from the status word

483

///

484

    /// If set, the flag indicates that the terminal has received a valid

485

    /// broadcast command. See [BroadcastReceived](crate::flags::BroadcastReceived) for

486

    /// more information.

487

4

    pub fn broadcast_received(&self) -> BroadcastReceived {

488

4

        STATUS_BROADCAST_RECEIVED_FIELD.get(self)

489

4

490

491

    /// Set the Broadcast Command flag of the status word

492

///

493

    /// See [StatusWord::broadcast_received] for

494

    /// more information.

495

///

496

    /// # Arguments

497

///

498

    /// * `value` - A [BroadcastReceived] flag to set

499

///

500

4

    pub fn set_broadcast_received(&mut self, value: BroadcastReceived) {

501

4

        STATUS_BROADCAST_RECEIVED_FIELD.set(self, value.into());

502

4

503

504

    /// Constructor method to set the Broadcast Command flag

505

///

506

    /// See [StatusWord::broadcast_received] for

507

    /// more information.

508

///

509

    /// # Arguments

510

///

511

    /// * `value` - A [BroadcastReceived] flag to set

512

///

513

2

    pub fn with_broadcast_received(mut self, value: BroadcastReceived) -> Self {

514

2

        self.set_broadcast_received(value);

515

2

        self

516

2

517

518

    /// Get the Busy flag from the status word

519

///

520

    /// If set, the flag indicates that the terminal is unable to respond to

521

    /// commands at this time. See [TerminalBusy](crate::flags::TerminalBusy) for

522

    /// more information.

523

8

    pub fn terminal_busy(&self) -> TerminalBusy {

524

8

        STATUS_TERMINAL_BUSY_FIELD.get(self)

525

8

526

527

    /// Set the Busy flag on the status word

528

///

529

    /// See [StatusWord::terminal_busy] for

530

    /// more information.

531

///

532

    /// # Arguments

533

///

534

    /// * `value` - A [TerminalBusy] flag to set

535

///

536

4

    pub fn set_terminal_busy(&mut self, value: TerminalBusy) {

537

4

        STATUS_TERMINAL_BUSY_FIELD.set(self, value.into());

538

4

539

540

    /// Constructor method to set the Busy flag

541

///

542

    /// See [StatusWord::terminal_busy] for

543

    /// more information.

544

///

545

    /// # Arguments

546

///

547

    /// * `value` - A [TerminalBusy] flag to set

548

///

549

2

    pub fn with_terminal_busy(mut self, value: TerminalBusy) -> Self {

550

2

        self.set_terminal_busy(value);

551

2

        self

552

2

553

554

    /// Get the Dynamic Bus Control Acceptance flag from the status word

555

///

556

    /// If set, the flag indicates that the terminal is taking control

557

    /// of the bus. See [DynamicBusAcceptance](crate::flags::DynamicBusAcceptance) for

558

    /// more information.

559

4

    pub fn dynamic_bus_acceptance(&self) -> DynamicBusAcceptance {

560

4

        STATUS_DYNAMIC_BUS_ACCEPTANCE_FIELD.get(self)

561

4

562

563

    /// Set the Dynamic Bus Control Acceptance flag on the status word

564

///

565

    /// See [StatusWord::dynamic_bus_acceptance] for

566

    /// more information.

567

///

568

    /// # Arguments

569

///

570

    /// * `value` - A [DynamicBusAcceptance] flag to set

571

///

572

4

    pub fn set_dynamic_bus_acceptance(&mut self, value: DynamicBusAcceptance) {

573

4

        STATUS_DYNAMIC_BUS_ACCEPTANCE_FIELD.set(self, value.into());

574

4

575

576

    /// Constructor method to set the Dynamic Bus Control Acceptance flag

577

///

578

    /// See [StatusWord::dynamic_bus_acceptance] for

579

    /// more information.

580

///

581

    /// # Arguments

582

///

583

    /// * `value` - A [DynamicBusAcceptance] flag to set

584

///

585

2

    pub fn with_dynamic_bus_acceptance(mut self, value: DynamicBusAcceptance) -> Self {

586

2

        self.set_dynamic_bus_acceptance(value);

587

2

        self

588

2

589

590

    /// Check if the message error flag is set

591

///

592

    /// See [MessageError] for more

593

    /// information.

594

16

    pub fn message_error(&self) -> MessageError {

595

16

        STATUS_MESSAGE_ERROR_FIELD.get(self)

596

16

597

598

    /// Set the message error flag on this word

599

///

600

    /// See [StatusWord::message_error] for

601

    /// more information.

602

///

603

    /// # Arguments

604

///

605

    /// * `value` - A [MessageError] flag to set

606

///

607

6

    pub fn set_message_error(&mut self, value: MessageError) {

608

6

        STATUS_MESSAGE_ERROR_FIELD.set(self, value.into());

609

6

610

611

    /// Constructor method to set the message error flag

612

///

613

    /// See [StatusWord::message_error] for

614

    /// more information.

615

///

616

    /// # Arguments

617

///

618

    /// * `value` - A [MessageError] flag to set

619

///

620

2

    pub fn with_message_error(mut self, value: MessageError) -> Self {

621

2

        self.set_message_error(value);

622

2

        self

623

2

624

625

    /// Check if the subsystem error flag is set

626

///

627

    /// See [SubsystemError](crate::errors::SubsystemError) for more

628

    /// information.

629

14

    pub fn subsystem_error(&self) -> SubsystemError {

630

14

        STATUS_SUBSYSTEM_ERROR_FIELD.get(self)

631

14

632

633

    /// Set the subsystem error flag on this word

634

///

635

    /// See [StatusWord::subsystem_error] for

636

    /// more information.

637

///

638

    /// # Arguments

639

///

640

    /// * `value` - A [SubsystemError] flag to set

641

///

642

6

    pub fn set_subsystem_error(&mut self, value: SubsystemError) {

643

6

        STATUS_SUBSYSTEM_ERROR_FIELD.set(self, value.into());

644

6

645

646

    /// Constructor method to set the subsystem error flag

647

///

648

    /// See [StatusWord::subsystem_error] for

649

    /// more information.

650

///

651

    /// # Arguments

652

///

653

    /// * `value` - A [SubsystemError] flag to set

654

///

655

2

    pub fn with_subsystem_error(mut self, value: SubsystemError) -> Self {

656

2

        self.set_subsystem_error(value);

657

2

        self

658

2

659

660

    /// Check if the terminal error flag is set

661

///

662

    /// See [`TerminalError`](crate::errors::TerminalError) for more

663

    /// information.

664

12

    pub fn terminal_error(&self) -> TerminalError {

665

12

        STATUS_TERMINAL_ERROR_FIELD.get(self)

666

12

667

668

    /// Set the terminal error flag on this word

669

///

670

    /// See [`StatusWord::terminal_error`][StatusWord::terminal_error] for

671

    /// more information.

672

///

673

    /// # Arguments

674

///

675

    /// * `value` - A [TerminalError] flag to set

676

///

677

6

    pub fn set_terminal_error(&mut self, value: TerminalError) {

678

6

        STATUS_TERMINAL_ERROR_FIELD.set(self, value.into());

679

6

680

681

    /// Constructor set the terminal error flag

682

///

683

    /// See [`StatusWord::terminal_error`][StatusWord::terminal_error] for

684

    /// more information.

685

///

686

    /// # Arguments

687

///

688

    /// * `value` - A [TerminalError] flag to set

689

///

690

2

    pub fn with_terminal_error(mut self, value: TerminalError) -> Self {

691

2

        self.set_terminal_error(value);

692

2

        self

693

2

694

695

    /// Check if any of the various error flags are set

696

///

697

    /// See [StatusWord::message_error], [StatusWord::subsystem_error],

698

    /// or [StatusWord::terminal_error] for more information.

699

    #[must_use = "Returned value is not used"]

700

12

    pub fn is_error(&self) -> bool {

701

12

        self.message_error().is_error()

702

10

            || self.subsystem_error().is_error()

703

8

            || self.terminal_error().is_error()

704

12

705

706

    /// Check if the terminal is currently busy

707

///

708

    /// See [StatusWord::terminal_busy] for

709

    /// more information.

710

    #[must_use = "Returned value is not used"]

711

4

    pub fn is_busy(&self) -> bool {

712

4

        self.terminal_busy().is_busy()

713

4

714

715

716

impl DataWord {

717

    /// Constructor method to set the word from a string

718

///

719

    /// Fails if the given string is more than two

720

    /// bytes long.

721

///

722

    /// # Arguments

723

///

724

    /// * `data` - A &str to set as data

725

///

726

8

    pub fn with_string(mut self, data: &str) -> Result<Self> {

727

8

        self.set_string(data)?;

728

6

        Ok(self)

729

8

730

731

    /// Set the word from a string

732

///

733

    /// Fails if the given string is more than two

734

    /// bytes long.

735

///

736

    /// # Arguments

737

///

738

    /// * `data` - A &str to set as data

739

///

740

12

    pub fn set_string(&mut self, data: &str) -> Result<()> {

741

12

        self.data = data.as_bytes().try_into().or(Err(Error::InvalidString))?;

742

8

        self.parity = self.calculate_parity();

743

8

        Ok(())

744

12

745

746

    /// Get the internal data as a &str

747

///

748

    /// Fails if the word is not a valid UTF-8 string.

749

8

    pub fn as_string(&self) -> Result<&str> {

750

8

        self.try_into()

751

8

752

753

754

impl Header for CommandWord {

755

10

    fn count(&self) -> Option<usize> {

756

10

        Some(self.word_count() as usize)

757

10

758

759

760

impl Header for StatusWord {

761

8

    fn count(&self) -> Option<usize> {

762

8

        None

763

8

764

765

766

impl Word for CommandWord {

767

160

    fn new() -> Self {

768

160

        Self {

769

160

            data: [0, 0],

770

160

            parity: 1,

771

160

772

160

773

774

100

    fn with_value(mut self, data: u16) -> Self {

775

100

        self.set_value(data);

776

100

        self

777

100

778

779

18

    fn with_bytes(mut self, data: [u8; 2]) -> Self {

780

18

        self.set_bytes(data);

781

18

        self

782

18

783

784

22

    fn with_parity(mut self, parity: u8) -> Self {

785

22

        self.set_parity(parity);

786

22

        self

787

22

788

789

100

    fn with_calculated_parity(mut self) -> Self {

790

100

        self.parity = self.calculate_parity();

791

100

        self

792

100

793

794

14

    fn build(self) -> Result<Self> {

795

14

        if self.check_parity() {

796

12

            Ok(self)

797

        } else {

798

2

            Err(Error::InvalidWord)

799

800

14

801

802

96

    fn from_value(data: u16) -> Self {

803

96

        Self::new().with_value(data).with_calculated_parity()

804

96

805

806

6

    fn from_bytes(data: [u8; 2]) -> Self {

807

6

        Self::new().with_bytes(data)

808

6

809

810

10

    fn as_bytes(&self) -> [u8; 2] {

811

10

        self.data

812

10

813

814

508

    fn as_value(&self) -> u16 {

815

508

        self.into()

816

508

817

818

144

    fn set_value(&mut self, data: u16) {

819

144

        self.data = data.to_be_bytes();

820

144

        self.parity = self.calculate_parity();

821

144

822

823

20

    fn set_bytes(&mut self, data: [u8; 2]) {

824

20

        self.data = data;

825

20

        self.parity = self.calculate_parity();

826

20

827

828

88

    fn parity(&self) -> u8 {

829

88

        self.parity

830

88

831

832

24

    fn set_parity(&mut self, parity: u8) {

833

24

        self.parity = parity;

834

24

835

836

336

    fn calculate_parity(&self) -> u8 {

837

336

        parity(self.as_value())

838

336

839

840

72

    fn check_parity(&self) -> bool {

841

72

        self.parity() == self.calculate_parity()

842

72

843

844

845

impl Word for StatusWord {

846

122

    fn new() -> Self {

847

122

        Self {

848

122

            data: [0, 0],

849

122

            parity: 1,

850

122

851

122

852

853

54

    fn with_value(mut self, data: u16) -> Self {

854

54

        self.set_value(data);

855

54

        self

856

54

857

858

18

    fn with_bytes(mut self, data: [u8; 2]) -> Self {

859

18

        self.set_bytes(data);

860

18

        self

861

18

862

863

22

    fn with_parity(mut self, parity: u8) -> Self {

864

22

        self.set_parity(parity);

865

22

        self

866

22

867

868

4

    fn with_calculated_parity(mut self) -> Self {

869

4

        self.parity = self.calculate_parity();

870

4

        self

871

4

872

873

14

    fn build(self) -> Result<Self> {

874

14

        if self.check_parity() {

875

12

            Ok(self)

876

        } else {

877

2

            Err(Error::InvalidWord)

878

879

14

880

881

50

    fn from_value(data: u16) -> Self {

882

50

        Self::new().with_value(data)

883

50

884

885

6

    fn from_bytes(data: [u8; 2]) -> Self {

886

6

        Self::new().with_bytes(data)

887

6

888

889

10

    fn as_bytes(&self) -> [u8; 2] {

890

10

        self.data

891

10

892

893

298

    fn as_value(&self) -> u16 {

894

298

        self.into()

895

298

896

897

102

    fn set_value(&mut self, data: u16) {

898

102

        self.data = data.to_be_bytes();

899

102

        self.parity = self.calculate_parity();

900

102

901

902

20

    fn set_bytes(&mut self, data: [u8; 2]) {

903

20

        self.data = data;

904

20

        self.parity = self.calculate_parity();

905

20

906

907

54

    fn parity(&self) -> u8 {

908

54

        self.parity

909

54

910

911

24

    fn set_parity(&mut self, parity: u8) {

912

24

        self.parity = parity;

913

24

914

915

166

    fn calculate_parity(&self) -> u8 {

916

166

        parity(self.as_value())

917

166

918

919

40

    fn check_parity(&self) -> bool {

920

40

        self.parity() == self.calculate_parity()

921

40

922

923

924

impl Word for DataWord {

925

258

    fn new() -> Self {

926

258

        Self {

927

258

            data: [0, 0],

928

258

            parity: 1,

929

258

930

258

931

932

104

    fn with_value(mut self, data: u16) -> Self {

933

104

        self.set_value(data);

934

104

        self

935

104

936

937

128

    fn with_bytes(mut self, data: [u8; 2]) -> Self {

938

128

        self.set_bytes(data);

939

128

        self

940

128

941

942

30

    fn with_parity(mut self, parity: u8) -> Self {

943

30

        self.set_parity(parity);

944

30

        self

945

30

946

947

6

    fn with_calculated_parity(mut self) -> Self {

948

6

        self.parity = self.calculate_parity();

949

6

        self

950

6

951

952

24

    fn build(self) -> Result<Self> {

953

24

        if self.check_parity() {

954

22

            Ok(self)

955

        } else {

956

2

            Err(Error::InvalidWord)

957

958

24

959

960

102

    fn from_value(data: u16) -> Self {

961

102

        Self::new().with_value(data)

962

102

963

964

106

    fn from_bytes(data: [u8; 2]) -> Self {

965

106

        Self::new().with_bytes(data)

966

106

967

968

14

    fn as_bytes(&self) -> [u8; 2] {

969

14

        self.data

970

14

971

972

428

    fn as_value(&self) -> u16 {

973

428

        self.into()

974

428

975

976

118

    fn set_value(&mut self, data: u16) {

977

118

        self.data = data.to_be_bytes();

978

118

        self.parity = self.calculate_parity();

979

118

980

981

130

    fn set_bytes(&mut self, data: [u8; 2]) {

982

130

        self.data = data;

983

130

        self.parity = self.calculate_parity();

984

130

985

986

154

    fn parity(&self) -> u8 {

987

154

        self.parity

988

154

989

990

32

    fn set_parity(&mut self, parity: u8) {

991

32

        self.parity = parity;

992

32

993

994

382

    fn calculate_parity(&self) -> u8 {

995

382

        parity(self.as_value())

996

382

997

998

120

    fn check_parity(&self) -> bool {

999

120

        self.parity() == self.calculate_parity()

1000

120

1001

1002

1003

impl Default for CommandWord {

1004

2

    fn default() -> Self {

1005

2

        Self::new()

1006

2

1007

1008

1009

impl Default for StatusWord {

1010

2

    fn default() -> Self {

1011

2

        Self::new()

1012

2

1013

1014

1015

impl Default for DataWord {

1016

2

    fn default() -> Self {

1017

2

        Self::new()

1018

2

1019

1020

1021

impl TryFrom<&str> for DataWord {

1022

    type Error = Error;

1023

1024

4

    fn try_from(value: &str) -> Result<Self> {

1025

4

        Self::new()

1026

4

            .with_string(value)

1027

5

            .map(|w| w.with_calculated_parity())

1028

4

1029

1030

1031

impl<'a> TryFrom<&'a DataWord> for &'a str {

1032

    type Error = Error;

1033

1034

22

    fn try_from(value: &'a DataWord) -> Result<Self> {

1035

22

        core::str::from_utf8(&value.data).or(Err(Error::InvalidString))

1036

22

1037

1038

1039

impl From<u16> for CommandWord {

1040

92

    fn from(value: u16) -> Self {

1041

92

        Self::from_value(value)

1042

92

1043

1044

1045

impl From<u16> for StatusWord {

1046

46

    fn from(value: u16) -> Self {

1047

46

        Self::from_value(value)

1048

46

1049

1050

1051

impl From<u16> for DataWord {

1052

98

    fn from(value: u16) -> Self {

1053

98

        Self::from_value(value)

1054

98

1055

1056

1057

impl From<[u8; 2]> for CommandWord {

1058

2

    fn from(value: [u8; 2]) -> Self {

1059

2

        Self::from_bytes(value)

1060

2

1061

1062

1063

impl From<[u8; 2]> for StatusWord {

1064

2

    fn from(value: [u8; 2]) -> Self {

1065

2

        Self::from_bytes(value)

1066

2

1067

1068

1069

impl From<[u8; 2]> for DataWord {

1070

102

    fn from(value: [u8; 2]) -> Self {

1071

102

        Self::from_bytes(value)

1072

102

1073

1074

1075

impl From<&CommandWord> for [u8; 2] {

1076

10

    fn from(value: &CommandWord) -> Self {

1077

10

        value.data

1078

10

1079

1080

1081

impl From<CommandWord> for [u8; 2] {

1082

2

    fn from(value: CommandWord) -> Self {

1083

2

        value.data

1084

2

1085

1086

1087

impl From<&StatusWord> for [u8; 2] {

1088

8

    fn from(value: &StatusWord) -> Self {

1089

8

        value.data

1090

8

1091

1092

1093

impl From<StatusWord> for [u8; 2] {

1094

2

    fn from(value: StatusWord) -> Self {

1095

2

        value.data

1096

2

1097

1098

1099

impl From<&DataWord> for [u8; 2] {

1100

34

    fn from(value: &DataWord) -> Self {

1101

34

        value.data

1102

34

1103

1104

1105

impl From<DataWord> for [u8; 2] {

1106

2

    fn from(value: DataWord) -> Self {

1107

2

        value.data

1108

2

1109

1110

1111

impl From<&CommandWord> for u16 {

1112

508

    fn from(value: &CommandWord) -> Self {

1113

508

        u16::from_be_bytes(value.data)

1114

508

1115

1116

1117

impl From<CommandWord> for u16 {

1118

2

    fn from(value: CommandWord) -> Self {

1119

2

        u16::from_be_bytes(value.data)

1120

2

1121

1122

1123

impl From<&StatusWord> for u16 {

1124

298

    fn from(value: &StatusWord) -> Self {

1125

298

        u16::from_be_bytes(value.data)

1126

298

1127

1128

1129

impl From<StatusWord> for u16 {

1130

2

    fn from(value: StatusWord) -> Self {

1131

2

        u16::from_be_bytes(value.data)

1132

2

1133

1134

1135

impl From<&DataWord> for u16 {

1136

446

    fn from(value: &DataWord) -> Self {

1137

446

        u16::from_be_bytes(value.data)

1138

446

1139

1140

1141

impl From<DataWord> for u16 {

1142

2

    fn from(value: DataWord) -> Self {

1143

2

        u16::from(&value)

1144

2

1145

1146

1147

impl From<&DataWord> for i16 {

1148

2

    fn from(value: &DataWord) -> Self {

1149

2

        u16::from(value) as i16

1150

2

1151

1152

1153

impl From<DataWord> for i16 {

1154

2

    fn from(value: DataWord) -> Self {

1155

2

        i16::from(&value)

1156

2

1157

1158

1159

impl From<&DataWord> for u32 {

1160

2

    fn from(value: &DataWord) -> Self {

1161

2

        u16::from(value) as u32

1162

2

1163

1164

1165

impl From<DataWord> for u32 {

1166

2

    fn from(value: DataWord) -> Self {

1167

2

        u32::from(&value)

1168

2

1169

1170

1171

impl From<&DataWord> for i32 {

1172

2

    fn from(value: &DataWord) -> Self {

1173

2

        u16::from(value) as i32

1174

2

1175

1176

1177

impl From<DataWord> for i32 {

1178

2

    fn from(value: DataWord) -> Self {

1179

2

        i32::from(&value)

1180

2

1181

1182

1183

impl From<&DataWord> for u64 {

1184

2

    fn from(value: &DataWord) -> Self {

1185

2

        u16::from(value) as u64

1186

2

1187

1188

1189

impl From<DataWord> for u64 {

1190

2

    fn from(value: DataWord) -> Self {

1191

2

        u64::from(&value)

1192

2

1193

1194

1195

impl From<&DataWord> for i64 {

1196

2

    fn from(value: &DataWord) -> Self {

1197

2

        u16::from(value) as i64

1198

2

1199

1200

1201

impl From<DataWord> for i64 {

1202

2

    fn from(value: DataWord) -> Self {

1203

2

        i64::from(&value)

1204

2

1205

1206

1207

#[cfg(test)]

1208

mod tests {

1209

    use super::*;

1210

1211

    // ----------------------------------------------------------

1212

    // CommandWord

1213

1214

    #[test]

1215

2

    fn test_command_get_set_address() {

1216

2

        let value1 = Address::Broadcast(0b11111);

1217

2

        let value2 = Address::Value(0b10101);

1218

2

1219

2

        let mut word = CommandWord::new().with_address(value1);

1220

2

        assert_eq!(word.address(), value1);

1221

1222

2

        word.set_address(value2);

1223

2

        assert_eq!(word.address(), value2);

1224

2

        assert_eq!(word.as_value(), 0b1010100000000000);

1225

2

1226

1227

    #[test]

1228

2

    fn test_command_get_set_subaddress() {

1229

2

        let value1 = SubAddress::ModeCode(0b11111);

1230

2

        let value2 = SubAddress::Value(0b10101);

1231

2

1232

2

        let mut word = CommandWord::new().with_subaddress(value1);

1233

2

        assert_eq!(word.subaddress(), value1);

1234

1235

2

        word.set_subaddress(value2);

1236

2

        assert_eq!(word.subaddress(), value2);

1237

2

        assert_eq!(word.as_value(), 0b0000001010100000);

1238

2

1239

1240

    #[test]

1241

2

    fn test_command_get_set_transmit_receive() {

1242

2

        let mut word = CommandWord::new().with_transmit_receive(TransmitReceive::Receive);

1243

2

        assert!(word.transmit_receive().is_receive());

1244

1245

2

        word.set_transmit_receive(TransmitReceive::Transmit);

1246

2

        assert!(word.transmit_receive().is_transmit());

1247

2

1248

1249

    #[test]

1250

2

    fn test_command_get_set_mode_code() {

1251

2

        let mut word = CommandWord::new().with_mode_code(ModeCode::TransmitVectorWord);

1252

2

        assert_eq!(word.mode_code(), ModeCode::TransmitVectorWord);

1253

1254

2

        word.set_mode_code(ModeCode::InitiateSelfTest);

1255

2

        assert_eq!(word.mode_code(), ModeCode::InitiateSelfTest);

1256

2

1257

1258

    #[test]

1259

2

    fn test_command_get_set_word_count() {

1260

2

        let mut word = CommandWord::new().with_word_count(33);

1261

2

        assert_eq!(word.word_count(), 32);

1262

1263

2

        word.set_word_count(5);

1264

2

        assert_eq!(word.word_count(), 5);

1265

2

1266

1267

    #[test]

1268

2

    fn test_command_is_mode_code() {

1269

2

        let mut word = CommandWord::new();

1270

2

1271

2

        word.set_subaddress(SubAddress::ModeCode(0b00000));

1272

2

        assert!(word.is_mode_code());

1273

1274

2

        word.set_subaddress(SubAddress::Value(0b01010));

1275

2

        assert!(!word.is_mode_code());

1276

1277

2

        word.set_subaddress(SubAddress::ModeCode(0b11111));

1278

2

        assert!(word.is_mode_code());

1279

2

1280

1281

    #[test]

1282

2

    fn test_command_is_transmit() {

1283

2

        let mut word = CommandWord::new();

1284

2

1285

2

        word.set_transmit_receive(TransmitReceive::Transmit);

1286

2

        assert!(word.is_transmit());

1287

1288

2

        word.set_transmit_receive(TransmitReceive::Receive);

1289

2

        assert!(!word.is_transmit());

1290

2

1291

1292

    #[test]

1293

2

    fn test_command_is_receive() {

1294

2

        let mut word = CommandWord::new();

1295

2

1296

2

        word.set_transmit_receive(TransmitReceive::Receive);

1297

2

        assert!(word.is_receive());

1298

1299

2

        word.set_transmit_receive(TransmitReceive::Transmit);

1300

2

        assert!(!word.is_receive());

1301

2

1302

1303

    #[test]

1304

2

    fn test_command_count() {

1305

2

        let mut word = CommandWord::new().with_word_count(33);

1306

2

        assert_eq!(word.count(), 32);

1307

1308

2

        word.set_word_count(5);

1309

2

        assert_eq!(word.count(), 5);

1310

2

1311

1312

    #[test]

1313

2

    fn test_command_roundtrip() {

1314

2

        let word1 = CommandWord::from_value(0b0110100001101001);

1315

2

        let data1 = word1.as_bytes();

1316

2

1317

2

        let word2 = CommandWord::from_bytes(data1);

1318

2

        let data2 = word2.as_bytes();

1319

2

1320

2

        assert_eq!(data1, [0b01101000, 0b01101001]);

1321

2

        assert_eq!(data2, [0b01101000, 0b01101001]);

1322

2

        assert_eq!(word1, word2);

1323

2

1324

1325

    // ----------------------------------------------------------

1326

1327

    // ----------------------------------------------------------

1328

    // CommandWord: Header

1329

1330

    #[test]

1331

2

    fn test_command_header_count() {

1332

2

        let mut word = CommandWord::new().with_word_count(33);

1333

2

        assert_eq!(Header::count(&word), Some(32));

1334

1335

2

        word.set_word_count(5);

1336

2

        assert_eq!(Header::count(&word), Some(5));

1337

2

1338

1339

    // ----------------------------------------------------------

1340

1341

    // ----------------------------------------------------------

1342

    // CommandWord: Word

1343

1344

    #[test]

1345

2

    fn test_command_word_new() {

1346

2

        let word = CommandWord::new();

1347

2

        assert_eq!(word.data, [0, 0]);

1348

2

        assert_eq!(word.parity, 1);

1349

2

1350

1351

    #[test]

1352

2

    fn test_command_word_value() {

1353

2

        let mut word = CommandWord::new().with_value(0b0101010101010101);

1354

2

        assert_eq!(word.data, [0b01010101, 0b01010101]);

1355

2

        assert_eq!(word.as_value(), 0b0101010101010101);

1356

1357

2

        word.set_value(0b1010101010101010);

1358

2

        assert_eq!(word.data, [0b10101010, 0b10101010]);

1359

2

        assert_eq!(word.as_value(), 0b1010101010101010);

1360

1361

2

        word = CommandWord::from_value(0b0101010101010101);

1362

2

        assert_eq!(word.data, [0b01010101, 0b01010101]);

1363

2

        assert_eq!(word.as_value(), 0b0101010101010101);

1364

2

1365

1366

    #[test]

1367

2

    fn test_command_word_bytes() {

1368

2

        let mut word = CommandWord::new().with_bytes([0b01010101, 0b01010101]);

1369

2

        assert_eq!(word.data, [0b01010101, 0b01010101]);

1370

2

        assert_eq!(word.as_bytes(), [0b01010101, 0b01010101]);

1371

1372

2

        word.set_bytes([0b10101010, 0b10101010]);

1373

2

        assert_eq!(word.data, [0b10101010, 0b10101010]);

1374

2

        assert_eq!(word.as_bytes(), [0b10101010, 0b10101010]);

1375

1376

2

        word = CommandWord::from_bytes([0b01010101, 0b01010101]);

1377

2

        assert_eq!(word.data, [0b01010101, 0b01010101]);

1378

2

        assert_eq!(word.as_bytes(), [0b01010101, 0b01010101]);

1379

2

1380

1381

    #[test]

1382

2

    fn test_command_word_parity() {

1383

2

        let mut word = CommandWord::from(0).with_parity(0);

1384

2

        assert_eq!(word.parity, 0);

1385

2

        assert_eq!(word.parity(), 0);

1386

2

        assert_eq!(word.check_parity(), false);

1387

1388

2

        word.set_parity(1);

1389

2

        assert_eq!(word.parity, 1);

1390

2

        assert_eq!(word.parity(), 1);

1391

2

        assert_eq!(word.check_parity(), true);

1392

1393

2

        word = CommandWord::from(1).with_calculated_parity();

1394

2

        assert_eq!(word.parity, 0);

1395

2

        assert_eq!(word.parity(), 0);

1396

2

        assert_eq!(word.check_parity(), true);

1397

2

1398

1399

    #[test]

1400

2

    fn test_command_word_build_success() {

1401

2

        let word = CommandWord::new().with_calculated_parity().build();

1402

2

        assert!(word.is_ok());

1403

2

1404

1405

    #[test]

1406

2

    fn test_command_word_build_fail() {

1407

2

        let word = CommandWord::new().with_parity(0).build();

1408

2

        assert!(word.is_err());

1409

2

1410

1411

    // ----------------------------------------------------------

1412

1413

    #[test]

1414

2

    fn test_command_default() {

1415

2

        let word = CommandWord::default();

1416

2

        assert_eq!(word.data, [0, 0]);

1417

2

        assert_eq!(word.parity, 1);

1418

2

1419

1420

    #[test]

1421

2

    fn test_command_from_value() {

1422

2

        let word: CommandWord = 0b1010101010101010.into();

1423

2

        assert_eq!(word.as_value(), 0b1010101010101010);

1424

2

1425

1426

    #[test]

1427

2

    fn test_command_from_bytes() {

1428

2

        let word: CommandWord = [0b10101010, 0b10101010].into();

1429

2

        assert_eq!(word.as_value(), 0b1010101010101010);

1430

2

1431

1432

    #[test]

1433

2

    fn test_command_into_value() {

1434

2

        let word = CommandWord::from(0b1010101010101010);

1435

2

        let value = u16::from(word);

1436

2

        assert_eq!(value, 0b1010101010101010);

1437

2

1438

1439

    #[test]

1440

2

    fn test_command_into_bytes() {

1441

2

        let word = CommandWord::from(0b1010101010101010);

1442

2

        let bytes = <[u8; 2]>::from(word);

1443

2

        assert_eq!(bytes, [0b10101010, 0b10101010]);

1444

2

1445

1446

    // ----------------------------------------------------------

1447

    // StatusWord

1448

1449

    #[test]

1450

2

    fn test_status_get_set_address() {

1451

2

        let item1 = Address::Broadcast(0b11111);

1452

2

        let item2 = Address::Value(0b10101);

1453

2

1454

2

        let mut word = StatusWord::new().with_address(item1);

1455

2

        assert_eq!(word.address(), item1);

1456

1457

2

        word.set_address(item2);

1458

2

        assert_eq!(word.address(), item2);

1459

2

        assert_eq!(word.as_value(), 0b1010100000000000);

1460

2

1461

1462

    #[test]

1463

2

    fn test_status_get_set_instrumentation() {

1464

2

        let item1 = Instrumentation::Status;

1465

2

        let item2 = Instrumentation::Command;

1466

2

1467

2

        let mut word = StatusWord::new().with_instrumentation(item1);

1468

2

        assert_eq!(word.instrumentation(), item1);

1469

1470

2

        word.set_instrumentation(item2);

1471

2

        assert_eq!(word.instrumentation(), item2);

1472

2

1473

1474

    #[test]

1475

2

    fn test_status_get_set_service_request() {

1476

2

        let item1 = ServiceRequest::NoService;

1477

2

        let item2 = ServiceRequest::Service;

1478

2

1479

2

        let mut word = StatusWord::new().with_service_request(item1);

1480

2

        assert_eq!(word.service_request(), item1);

1481

1482

2

        word.set_service_request(item2);

1483

2

        assert_eq!(word.service_request(), item2);

1484

2

1485

1486

    #[test]

1487

2

    fn test_status_get_set_reserved() {

1488

2

        let item1 = Reserved::None;

1489

2

        let item2 = Reserved::Value(0b111);

1490

2

1491

2

        let mut word = StatusWord::new().with_reserved(item1);

1492

2

        assert_eq!(word.reserved(), item1);

1493

1494

2

        word.set_reserved(item2);

1495

2

        assert_eq!(word.reserved(), item2);

1496

2

1497

1498

    #[test]

1499

2

    fn test_status_get_set_broadcast_received() {

1500

2

        let item1 = BroadcastReceived::NotReceived;

1501

2

        let item2 = BroadcastReceived::Received;

1502

2

1503

2

        let mut word = StatusWord::new().with_broadcast_received(item1);

1504

2

        assert_eq!(word.broadcast_received(), item1);

1505

1506

2

        word.set_broadcast_received(item2);

1507

2

        assert_eq!(word.broadcast_received(), item2);

1508

2

1509

1510

    #[test]

1511

2

    fn test_status_get_set_terminal_busy() {

1512

2

        let item1 = TerminalBusy::NotBusy;

1513

2

        let item2 = TerminalBusy::Busy;

1514

2

1515

2

        let mut word = StatusWord::new().with_terminal_busy(item1);

1516

2

        assert_eq!(word.is_busy(), false);

1517

2

        assert_eq!(word.terminal_busy(), item1);

1518

1519

2

        word.set_terminal_busy(item2);

1520

2

        assert_eq!(word.is_busy(), true);

1521

2

        assert_eq!(word.terminal_busy(), item2);

1522

2

1523

1524

    #[test]

1525

2

    fn test_status_get_set_dynamic_bus_acceptance() {

1526

2

        let item1 = DynamicBusAcceptance::NotAccepted;

1527

2

        let item2 = DynamicBusAcceptance::Accepted;

1528

2

1529

2

        let mut word = StatusWord::new().with_dynamic_bus_acceptance(item1);

1530

2

        assert_eq!(word.dynamic_bus_acceptance(), item1);

1531

1532

2

        word.set_dynamic_bus_acceptance(item2);

1533

2

        assert_eq!(word.dynamic_bus_acceptance(), item2);

1534

2

1535

1536

    #[test]

1537

2

    fn test_status_get_set_message_error() {

1538

2

        let item1 = MessageError::None;

1539

2

        let item2 = MessageError::Error;

1540

2

1541

2

        let mut word = StatusWord::new().with_message_error(item1);

1542

2

        assert_eq!(word.message_error(), item1);

1543

1544

2

        word.set_message_error(item2);

1545

2

        assert_eq!(word.message_error(), item2);

1546

2

1547

1548

    #[test]

1549

2

    fn test_status_get_set_subsystem_error() {

1550

2

        let item1 = SubsystemError::None;

1551

2

        let item2 = SubsystemError::Error;

1552

2

1553

2

        let mut word = StatusWord::new().with_subsystem_error(item1);

1554

2

        assert_eq!(word.subsystem_error(), item1);

1555

1556

2

        word.set_subsystem_error(item2);

1557

2

        assert_eq!(word.subsystem_error(), item2);

1558

2

1559

1560

    #[test]

1561

2

    fn test_status_get_set_terminal_error() {

1562

2

        let item1 = TerminalError::None;

1563

2

        let item2 = TerminalError::Error;

1564

2

1565

2

        let mut word = StatusWord::new().with_terminal_error(item1);

1566

2

        assert_eq!(word.terminal_error(), item1);

1567

1568

2

        word.set_terminal_error(item2);

1569

2

        assert_eq!(word.terminal_error(), item2);

1570

2

1571

1572

    #[test]

1573

2

    fn test_status_is_error() {

1574

2

        let item1 = TerminalError::Error;

1575

2

        let item2 = SubsystemError::Error;

1576

2

        let item3 = MessageError::Error;

1577

2

1578

2

        let mut word1 = StatusWord::new();

1579

2

        let mut word2 = StatusWord::new();

1580

2

        let mut word3 = StatusWord::new();

1581

2

1582

2

        assert!(!word1.is_error());

1583

2

        assert!(!word2.is_error());

1584

2

        assert!(!word3.is_error());

1585

1586

2

        word1.set_terminal_error(item1);

1587

2

        word2.set_subsystem_error(item2);

1588

2

        word3.set_message_error(item3);

1589

2

1590

2

        assert!(word1.is_error());

1591

2

        assert!(word2.is_error());

1592

2

        assert!(word3.is_error());

1593

2

1594

1595

    #[test]

1596

2

    fn test_status_roundtrip() {

1597

2

        let word1 = StatusWord::from_value(0b0110100001101001);

1598

2

        let data1 = word1.as_bytes();

1599

2

1600

2

        let word2 = StatusWord::from_bytes(data1);

1601

2

        let data2 = word2.as_bytes();

1602

2

1603

2

        assert_eq!(data1, [0b01101000, 0b01101001]);

1604

2

        assert_eq!(data2, [0b01101000, 0b01101001]);

1605

2

        assert_eq!(word1, word2);

1606

2

1607

1608

    // ----------------------------------------------------------

1609

1610

    // ----------------------------------------------------------

1611

    // StatusWord: Header

1612

1613

    #[test]

1614

2

    fn test_status_header_count() {

1615

2

        let word = StatusWord::new();

1616

2

        assert_eq!(Header::count(&word), None);

1617

2

1618

1619

    // ----------------------------------------------------------

1620

1621

    // ----------------------------------------------------------

1622

    // StatusWord: Word

1623

1624

    #[test]

1625

2

    fn test_status_word_new() {

1626

2

        let word = StatusWord::new();

1627

2

        assert_eq!(word.data, [0, 0]);

1628

2

        assert_eq!(word.parity, 1);

1629

2

1630

1631

    #[test]

1632

2

    fn test_status_word_value() {

1633

2

        let mut word = StatusWord::new().with_value(0b0101010101010101);

1634

2

        assert_eq!(word.data, [0b01010101, 0b01010101]);

1635

2

        assert_eq!(word.as_value(), 0b0101010101010101);

1636

1637

2

        word.set_value(0b1010101010101010);

1638

2

        assert_eq!(word.data, [0b10101010, 0b10101010]);

1639

2

        assert_eq!(word.as_value(), 0b1010101010101010);

1640

1641

2

        word = StatusWord::from_value(0b0101010101010101);

1642

2

        assert_eq!(word.data, [0b01010101, 0b01010101]);

1643

2

        assert_eq!(word.as_value(), 0b0101010101010101);

1644

2

1645

1646

    #[test]

1647

2

    fn test_status_word_bytes() {

1648

2

        let mut word = StatusWord::new().with_bytes([0b01010101, 0b01010101]);

1649

2

        assert_eq!(word.data, [0b01010101, 0b01010101]);

1650

2

        assert_eq!(word.as_bytes(), [0b01010101, 0b01010101]);

1651

1652

2

        word.set_bytes([0b10101010, 0b10101010]);

1653

2

        assert_eq!(word.data, [0b10101010, 0b10101010]);

1654

2

        assert_eq!(word.as_bytes(), [0b10101010, 0b10101010]);

1655

1656

2

        word = StatusWord::from_bytes([0b01010101, 0b01010101]);

1657

2

        assert_eq!(word.data, [0b01010101, 0b01010101]);

1658

2

        assert_eq!(word.as_bytes(), [0b01010101, 0b01010101]);

1659

2

1660

1661

    #[test]

1662

2

    fn test_status_word_parity() {

1663

2

        let mut word = StatusWord::from(0).with_parity(0);

1664

2

        assert_eq!(word.parity, 0);

1665

2

        assert_eq!(word.parity(), 0);

1666

2

        assert_eq!(word.check_parity(), false);

1667

1668

2

        word.set_parity(1);

1669

2

        assert_eq!(word.parity, 1);

1670

2

        assert_eq!(word.parity(), 1);

1671

2

        assert_eq!(word.check_parity(), true);

1672

1673

2

        word = StatusWord::from(1).with_calculated_parity();

1674

2

        assert_eq!(word.parity, 0);

1675

2

        assert_eq!(word.parity(), 0);

1676

2

        assert_eq!(word.check_parity(), true);

1677

2

1678

1679

    #[test]

1680

2

    fn test_status_word_build_success() {

1681

2

        let word = StatusWord::new().with_calculated_parity().build();

1682

2

        assert!(word.is_ok());

1683

2

1684

1685

    #[test]

1686

2

    fn test_status_word_build_fail() {

1687

2

        let word = StatusWord::new().with_parity(0).build();

1688

2

        assert!(word.is_err());

1689

2

1690

1691

    // ----------------------------------------------------------

1692

1693

    #[test]

1694

2

    fn test_status_default() {

1695

2

        let word = StatusWord::default();

1696

2

        assert_eq!(word.data, [0, 0]);

1697

2

        assert_eq!(word.parity, 1);

1698

2

1699

1700

    #[test]

1701

2

    fn test_status_from_value() {

1702

2

        let word: StatusWord = 0b1010101010101010.into();

1703

2

        assert_eq!(word.as_value(), 0b1010101010101010);

1704

2

1705

1706

    #[test]

1707

2

    fn test_status_from_bytes() {

1708

2

        let word: StatusWord = [0b10101010, 0b10101010].into();

1709

2

        assert_eq!(word.as_value(), 0b1010101010101010);

1710

2

1711

1712

    #[test]

1713

2

    fn test_status_into_value() {

1714

2

        let word = StatusWord::from(0b1010101010101010);

1715

2

        let value = u16::from(word);

1716

2

        assert_eq!(value, 0b1010101010101010);

1717

2

1718

1719

    #[test]

1720

2

    fn test_status_into_bytes() {

1721

2

        let word = StatusWord::from(0b1010101010101010);

1722

2

        let bytes = <[u8; 2]>::from(word);

1723

2

        assert_eq!(bytes, [0b10101010, 0b10101010]);

1724

2

1725

1726

    // ----------------------------------------------------------

1727

    // DataWord

1728

1729

    #[test]

1730

2

    fn test_data_get_set_string_success() {

1731

2

        let mut word = DataWord::new().with_string("HI").unwrap();

1732

2

        assert_eq!(word.as_bytes(), [0b01001000, 0b01001001]);

1733

2

        assert_eq!(word.as_value(), 0b0100100001001001u16);

1734

2

        assert_eq!(word.as_string(), Ok("HI"));

1735

2

        assert_eq!(word.parity(), 0);

1736

1737

2

        word.set_string("NO").unwrap();

1738

2

        assert_eq!(word.as_bytes(), [0b01001110, 0b01001111]);

1739

2

        assert_eq!(word.as_value(), 0b0100111001001111);

1740

2

        assert_eq!(word.as_string(), Ok("NO"));

1741

2

        assert_eq!(word.parity(), 0);

1742

2

1743

1744

    #[test]

1745

2

    fn test_data_get_set_string_failure() {

1746

2

        let mut word = DataWord::new().with_string("HI").unwrap();

1747

2

1748

2

        // fails if string is too long without modifying data

1749

2

        let result = word.set_string("TOO LONG");

1750

2

        assert_eq!(word.as_string(), Ok("HI"));

1751

2

        assert_eq!(word.parity(), 0);

1752

2

        assert!(result.is_err());

1753

1754

        // fails to return a string if not valid utf-8

1755

2

        word.set_value(0b1111111111111111);

1756

2

        assert_eq!(word.as_value(), 0b1111111111111111);

1757

2

        assert!(word.as_string().is_err());

1758

2

        assert_eq!(word.parity(), 1);

1759

2

1760

1761

    #[test]

1762

2

    fn test_data_roundtrip() {

1763

2

        let word1 = DataWord::from_value(0b0110100001101001);

1764

2

        let data1 = word1.as_bytes();

1765

2

1766

2

        let word2 = DataWord::from_bytes(data1);

1767

2

        let data2 = word2.as_bytes();

1768

2

1769

2

        assert_eq!(data1, [0b01101000, 0b01101001]);

1770

2

        assert_eq!(data2, [0b01101000, 0b01101001]);

1771

2

        assert_eq!(word1, word2);

1772

2

1773

1774

    // ----------------------------------------------------------

1775

    // DataWord: Word

1776

1777

    #[test]

1778

2

    fn test_data_word_new() {

1779

2

        let word = StatusWord::new();

1780

2

        assert_eq!(word.data, [0, 0]);

1781

2

        assert_eq!(word.parity, 1);

1782

2

1783

1784

    #[test]

1785

2

    fn test_data_word_value() {

1786

2

        let mut word = DataWord::new().with_value(0b0101010101010101);

1787

2

        assert_eq!(word.data, [0b01010101, 0b01010101]);

1788

2

        assert_eq!(word.as_value(), 0b0101010101010101);

1789

1790

2

        word.set_value(0b1010101010101010);

1791

2

        assert_eq!(word.data, [0b10101010, 0b10101010]);

1792

2

        assert_eq!(word.as_value(), 0b1010101010101010);

1793

1794

2

        word = DataWord::from_value(0b0101010101010101);

1795

2

        assert_eq!(word.data, [0b01010101, 0b01010101]);

1796

2

        assert_eq!(word.as_value(), 0b0101010101010101);

1797

2

1798

1799

    #[test]

1800

2

    fn test_data_word_bytes() {

1801

2

        let mut word = DataWord::new().with_bytes([0b01010101, 0b01010101]);

1802

2

        assert_eq!(word.data, [0b01010101, 0b01010101]);

1803

2

        assert_eq!(word.as_bytes(), [0b01010101, 0b01010101]);

1804

1805

2

        word.set_bytes([0b10101010, 0b10101010]);

1806

2

        assert_eq!(word.data, [0b10101010, 0b10101010]);

1807

2

        assert_eq!(word.as_bytes(), [0b10101010, 0b10101010]);

1808

1809

2

        word = DataWord::from_bytes([0b01010101, 0b01010101]);

1810

2

        assert_eq!(word.data, [0b01010101, 0b01010101]);

1811

2

        assert_eq!(word.as_bytes(), [0b01010101, 0b01010101]);

1812

2

1813

1814

    #[test]

1815

2

    fn test_data_word_parity() {

1816

2

        let mut word = DataWord::from(0).with_parity(0);

1817

2

        assert_eq!(word.parity, 0);

1818

2

        assert_eq!(word.parity(), 0);

1819

2

        assert_eq!(word.check_parity(), false);

1820

1821

2

        word.set_parity(1);

1822

2

        assert_eq!(word.parity, 1);

1823

2

        assert_eq!(word.parity(), 1);

1824

2

        assert_eq!(word.check_parity(), true);

1825

1826

2

        word = DataWord::from(1).with_calculated_parity();

1827

2

        assert_eq!(word.parity, 0);

1828

2

        assert_eq!(word.parity(), 0);

1829

2

        assert_eq!(word.check_parity(), true);

1830

2

1831

1832

    #[test]

1833

2

    fn test_data_build_success() {

1834

2

        let word = DataWord::new().with_calculated_parity().build();

1835

2

        assert!(word.is_ok());

1836

2

1837

1838

    #[test]

1839

2

    fn test_data_build_fail() {

1840

2

        let word = DataWord::new().with_parity(0).build();

1841

2

        assert!(word.is_err());

1842

2

1843

1844

    // ----------------------------------------------------------

1845

1846

    #[test]

1847

2

    fn test_data_default() {

1848

2

        let word = DataWord::default();

1849

2

        assert_eq!(word.data, [0, 0]);

1850

2

        assert_eq!(word.parity, 1);

1851

2

1852

1853

    #[test]

1854

2

    fn test_data_try_from_string_success() {

1855

2

        let result = DataWord::try_from("HI");

1856

2

        assert!(result.is_ok());

1857

2

1858

1859

    #[test]

1860

2

    fn test_data_try_from_string_fail() {

1861

2

        let result = DataWord::try_from("TOO LONG");

1862

2

        assert!(result.is_err());

1863

2

1864

1865

    #[test]

1866

2

    fn test_data_from_value() {

1867

2

        let word: DataWord = 0b1010101010101010.into();

1868

2

        assert_eq!(word.as_value(), 0b1010101010101010);

1869

2

1870

1871

    #[test]

1872

2

    fn test_data_from_bytes() {

1873

2

        let word: DataWord = [0b10101010, 0b10101010].into();

1874

2

        assert_eq!(word.as_value(), 0b1010101010101010);

1875

2

1876

1877

    #[test]

1878

2

    fn test_data_into_value() {

1879

2

        let word = DataWord::from(0b1010101010101010);

1880

2

        let value = u16::from(word);

1881

2

        assert_eq!(value, 0b1010101010101010);

1882

2

1883

1884

    #[test]

1885

2

    fn test_data_into_bytes() {

1886

2

        let word = DataWord::from(0b1010101010101010);

1887

2

        let bytes = <[u8; 2]>::from(word);

1888

2

        assert_eq!(bytes, [0b10101010, 0b10101010]);

1889

2

1890

1891

    #[test]

1892

2

    fn test_data_into_u32() {

1893

2

        let word = DataWord::from(0b0000000010101010);

1894

2

        let value = u32::from(word);

1895

2

        assert_eq!(value, 170); // decimal

1896

2

1897

1898

    #[test]

1899

2

    fn test_data_into_u64() {

1900

2

        let word = DataWord::from(0b0000000010101010);

1901

2

        let value = u64::from(word);

1902

2

        assert_eq!(value, 170); // decimal

1903

2

1904

1905

    #[test]

1906

2

    fn test_data_into_i16() {

1907

2

        let word = DataWord::from(0b0000000010101010);

1908

2

        let value = i16::from(word);

1909

2

        assert_eq!(value, 170); // decimal

1910

2

1911

1912

    #[test]

1913

2

    fn test_data_into_i32() {

1914

2

        let word = DataWord::from(0b0000000010101010);

1915

2

        let value = i32::from(word);

1916

2

        assert_eq!(value, 170); // decimal

1917

2

1918

1919

    #[test]

1920

2

    fn test_data_into_i64() {

1921

2

        let word = DataWord::from(0b0000000010101010);

1922

2

        let value = i64::from(word);

1923

2

        assert_eq!(value, 170); // decimal

1924

2

1925