Class: XBee::Packet

Inherits:
Object
  • Object
show all
Defined in:
lib/xbee/packet.rb

Constant Summary collapse

START_BYTE = 
0x7E
ESCAPE = 
0x7D
XON = 
0x11
XOFF = 
0x13
ESCAPE_XOR = 
0x20
ESCAPE_BYTES = 
[
  START_BYTE, ESCAPE, XON, XOFF
].freeze

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(data) ⇒ Packet

Returns a new instance of Packet.

Parameters:

  • data (Array<Integer>) —

    Byte array



130
131
132
 
# File 'lib/xbee/packet.rb', line 130

def initialize(data)
  @data = data
end

Class Method Details

.checksum(bytes) ⇒ Object 



23
24
25
 
# File 'lib/xbee/packet.rb', line 23

def checksum(bytes)
  255 - bytes.reduce(&:+) % 256
end

.escape(bytes, options = {}) ⇒ Array<Integer>

Escapes an array of bytes. Ignores the first byte unless ignore_first_byte is set to false in the options hash.

Parameters:

  • bytes (Array<Integer>) —

    The array of bytes to escape.

  • options (Hash) (defaults to: {}) —

    Options hash.

Options Hash (options):

  • :ignore_first_byte (Boolean) —

    If the first byte should be ignored (usually true for handling an entire packet since the first byte is START_BYTE). Default true.

Returns:

  • (Array<Integer>) —

    Escaped bytes.



33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
 
# File 'lib/xbee/packet.rb', line 33

def escape(bytes, options = {})
  ignore_first_byte = options.fetch :ignore_first_byte, true

  prepend = []
  if ignore_first_byte
    bytes = bytes.dup
    prepend = [bytes.shift]
  end

  prepend + bytes.reduce([]) do |escaped, b|
    if ESCAPE_BYTES.include?(b)
      escaped << ESCAPE
      escaped << (ESCAPE_XOR ^ b)
    else
      escaped << b
    end
  end
end

.from_byte_enum(bytes) ⇒ Object 



104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
 
# File 'lib/xbee/packet.rb', line 104

def from_byte_enum(bytes)
  begin
    loop until bytes.next == START_BYTE
    length = (next_unescaped_byte(bytes) << 8) + next_unescaped_byte(bytes)
  rescue
    raise IOError, 'Packet is too short, unable to read length fields.'
  end
  begin
    data = (1..length).map { next_unescaped_byte bytes }
  rescue
    raise IOError, "Expected data length to be #{length} but got fewer bytes"
  end
  begin
    crc = next_unescaped_byte bytes
  rescue
    raise IOError, 'Packet is too short, unable to read checksum'
  end
  if crc != checksum(data)
    raise IOError, "Expected checksum to be 0x#{checksum(data).to_s 16} but was 0x#{crc.to_s 16}"
  end
  new data
end

.from_bytes(bytes) ⇒ Object 



74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
 
# File 'lib/xbee/packet.rb', line 74

def from_bytes(bytes)
  if bytes.length < 4
    raise ArgumentError, "Packet is too short (only #{bytes.length} bytes)"
  end
  if bytes[0] != START_BYTE
    raise ArgumentError, 'Missing start byte'
  end
  data = [START_BYTE] + unescape(bytes[1..-1])
  length = (data[1] << 8) + data[2]
  if length != data.length - 4
    raise ArgumentError, "Expected data length to be #{length} but was #{data.length - 4}"
  end
  crc = checksum(data[3..-2])
  if crc != data[-1]
    raise ArgumentError, "Expected checksum to be 0x#{crc.to_s 16} but was 0x#{data[-1].to_s 16}"
  end
  new data[3..-2]
end

.next_unescaped_byte(bytes) ⇒ Object 



94
95
96
97
98
99
100
101
 
# File 'lib/xbee/packet.rb', line 94

def next_unescaped_byte(bytes)
  byte = bytes.next
  if byte == ESCAPE
    0x20 ^ bytes.next
  else
    byte
  end
end

.special_byte?(byte) ⇒ Boolean

Parameters:

  • byte (Integer)

Returns:

  • (Boolean) 


18
19
20
 
# File 'lib/xbee/packet.rb', line 18

def special_byte?(byte)
  ESCAPE_BYTES.include? byte
end

.unescape(bytes) ⇒ Array<Integer>

When provided a byte array that has escaped data, this returns a new byte array with just the raw data.

Parameters:

  • bytes (Array<Integer>) —

    Array of bytes to unescape.

Returns:

  • (Array<Integer>) —

    Array of unescaped bytes.



56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
 
# File 'lib/xbee/packet.rb', line 56

def unescape(bytes)
  byte_escaped = false
  bytes.reduce([]) do |unescaped, b|
    if byte_escaped
      unescaped << (0x20 ^ b)
      byte_escaped = false
    else
      if b == ESCAPE
        byte_escaped = true
      else
        unescaped << b
      end
    end
    unescaped
  end
end

Instance Method Details

#==(other) ⇒ Object 



166
167
168
 
# File 'lib/xbee/packet.rb', line 166

def ==(other)
  data == other.data
end

#bytes ⇒ Object 



150
151
152
 
# File 'lib/xbee/packet.rb', line 150

def bytes
  [START_BYTE, length >> 8, length & 0xff] + @data + [checksum]
end

#bytes_escaped ⇒ Object 



155
156
157
158
159
160
161
162
163
 
# File 'lib/xbee/packet.rb', line 155

def bytes_escaped
  [START_BYTE] + bytes[1..-1].flat_map do |b|
    if self.class.special_byte?(b)
      [ESCAPE, 0x20 ^ b]
    else
      b
    end
  end
end

#checksum ⇒ Object 



145
146
147
 
# File 'lib/xbee/packet.rb', line 145

def checksum
  Packet.checksum @data
end

#data ⇒ Object 



135
136
137
 
# File 'lib/xbee/packet.rb', line 135

def data
  @data
end

#length ⇒ Object 



140
141
142
 
# File 'lib/xbee/packet.rb', line 140

def length
  @data.length
end

#to_s ⇒ Object 



171
172
173
 
# File 'lib/xbee/packet.rb', line 171

def to_s
  'Packet [' + data.map { |b| "0x#{b.to_s 16}" }.join(', ') + ']'
end