cresip 0.9.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 43fd46eee2a87a033259dde9c85f15fff84eaa1c
+  data.tar.gz: 81b6b036ad0218f1f5f9ef53a339393311224fbe
+SHA512:
+  metadata.gz: f119fc6dc874f74a4ff0a157dd80871b3843276d24008ce688c7c6552376205c7f50de34f62cd4a757b366aeb0d04346d27fb2f964df3461fa19f05c971a33ca
+  data.tar.gz: 5e45fe866d284a4fb7d2d79a94467330ff32b9b62c827ab7aa951247f51ce6a9b8412d5cfef74dd16dc151f2f4880b8a75a89fccf8d3944d6b05984845e764d4

data/README.md

@@ -0,0 +1,69 @@
+# Ruby CresIP
+
+Constructs and parses Crestron IP protocol packets that make it easier to communicate with Crestron devices that would otherwise require a crestron controller.
+It does not implement the transport layer so you can use it with native ruby, eventmachine, celluloid or the like.
+
+[![Build Status](https://travis-ci.org/acaprojects/ruby-cresip.svg?branch=master)](https://travis-ci.org/acaprojects/ruby-cresip)
+
+You'll still need to use Crestron Toolbox software to configure the devices.
+
+
+## Install the gem
+
+Install it with [RubyGems](https://rubygems.org/)
+
+    gem install cresip
+
+or add this to your Gemfile if you use [Bundler](http://gembundler.com/):
+
+    gem 'cresip'
+
+
+
+## Usage
+
+```ruby
+require 'cresip'
+
+values = {}
+cresip = CresIP.new do |message|
+    case message
+    when Action
+        if message.feedback?
+            values[message.join] = message.value
+        else
+            values[message.join] = message.value
+            # The request is a set value so maybe perform some action
+        end
+    when Echo
+        if not message.is_response?
+            # Send a response using you TCP transport
+            message.response.to_binary_s
+        end
+    when Register
+        if not message.reg_success?
+            # Send a response using you TCP transport
+            message.register.to_binary_s
+        end
+    end
+end
+cresip.read(byte_string)
+
+
+# You can also generate your own actions
+act = CresIP::Action.new
+
+# Supports Strings, Integers and true / false values
+act.value = 'hello crestron'
+act.join = 123
+
+# Send this string over the wire to communicate
+act.to_binary_s
+
+```
+
+
+
+## License and copyright
+
+MIT

data/cresip.gemspec

@@ -0,0 +1,28 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+    s.name        = "cresip"
+    s.version     = '0.9.0'
+    s.authors     = ["Stephen von Takach"]
+    s.email       = ["steve@cotag.me"]
+    s.licenses    = ["MIT"]
+    s.homepage    = "https://github.com/advancedcontrol/ruby-crescip"
+    s.summary     = "Crestron IP protocol on Ruby"
+    s.description = <<-EOF
+        Constructs and parses Crestron IP packets allowing you to communicate with Crestron devices without a controller
+    EOF
+
+
+    s.add_dependency 'bindata', '~> 2.3'
+
+    s.add_development_dependency 'rspec', '~> 3.5'
+    s.add_development_dependency 'yard',  '~> 0'
+    s.add_development_dependency 'rake',  '~> 11'
+
+
+    s.files = Dir["{lib}/**/*"] + %w(cresip.gemspec README.md)
+    s.test_files = Dir["spec/**/*"]
+    s.extra_rdoc_files = ["README.md"]
+
+    s.require_paths = ["lib"]
+end

data/lib/cresip.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true, encoding: ASCII-8BIT
+
+require 'bindata'
+
+require 'cresip/header'
+require 'cresip/register'
+require 'cresip/action'
+require 'cresip/echo'
+require 'cresip/serial'
+
+
+=begin
+    For testing 3series device control you can use the reserved joins
+    Analog Joins:  17201 == LCD Brightness
+    Digital Joins: 17229 == LCD Backlight On
+                   17230 == LCD Backlight Off
+=end
+
+
+class CresIP
+    HeartBeatRate = 5000 #ms
+    DefaultPort = 41794
+    TLSPort = 41796
+
+    def initialize(callback = nil, &block)
+        @callback = callback || block
+        @buffer = String.new
+    end
+
+    def read(data)
+        @buffer << data
+        while @buffer.length >= 3 do
+            header = PacketHeader.new
+            header.read(@buffer[0..2])
+            length = header.packet_size + 3
+
+            break if @buffer.length < length
+
+            payload = @buffer[3...length]
+            @buffer = @buffer[length..-1]
+
+            parse_packet(header, payload)
+        end
+    end
+
+    def parse_packet(header, payload)
+        case header.type
+        when :register, :register_response, :register_success
+            @callback.call Register.new(header, payload)
+
+        when :program_stopping
+            # Should we bother with a callback?
+
+        when :echo_request, :echo_response
+            @callback.call Echo.new(header, payload)
+
+        when :action_info
+            action_header = ActionHeader.new
+            action_header.read(payload)
+            @callback.call Action.new(header, action_header)
+
+        when :serial_data
+            @callback.call SerialData.new(header, payload)
+            
+        end
+    end
+end

data/lib/cresip/action.rb

@@ -0,0 +1,191 @@
+# frozen_string_literal: true, encoding: ASCII-8BIT
+
+class CresIP
+    PayloadType = {
+        0x00 => :digital_feedback,
+        0x01 => :analog_feedback,
+        0x02 => :serial_feedback,
+        0x03 => :update_request_incomming, # seems pointless and can be ignored
+        0x08 => :date_and_time,
+        0x27 => :digital_set,
+        0x14 => :analog_set,
+        0x12 => :serial_set
+        #0x20 => :??
+    }
+    PayloadType.merge!(PayloadType.invert)
+
+    class ActionHeader < BinData::Record
+        endian :big
+
+        uint8  :reserved
+        uint16 :payload_size,  :value => lambda { payload.length + 1 }
+        uint8  :payload_type
+        string :payload, :read_length => lambda { payload_size - 1 }
+
+        def type
+            PayloadType[payload_type]
+        end
+    end
+
+
+    # Digital Feedback: 05 0006 000003 00 1300
+    # Analog Set:       05 0008 000005 14 004204d2
+    # Date & Time:(dev) 05 000b 000008 08 0e230710092216
+    #      (controller) 05 000b 000008 08 0e230709092216
+    # Unknown:    (dev) 05 0009 000006 20 0103009201
+    #             (dev) 05 000a 000007 20 01041500f203
+    #      (controller) 05 0014 000011 20 110e1c050000444d204f757470757473
+    # Update Incomming: 05 0005 000002 03 00    (device & server)
+    #                   05 0006 000003 03 2107  (device)
+    #                   05 0005 000002 03 16    (server)
+    # Serial Set: (dev) 05 0013 000010 12 03444d2d54582d344b2d3330322d43
+    class Action
+        def initialize(header = PacketHeader.new, action = ActionHeader.new)
+            @header = header
+            @action = action
+            @header.packet_type = PacketTypes[:action_info]
+
+            if action.type && self.respond_to?(action.type, true)
+                @join, @value = self.send(action.type, action.payload)
+            end
+        end
+
+        attr_reader :header, :action, :join, :value
+
+        def type
+            @action.type
+        end
+
+        def payload
+            @action.payload
+        end
+
+        Feedback = [:analog_feedback, :digital_feedback, :serial_feedback]
+        def feedback?
+            Feedback.include? @action.type
+        end
+
+        def to_binary_s
+            action_resp = @action.to_binary_s
+            @header.packet_size = action_resp.length
+            "#{@header.to_binary_s}#{action_resp}"
+        end
+
+        def set_value(data, type: :set, join: @join)
+            case data
+            when String
+                @action.payload_type = type == :set ? PayloadType[:serial_set] : PayloadType[:serial_feedback]
+                @action.payload = encode_serial_set(join, data)
+            when Integer
+                @action.payload_type = type == :set ? PayloadType[:analog_set] : PayloadType[:analog_feedback]
+                @action.payload = encode_analog_set(join, data)
+            when true, false
+                @action.payload_type = type == :set ? PayloadType[:digital_set] : PayloadType[:digital_feedback]
+                @action.payload = encode_digital_set(join, data)
+            else
+                raise 'invalid data type'
+            end
+
+            @join = join
+            @value = data
+        end
+
+        def set_join(number)
+            @join = number
+            # this keeps the binary representation up to date
+            set_value(@value)
+            number
+        end
+
+
+        protected
+
+
+        def digital_feedback(string)
+            bytes = string.bytes
+
+            join = 1 + ((bytes[1] & 0x7F) << 8) + bytes[0]
+            # value == true, high/press
+            # value == false, low/release
+            value = (bytes[1] & 0x80) == 0
+
+            [join, value]
+        end
+        alias_method :digital_set, :digital_feedback
+
+        def encode_digital_set(join, value)
+            join -= 1
+            high = (join & 0x7F00) >> 8
+            high = high | 0x80 unless value
+            low = join & 0xFF
+            [low, high].pack('c*')
+        end
+
+        def analog_feedback(string)
+            bytes = string.bytes
+
+            if bytes.length == 4
+                join = 1 + (bytes[0] << 8) + bytes[1]
+                value = (bytes[2] << 8) + bytes[3]
+            else
+                join = 1 + bytes[0]
+                value = (bytes[1] << 8) + bytes[2]
+            end
+
+            [join, value]
+        end
+        alias_method :analog_set, :analog_feedback
+
+        def encode_analog_set(join, value)
+            output = []
+            join -= 1
+            output << ((join & 0xFF00) >> 8)
+            output << (join & 0xFF)
+            output << ((value & 0xFF00) >> 8)
+            output << (value & 0xFF)
+            output.pack('c*')
+        end
+
+        # NOTE:: Have not seen this returned, untested
+        # Ref: https://github.com/CommandFusion/CIP/blob/master/CommandFusion/CIPv1.1.js#L165
+        def serial_feedback(string)
+            rows = string.split("\r")
+            joinLength = rows[0].index(',');
+            join = rows[0][1...joinLength].to_i
+            
+            value = String.new
+            rows.each_with_index do |row, i|
+                text = row[(joinLength + 1)..-1];
+                if row == 0
+                    if row[0] == '#'
+                        value << "\r#{row}" if row.length > 0
+                    elsif row[0] == '@'
+                        value << row
+                    end
+                else
+                    if row.empty? && !(i == (rows.length - 1) && value.empty?)
+                        value << "\r"
+                    else
+                        value << row
+                    end
+                end
+            end
+
+            [join, value]
+        end
+
+        def serial_set(string)
+            join = string.getbyte(0)
+            value = string[1..-1]
+            [join, value]
+        end
+
+        def encode_serial_set(join, value)
+            output = String.new
+            output << join
+            output << value
+            output
+        end
+    end
+
+end

data/lib/cresip/echo.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true, encoding: ASCII-8BIT
+
+=begin Example Data
+    Device sent:     0d 0002 0000
+    Controller sent: 0e 0002 0000
+=end
+
+class CresIP
+    class Echo
+        def initialize(header, payload)
+            @header = header
+            @payload = payload
+        end
+
+        attr_reader :header, :payload
+
+        def type
+            @header.type
+        end
+
+        def is_response?
+            @header.type == :echo_response
+        end
+
+        def response
+            head = PacketHeader.new
+            head.packet_type = PacketTypes[:echo_response]
+            head.packet_size = @payload.length
+            Echo.new(head, @payload)
+        end
+
+        def to_binary_s
+            "#{@header.to_binary_s}#{@payload}"
+        end
+    end
+end

data/lib/cresip/header.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true, encoding: ASCII-8BIT
+
+class CresIP
+    PacketTypes = {
+        # Registering
+        0x0f => :register,
+        0x01 => :register_response, # panel
+        0x0a => :register_response, # device
+        0x02 => :register_success,
+        
+        0x03 => :program_stopping,
+
+        # Feeback and requests
+        0x05 => :action_info,
+        0x12 => :serial_data,
+
+        # Used for heartbeat
+        0x0d => :echo_request,
+        0x0e => :echo_response
+    }
+    PacketTypes.merge!(PacketTypes.invert)
+
+    class PacketHeader < BinData::Record
+        endian :big
+
+        uint8  :packet_type
+        uint16 :packet_size
+
+        def type
+            PacketTypes[packet_type]
+        end
+    end
+end

data/lib/cresip/register.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true, encoding: ASCII-8BIT
+
+=begin Example Data
+    server:
+        0f 0001 02 (request IP ID Register, switch should send IPID)
+    switch:
+        0a 000a 00 05 a34240 02 00000000
+        (IPID: 0x03 to 0xFE === 05) (byte 5)
+        (RESP: 0x02)
+    server:
+        02 0004 00000003 (IP ID registry success)
+        failed response: 02 0003 ffff02
+=end
+
+class CresIP
+    class Register
+        def initialize(header = PacketHeader.new, payload = "\x02")
+            @header = header
+            @payload = payload
+
+            if @header.type == nil
+                @header.packet_type = PacketTypes[:register]
+            end
+        end
+
+        attr_reader :header, :payload
+
+        def type
+            @header.type
+        end
+
+        def registering?
+            @header.type == :register_response
+        end
+
+        def reg_success?
+            @header.type == :register_success && @payload.length == 4
+        end
+
+        def respond(success = true)
+            head = PacketHeader.new
+            head.packet_type = PacketTypes[:register_success]
+
+            if success
+                Register.new(head, "\x00\x00\x00\x03")
+            else
+                Register.new(head, "\xff\xff\x02")
+            end
+        end
+
+        def register(ipid = 5, type = 0x0a)
+            # IPID Range: 0x03..0xFE
+
+            head = PacketHeader.new
+            # I think 0x0A is a switcher register response
+            # and     0x01 is touch screen 
+            head.packet_type = type
+            payload = if type == 0x0a
+                # 0a000a00 ipid a342400200000000
+                "\x00#{ipid.chr}\xa3\x42\x40\x02\x00\x00\x00\x00"
+            else
+                # 0100077F00000100 ipid 40
+                "\x7F\x00\x00\x01\x00#{ipid.chr}\x40"
+            end
+            Register.new(head, payload)
+        end
+
+        def to_binary_s
+            @header.packet_size = @payload.bytesize
+            "#{@header.to_binary_s}#{@payload}"
+        end
+    end
+end

data/lib/cresip/serial.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true, encoding: ASCII-8BIT
+
+# NOTE:: No example data
+
+class CresIP
+    class SerialData
+        def initialize(header, payload)
+            @header = header
+            @payload = payload
+
+            @value = parse_serial_data(payload.bytes)
+        end
+
+        attr_reader :header, :payload
+
+        def type
+            @header.type
+        end
+
+
+        protected
+
+
+        Encodings = {
+            3 => 'ASCII-8BIT',
+            7 => 'UTF-16BE'
+        }
+        def parse_serial_data(bytes)
+            len = (bytes[0] << 24) + (bytes[1] << 16) + (bytes[2] << 8) + bytes[3]
+            join = 1 + (bytes[5] << 8) + bytes[6]
+            encoding = bytes[7]
+            string = bytes[8...(len + 4)].pack('c*')
+            enc = Encodings[encoding]
+
+            # Not sure if this will work as don't have any sample data.
+            # Reference: https://github.com/ironiridis/control4go/blob/master/crestron/packets.go#L149
+            string.force_encoding(enc) if enc
+        end
+    end
+end

data/spec/cresip_spec.rb

@@ -0,0 +1,212 @@
+# frozen_string_literal: true, encoding: ASCII-8BIT
+
+require 'cresip'
+
+
+describe CresIP do
+    before :each do
+        @packets = []
+        @cip = CresIP.new do |packet|
+            @packets << packet
+        end
+    end
+
+    it "should parse echo requests" do
+        @cip.read("\x0d\x00\x02\x00\x00")
+        expect(@packets.length).to be(1)
+
+        echo = @packets[0]
+        expect(echo.to_binary_s).to eq("\x0d\x00\x02\x00\x00")
+        expect(echo.is_response?).to be(false)
+        expect(echo.response.is_response?).to be(true)
+        expect(echo.response.to_binary_s).to eq("\x0e\x00\x02\x00\x00")
+    end
+
+    it "should perform registration tasks" do
+        req = CresIP::Register.new
+        expect(req.to_binary_s).to eq("\x0f\x00\x01\x02")
+
+        @cip.read(req.to_binary_s)
+        expect(@packets.length).to be(1)
+
+        # Test basic parsing
+        req = @packets[0]
+        expect(req.to_binary_s).to eq("\x0f\x00\x01\x02")
+        expect(req.registering?).to be(false)
+        expect(req.reg_success?).to be(false)
+
+        # Test responding to the registration request
+        resp = req.register
+        expect(resp.to_binary_s).to eq("\x0a\x00\x0a\x00\x05\xa3\x42\x40\x02\x00\x00\x00\x00")
+        @cip.read(resp.to_binary_s)
+        expect(@packets.length).to be(2)
+        req = @packets[-1]
+        expect(req.to_binary_s).to eq("\x0a\x00\x0a\x00\x05\xa3\x42\x40\x02\x00\x00\x00\x00")
+        expect(req.registering?).to be(true)
+        expect(req.reg_success?).to be(false)
+
+        # Test responding to the registration request
+        resp = req.respond
+        expect(resp.to_binary_s).to eq("\x02\x00\x04\x00\x00\x00\x03")
+        @cip.read(resp.to_binary_s)
+        expect(@packets.length).to be(3)
+        req = @packets[-1]
+        expect(req.to_binary_s).to eq("\x02\x00\x04\x00\x00\x00\x03")
+        expect(req.registering?).to be(false)
+        expect(req.reg_success?).to be(true)
+
+        # Test a failed response
+        resp = req.respond false
+        expect(resp.to_binary_s).to eq("\x02\x00\x03\xff\xff\x02")
+        @cip.read(resp.to_binary_s)
+        expect(@packets.length).to be(4)
+        req = @packets[-1]
+        expect(req.to_binary_s).to eq("\x02\x00\x03\xff\xff\x02")
+        expect(req.registering?).to be(false)
+        expect(req.reg_success?).to be(false)
+    end
+
+    it "should parse digital requests" do
+        @cip.read("\x05\x00\x06\x00\x00\x03\x00\x13\x00")
+        expect(@packets.length).to be(1)
+
+        # Test basic parsing
+        req = @packets[0]
+        expect(req.to_binary_s).to eq("\x05\x00\x06\x00\x00\x03\x00\x13\x00")
+        expect(req.feedback?).to be(true)
+        expect(req.join).to be(20)
+        expect(req.value).to be(true)
+
+        # Test changing the value and type
+        req.set_value(false)
+        expect(req.value).to be(false)
+        expect(req.join).to be(20)
+        expect(req.feedback?).to be(false)
+        expect(req.to_binary_s).to eq("\x05\x00\x06\x00\x00\x03\x27\x13\x80")
+
+        # Test changing the join value and type
+        req.set_value(false, type: :feedback, join: 22)
+        expect(req.value).to be(false)
+        expect(req.join).to be(22)
+        expect(req.feedback?).to be(true)
+        expect(req.to_binary_s).to eq("\x05\x00\x06\x00\x00\x03\x00\x15\x80")
+
+        # Test generated values parse properly
+        @cip.read(req.to_binary_s)
+        expect(@packets.length).to be(2)
+
+        req2 = @packets[-1]
+        expect(req2.value).to be(false)
+        expect(req2.join).to be(22)
+        expect(req2.feedback?).to be(true)
+    end
+
+    it "should parse analog requests" do
+        @cip.read("\x05\x00\x08\x00\x00\x05\x14\x00\x42\x04\xd2")
+        expect(@packets.length).to be(1)
+
+        # Test basic parsing
+        req = @packets[0]
+        expect(req.to_binary_s).to eq("\x05\x00\x08\x00\x00\x05\x14\x00\x42\x04\xd2")
+        expect(req.feedback?).to be(false)
+        expect(req.join).to be(67)
+        expect(req.value).to be(1234)
+
+        # Test changing the value
+        req.set_value(45)
+        expect(req.value).to be(45)
+        expect(req.join).to be(67)
+        expect(req.feedback?).to be(false)
+        expect(req.to_binary_s).to eq("\x05\x00\x08\x00\x00\x05\x14\x00\x42\x00\x2d")
+
+        # Test changing the value, type and join
+        req.set_value(46, type: :feedback, join: 22)
+        expect(req.value).to be(46)
+        expect(req.join).to be(22)
+        expect(req.feedback?).to be(true)
+        expect(req.to_binary_s).to eq("\x05\x00\x08\x00\x00\x05\x01\x00\x15\x00\x2e")
+
+        # Test generated values parse properly
+        @cip.read(req.to_binary_s)
+        expect(@packets.length).to be(2)
+
+        req2 = @packets[-1]
+        expect(req2.value).to be(46)
+        expect(req2.join).to be(22)
+        expect(req2.feedback?).to be(true)
+    end
+
+    it "should parse serial requests" do
+        @cip.read("\x05\x00\x18\x00\x00\x15\x12\x15\x53\x74\x72\x65\x61\x6d\x69\x6e\x67\x20\x44\x6f\x77\x6e\x73\x63\x61\x6c\x65")
+        expect(@packets.length).to be(1)
+
+        # Test basic parsing
+        req = @packets[0]
+        expect(req.to_binary_s).to eq("\x05\x00\x18\x00\x00\x15\x12\x15\x53\x74\x72\x65\x61\x6d\x69\x6e\x67\x20\x44\x6f\x77\x6e\x73\x63\x61\x6c\x65")
+        expect(req.feedback?).to be(false)
+        expect(req.join).to be(21)
+        expect(req.value).to eq('Streaming Downscale')
+
+        # Test changing the value
+        req.set_value('Input 16', join: 15)
+        expect(req.value).to eq('Input 16')
+        expect(req.join).to be(15)
+        expect(req.feedback?).to be(false)
+        expect(req.to_binary_s).to eq("\x05\x00\x0d\x00\x00\x0a\x12\x0f\x49\x6e\x70\x75\x74\x20\x31\x36")
+
+        # Test generated values parse properly
+        @cip.read(req.to_binary_s)
+        expect(@packets.length).to be(2)
+
+        req2 = @packets[-1]
+        expect(req.value).to eq('Input 16')
+        expect(req.join).to be(15)
+        expect(req.feedback?).to be(false)
+    end
+
+    it "should work with unknown requests" do
+        # I don't know the format of the date and time data
+        @cip.read("\x05\x00\x0b\x00\x00\x08\x08\x0e\x23\x07\x10\x09\x22\x16")
+        expect(@packets.length).to be(1)
+        
+        # Test basic parsing
+        req = @packets[0]
+        expect(req.to_binary_s).to eq("\x05\x00\x0b\x00\x00\x08\x08\x0e\x23\x07\x10\x09\x22\x16")
+        expect(req.feedback?).to be(false)
+        expect(req.join).to be(nil)
+        expect(req.value).to be(nil)
+        expect(req.type).to be(:date_and_time)
+
+        # Not sure what the point of the updates incomming packet are
+        @cip.read("\x05\x00\x06\x00\x00\x03\x03\x21\x07")
+        expect(@packets.length).to be(2)
+        
+        # Test basic parsing
+        req = @packets[-1]
+        expect(req.to_binary_s).to eq("\x05\x00\x06\x00\x00\x03\x03\x21\x07")
+        expect(req.feedback?).to be(false)
+        expect(req.join).to be(nil)
+        expect(req.value).to be(nil)
+        expect(req.type).to be(:update_request_incomming)
+
+        # Pretty sure this is a DM switch packet...
+        @cip.read("\x05\x00\x0a\x00\x00\x07\x20\x01\x04\x15\x00\xf2\x03")
+        expect(@packets.length).to be(3)
+        
+        # Test basic parsing
+        req = @packets[-1]
+        expect(req.to_binary_s).to eq("\x05\x00\x0a\x00\x00\x07\x20\x01\x04\x15\x00\xf2\x03")
+        expect(req.feedback?).to be(false)
+        expect(req.join).to be(nil)
+        expect(req.value).to be(nil)
+        expect(req.type).to be(nil)
+    end
+
+    it 'should buffer messages' do
+        @cip.read("\x05\x00\x0b\x00\x00\x08\x08\x0e\x23\x07\x10\x09\x22")
+        expect(@packets.length).to be(0)
+
+        @cip.read("\x16\x05\x00\x0b\x00\x00\x08\x08\x0e\x23\x07\x10\x09\x22\x16")
+        expect(@packets.length).to be(2)
+    end
+end

metadata

@@ -0,0 +1,112 @@
+--- !ruby/object:Gem::Specification
+name: cresip
+version: !ruby/object:Gem::Version
+  version: 0.9.0
+platform: ruby
+authors:
+- Stephen von Takach
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-09-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bindata
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.3'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.5'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '11'
+description: "        Constructs and parses Crestron IP packets allowing you to communicate
+  with Crestron devices without a controller\n"
+email:
+- steve@cotag.me
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.md
+files:
+- README.md
+- cresip.gemspec
+- lib/cresip.rb
+- lib/cresip/action.rb
+- lib/cresip/echo.rb
+- lib/cresip/header.rb
+- lib/cresip/register.rb
+- lib/cresip/serial.rb
+- spec/cresip_spec.rb
+homepage: https://github.com/advancedcontrol/ruby-crescip
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: Crestron IP protocol on Ruby
+test_files:
+- spec/cresip_spec.rb