sockt/ecosystem-zwave - Change 26AB7MFFP3Y7GGZIMUTT3NOECEKWUSYFX6P4LZ2MGIEZNXO5XCMQC

Cleaning up some smelly code in driver

Created by jcdickinson on December 13, 2022

26AB7MFFP3Y7GGZIMUTT3NOECEKWUSYFX6P4LZ2MGIEZNXO5XCMQC

Dependencies

[2] V3N7ZSMUNTM4CK6DPSL3R5QZTAAOI25ROQ5OFJME32WGSSO4B7EQC

In channels

main

Change contents

Replacement in crates/zwave/src/driver/serial/serial_driver.rs at line 231 [2.6177]

B:BD[2.12453] → [2.12453:12531]

    self.read_at_least(1, timeout)?;
    let len = self.buffer.consume(1)[0];

[2.12453]

[2.12531]

    let (frame, result) = {
      self.read_at_least(1, timeout)?;
      let len = self.buffer.consume(1)[0];
      trace!("expecting a frame of {} bytes", len);

Replacement in crates/zwave/src/driver/serial/serial_driver.rs at line 236 [2.6177]

B:BD[2.12532] → [2.12532:12582]

    trace!("expecting a frame of {} bytes", len);

[2.12532]

[2.12582]

      let count = (len) as usize;
      self.read_at_least(count, timeout)?;
      let payload = self.buffer.consume(count);

Replacement in crates/zwave/src/driver/serial/serial_driver.rs at line 240 [2.6177]

B:BD[2.12583] → [2.12583:13472]

    let count = (len) as usize;
    self.read_at_least(count, timeout)?;
    let payload = self.buffer.consume(count);
    let (data, actual_checksum) = payload.split_at(count - 1);
    let expected_checksum = data.iter().fold(0xff ^ len, |a, b| a ^ b);
    if actual_checksum[0] != expected_checksum {
      debug!(
        "received a frame with an invalid checksum: {} != {}",
        actual_checksum[0], expected_checksum
      );
      drop(payload);
      debug!("sending nak");
      self.write_one(FrameType::Nak)?;
      return Err(ReadError::TimeoutOrBadFrame);
    }
    let raw_command = RawCommandData::new(data[1], &data[2..]);
    let command = match raw_command.try_into() {
      Err(e) => {
        debug!("received a frame with invalid data: {:?}", e);
        drop(payload);
        self.write_one(FrameType::Nak)?;
        return Err(ReadError::TimeoutOrBadFrame);

[2.12583]

[2.13472]

      let (data, actual_checksum) = payload.split_at(count - 1);
      let expected_checksum = data.iter().fold(0xff ^ len, |a, b| a ^ b);
      if actual_checksum[0] != expected_checksum {
        debug!(
          "received a frame with an invalid checksum: {} != {}",
          actual_checksum[0], expected_checksum
        );
        (FrameType::Nak, Err(ReadError::TimeoutOrBadFrame))
      } else {
        let raw_command = RawCommandData::new(data[1], &data[2..]);
        match raw_command.try_into() {
          Err(e) => {
            debug!("received a frame with invalid data: {:?}", e);
            (FrameType::Nak, Err(ReadError::TimeoutOrBadFrame))
          }
          Ok(v) => match data[0] {
            0x00 => (FrameType::Ack, Ok(Frame::Request(v))),
            0x01 => (FrameType::Ack, Ok(Frame::Response(v))),
            v => {
              debug!("received a frame with invalid type: {:02x}", v);
              (FrameType::Nak, Err(ReadError::TimeoutOrBadFrame))
            }
          },
        }

Deletion in crates/zwave/src/driver/serial/serial_driver.rs at line 265 [2.6177]

B:BD[2.13480] → [2.13480:13803]

      Ok(v) => match data[0] {
        0x00 => Frame::Request(v),
        0x01 => Frame::Response(v),
        v => {
          debug!("received a frame with invalid type: {:02x}", v);
          drop(payload);
          self.write_one(FrameType::Nak)?;
          return Err(ReadError::TimeoutOrBadFrame);
        }
      },

Replacement in crates/zwave/src/driver/serial/serial_driver.rs at line 266 [2.6177]
B:BD[2.13810] → [2.13810:13827]
```
    Ok(command)
```
[2.13810]
[2.13827]
```
    self.write_one(frame)?;
    result
```