diff --git a/CHANGES.md b/CHANGES.md
index d7b9594..4c9ed21 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -1,6 +1,14 @@
 
 # Changes
 
+## Version 0.7.0
+
+New Features:
+
+ - Add data type `tlv8.DataType.UNSIGNED_INTEGER` to make a distinction between the default of 
+   signed integers and unsigned integer. This is important for read network ports from TLV 
+   structures
+
 ## Version 0.6.0
 
 New Features:
diff --git a/setup.py b/setup.py
index 2c78c95..4918c36 100644
--- a/setup.py
+++ b/setup.py
@@ -23,14 +23,14 @@
 setuptools.setup(
     name='tlv8',
     packages=setuptools.find_packages(exclude=['tests']),
-    version='0.6.0',
+    version='0.7.0',
     description='Python module to handle type-length-value (TLV) encoded data 8-bit type, 8-bit length, and N-byte '
                 'value as described within the Apple HomeKit Accessory Protocol Specification Non-Commercial Version '
                 'Release R2.',
     author='Joachim Lusiardi',
     author_email='pypi@lusiardi.de',
     url='https://github.com/jlusiardi/tlv8_python',
-    download_url='https://github.com/jlusiardi/tlv8_python/archive/0.6.0.tar.gz',
+    download_url='https://github.com/jlusiardi/tlv8_python/archive/0.7.0.tar.gz',
     keywords=['TLV', 'Type-Length-Value', 'tlv8'],
     classifiers=[
         'License :: OSI Approved :: Apache Software License',
diff --git a/tests/__init__.py b/tests/__init__.py
index 1118bcf..83128b3 100644
--- a/tests/__init__.py
+++ b/tests/__init__.py
@@ -15,7 +15,8 @@
 #
 
 __all__ = [
-    'TestTLV8', 'TestTLV8Decode', 'TestTLV8Entry', 'TestTLV8Enum', 'TestTLV8EntryList', 'TestTLV8DeepDecode'
+    'TestTLV8', 'TestTLV8Decode', 'TestTLV8Entry', 'TestTLV8Enum', 'TestTLV8EntryList', 'TestTLV8DeepDecode',
+    'TestTLV8DecodeInteger'
 ]
 
 from tests.tlv8_encode_tests import TestTLV8
@@ -24,3 +25,4 @@
 from tests.tlv8_entry_tests import TestTLV8Entry
 from tests.tlv8_enum_test import TestTLV8Enum
 from tests.tlv8_entrylist_tests import TestTLV8EntryList
+from tests.tlv8_decode_integer_tests import TestTLV8DecodeInteger
diff --git a/tests/tlv8_decode_integer_tests.py b/tests/tlv8_decode_integer_tests.py
new file mode 100644
index 0000000..dbc8554
--- /dev/null
+++ b/tests/tlv8_decode_integer_tests.py
@@ -0,0 +1,175 @@
+#
+# Copyright 2020 Joachim Lusiardi
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+import unittest
+from struct import pack
+
+import tlv8
+
+
+class TestTLV8DecodeInteger(unittest.TestCase):
+    def test_decode_int1_neg(self):
+        input_data = b'\x01\x01' + pack('<b', -123)
+        structure = {
+            1: tlv8.DataType.INTEGER,
+        }
+        result = tlv8.decode(input_data, structure)
+        expected = tlv8.EntryList([
+            tlv8.Entry(1, -123),
+        ])
+        self.assertEqual(expected, result)
+
+    def test_decode_int1_pos(self):
+        input_data = b'\x01\x01' + pack('<b', 123)
+        structure = {
+            1: tlv8.DataType.INTEGER,
+        }
+        result = tlv8.decode(input_data, structure)
+        expected = tlv8.EntryList([
+            tlv8.Entry(1, 123),
+        ])
+        self.assertEqual(expected, result)
+
+    def test_decode_int1_un(self):
+        input_data = b'\x01\x01' + pack('<B', 123)
+        structure = {
+            1: tlv8.DataType.UNSIGNED_INTEGER,
+        }
+        result = tlv8.decode(input_data, structure)
+        expected = tlv8.EntryList([
+            tlv8.Entry(1, 123),
+        ])
+        self.assertEqual(expected, result)
+
+    def test_decode_int2_neg(self):
+        input_data = b'\x01\x02' + pack('<h', -12345)
+        structure = {
+            1: tlv8.DataType.INTEGER,
+        }
+        result = tlv8.decode(input_data, structure)
+        expected = tlv8.EntryList([
+            tlv8.Entry(1, -12345),
+        ])
+        self.assertEqual(expected, result)
+
+    def test_decode_int2_pos(self):
+        input_data = b'\x01\x02' + pack('<h', 12345)
+        structure = {
+            1: tlv8.DataType.INTEGER,
+        }
+        result = tlv8.decode(input_data, structure)
+        expected = tlv8.EntryList([
+            tlv8.Entry(1, 12345),
+        ])
+        self.assertEqual(expected, result)
+
+    def test_decode_int2_un(self):
+        input_data = b'\x01\x02' + pack('<H', 12345)
+        structure = {
+            1: tlv8.DataType.UNSIGNED_INTEGER,
+        }
+        result = tlv8.decode(input_data, structure)
+        expected = tlv8.EntryList([
+            tlv8.Entry(1, 12345),
+        ])
+        self.assertEqual(expected, result)
+
+    def test_decode_int3_signed(self):
+        input_data = b'\x01\x03\x01\x02\x03\x02\x02\x02\x03'
+        structure = {
+            1: tlv8.DataType.INTEGER,
+        }
+        self.assertRaises(ValueError, tlv8.decode, input_data, structure)
+
+    def test_decode_int3_unsigned(self):
+        input_data = b'\x01\x03\x01\x02\x03\x02\x02\x02\x03'
+        structure = {
+            1: tlv8.DataType.UNSIGNED_INTEGER,
+        }
+        self.assertRaises(ValueError, tlv8.decode, input_data, structure)
+        # tlv8.decode(input_data, structure)
+
+    def test_decode_int4_neg(self):
+        input_data = b'\x01\x04' + pack('<i', -12345)
+        structure = {
+            1: tlv8.DataType.INTEGER,
+        }
+        result = tlv8.decode(input_data, structure)
+
+        expected = tlv8.EntryList([
+            tlv8.Entry(1, -12345),
+        ])
+        self.assertEqual(expected, result)
+
+    def test_decode_int4_pos(self):
+        input_data = b'\x01\x04' + pack('<i', 12345)
+        structure = {
+            1: tlv8.DataType.INTEGER,
+        }
+        result = tlv8.decode(input_data, structure)
+
+        expected = tlv8.EntryList([
+            tlv8.Entry(1, 12345),
+        ])
+        self.assertEqual(expected, result)
+
+    def test_decode_int4_un(self):
+        input_data = b'\x01\x04' + pack('<I', 12345)
+        structure = {
+            1: tlv8.DataType.UNSIGNED_INTEGER,
+        }
+        result = tlv8.decode(input_data, structure)
+
+        expected = tlv8.EntryList([
+            tlv8.Entry(1, 12345),
+        ])
+        self.assertEqual(expected, result)
+
+    def test_decode_int8_neg(self):
+        input_data = b'\x01\x08' + pack('<q', -4611686018427387904)
+        structure = {
+            1: tlv8.DataType.INTEGER,
+        }
+        result = tlv8.decode(input_data, structure)
+
+        expected = tlv8.EntryList([
+            tlv8.Entry(1, -4611686018427387904),
+        ])
+        self.assertEqual(expected, result)
+
+    def test_decode_int8_pos(self):
+        input_data = b'\x01\x08' + pack('<q', 4611686018427387904)
+        structure = {
+            1: tlv8.DataType.INTEGER,
+        }
+        result = tlv8.decode(input_data, structure)
+
+        expected = tlv8.EntryList([
+            tlv8.Entry(1, 4611686018427387904),
+        ])
+        self.assertEqual(expected, result)
+
+    def test_decode_int8_un(self):
+        input_data = b'\x01\x08' + pack('<q', 4611686018427387904)
+        structure = {
+            1: tlv8.DataType.UNSIGNED_INTEGER,
+        }
+        result = tlv8.decode(input_data, structure)
+
+        expected = tlv8.EntryList([
+            tlv8.Entry(1, 4611686018427387904),
+        ])
+        self.assertEqual(expected, result)
diff --git a/tests/tlv8_decode_tests.py b/tests/tlv8_decode_tests.py
index 53718d2..eff8ed3 100644
--- a/tests/tlv8_decode_tests.py
+++ b/tests/tlv8_decode_tests.py
@@ -86,59 +86,6 @@ def test_decode_float(self):
         ])
         self.assertEqual(expected, result)
 
-    def test_decode_int1(self):
-        input_data = b'\x01\x01' + pack('<b', -123)
-        structure = {
-            1: tlv8.DataType.INTEGER,
-        }
-        result = tlv8.decode(input_data, structure)
-        expected = tlv8.EntryList([
-            tlv8.Entry(1, -123),
-        ])
-        self.assertEqual(expected, result)
-
-    def test_decode_int2(self):
-        input_data = b'\x01\x02' + pack('<h', 12345)
-        structure = {
-            1: tlv8.DataType.INTEGER,
-        }
-        result = tlv8.decode(input_data, structure)
-        expected = tlv8.EntryList([
-            tlv8.Entry(1, 12345),
-        ])
-        self.assertEqual(expected, result)
-
-    def test_decode_int3(self):
-        input_data = b'\x01\x03' + pack('<i', 12345)
-        structure = {
-            1: tlv8.DataType.INTEGER,
-        }
-        self.assertRaises(ValueError, tlv8.decode, input_data, structure)
-
-    def test_decode_int4(self):
-        input_data = b'\x01\x08' + pack('<q', 4611686018427387904)
-        structure = {
-            1: tlv8.DataType.INTEGER,
-        }
-        result = tlv8.decode(input_data, structure)
-
-        expected = tlv8.EntryList([
-            tlv8.Entry(1, 4611686018427387904),
-        ])
-        self.assertEqual(expected, result)
-
-    def test_decode_int8(self):
-        input_data = b'\x01\x04' + pack('<i', 12345)
-        structure = {
-            1: tlv8.DataType.INTEGER,
-        }
-        result = tlv8.decode(input_data, structure)
-
-        expected = tlv8.EntryList([
-            tlv8.Entry(1, 12345),
-        ])
-        self.assertEqual(expected, result)
-
     def test_decode_example_2(self):
         input_data = b'\x01\x01\x00'
         structure = {
diff --git a/tests/tlv8_encode_tests.py b/tests/tlv8_encode_tests.py
index b70dcbf..8484fe5 100644
--- a/tests/tlv8_encode_tests.py
+++ b/tests/tlv8_encode_tests.py
@@ -71,9 +71,9 @@ def test_float(self):
 
     def test_encode_different(self):
         data = [
-                tlv8.Entry(23, b'23', tlv8.DataType.BYTES),
-                tlv8.Entry(22, '23', tlv8.DataType.STRING)
-            ]
+            tlv8.Entry(23, b'23', tlv8.DataType.BYTES),
+            tlv8.Entry(22, '23', tlv8.DataType.STRING)
+        ]
         result = tlv8.encode(data)
         expected_data = data[0].encode() + data[1].encode()
         self.assertEqual(result, expected_data)
@@ -89,37 +89,37 @@ def test_encode_same_autodetect(self):
 
     def test_encode_same(self):
         data = [
-                tlv8.Entry(23, b'23', tlv8.DataType.BYTES),
-                tlv8.Entry(23, '23', tlv8.DataType.STRING)
-            ]
+            tlv8.Entry(23, b'23', tlv8.DataType.BYTES),
+            tlv8.Entry(23, '23', tlv8.DataType.STRING)
+        ]
         result = tlv8.encode(data)
         expected_data = data[0].encode() + b'\xff\x00' + data[1].encode()
         self.assertEqual(result, expected_data)
 
     def test_encode_same_set_sep_type(self):
         data = [
-                tlv8.Entry(23, b'23', tlv8.DataType.BYTES),
-                tlv8.Entry(23, '23', tlv8.DataType.STRING)
-            ]
+            tlv8.Entry(23, b'23', tlv8.DataType.BYTES),
+            tlv8.Entry(23, '23', tlv8.DataType.STRING)
+        ]
         result = tlv8.encode(data, 0)
         expected_data = data[0].encode() + b'\x00\x00' + data[1].encode()
         self.assertEqual(result, expected_data)
 
     def test_encode_same_set_sep_type_occurs(self):
         data = [
-                tlv8.Entry(23, '42'),
-                tlv8.Entry(23, '43')
-            ]
+            tlv8.Entry(23, '42'),
+            tlv8.Entry(23, '43')
+        ]
         with self.assertRaises(ValueError) as error_context:
             tlv8.encode(data, 23)
         self.assertEqual(str(error_context.exception), 'Separator type id 23 occurs with list of entries!')
 
     def test_encode_3same(self):
         data = [
-                tlv8.Entry(23, b'23', tlv8.DataType.BYTES),
-                tlv8.Entry(23, '23', tlv8.DataType.STRING),
-                tlv8.Entry(23, '23', tlv8.DataType.STRING)
-            ]
+            tlv8.Entry(23, b'23', tlv8.DataType.BYTES),
+            tlv8.Entry(23, '23', tlv8.DataType.STRING),
+            tlv8.Entry(23, '23', tlv8.DataType.STRING)
+        ]
         result = tlv8.encode(data)
         expected_data = \
             data[0].encode() + b'\xff\x00' + \
@@ -141,22 +141,22 @@ def test_encode_supported_rtp_configs(self):
 
     def test_encode_supported_video_stream_configuration(self):
         data = [
-            tlv8.Entry(1, [         # video codec config
-                tlv8.Entry(1, 0),   # h.264
-                tlv8.Entry(2, [     # video codec param
-                    tlv8.Entry(1, 0),   # Constrained Baseline Profile
-                    tlv8.Entry(2, 0),   # Level 3.1
-                    tlv8.Entry(3, 0),   # Packetization mode: Non-interleaved mode
-                    tlv8.Entry(4, 1),   # CVO not enabled
+            tlv8.Entry(1, [  # video codec config
+                tlv8.Entry(1, 0),  # h.264
+                tlv8.Entry(2, [  # video codec param
+                    tlv8.Entry(1, 0),  # Constrained Baseline Profile
+                    tlv8.Entry(2, 0),  # Level 3.1
+                    tlv8.Entry(3, 0),  # Packetization mode: Non-interleaved mode
+                    tlv8.Entry(4, 1),  # CVO not enabled
                     tlv8.Entry(5, 10),  # CVO ID
                 ]),
-                tlv8.Entry(3, [     # video attributes
-                    tlv8.Entry(1, 1280),    # width
+                tlv8.Entry(3, [  # video attributes
+                    tlv8.Entry(1, 1280),  # width
                     tlv8.Entry(2, 800),  # height
                     tlv8.Entry(3, 30)  # fps
                 ]),
-                tlv8.Entry(3, [     # video attributes
-                    tlv8.Entry(1, 640),     # width
+                tlv8.Entry(3, [  # video attributes
+                    tlv8.Entry(1, 640),  # width
                     tlv8.Entry(2, 480),  # height
                     tlv8.Entry(3, 30)  # fps
                 ])
@@ -184,39 +184,39 @@ def test_encode_supported_video_stream_configuration(self):
         result = tlv8.encode(data)
         expected_data = \
             b'\x01\x30' \
-                b'\x01\x01\x00' \
-                b'\x02\x0f' \
-                    b'\x01\x01\x00' \
-                    b'\x02\x01\x00' \
-                    b'\x03\x01\x00' \
-                    b'\x04\x01\x01' \
-                    b'\x05\x01\n' \
-                b'\x03\x0b' \
-                    b'\x01\x02\x00\x05' \
-                    b'\x02\x02 \x03' \
-                    b'\x03\x01\x1e' \
-                b'\xff\x00' \
-                b'\x03\x0b' \
-                    b'\x01\x02\x80\x02' \
-                    b'\x02\x02\xe0\x01' \
-                    b'\x03\x01\x1e' \
+            b'\x01\x01\x00' \
+            b'\x02\x0f' \
+            b'\x01\x01\x00' \
+            b'\x02\x01\x00' \
+            b'\x03\x01\x00' \
+            b'\x04\x01\x01' \
+            b'\x05\x01\n' \
+            b'\x03\x0b' \
+            b'\x01\x02\x00\x05' \
+            b'\x02\x02 \x03' \
+            b'\x03\x01\x1e' \
+            b'\xff\x00' \
+            b'\x03\x0b' \
+            b'\x01\x02\x80\x02' \
+            b'\x02\x02\xe0\x01' \
+            b'\x03\x01\x1e' \
             b'\xff\x00' \
             b'\x01\x2d' \
-                b'\x01\x01\x00' \
-                b'\x02\x0c' \
-                    b'\x01\x01\x00' \
-                    b'\x02\x01\x00' \
-                    b'\x03\x01\x00' \
-                    b'\x04\x01\x00' \
-                b'\x03\x0b' \
-                    b'\x01\x02\x00\x05' \
-                    b'\x02\x02 \x03' \
-                    b'\x03\x01\x1e' \
-                b'\xff\x00' \
-                b'\x03\x0b' \
-                    b'\x01\x02\x80\x02' \
-                    b'\x02\x02\xe0\x01' \
-                    b'\x03\x01\x1e'
+            b'\x01\x01\x00' \
+            b'\x02\x0c' \
+            b'\x01\x01\x00' \
+            b'\x02\x01\x00' \
+            b'\x03\x01\x00' \
+            b'\x04\x01\x00' \
+            b'\x03\x0b' \
+            b'\x01\x02\x00\x05' \
+            b'\x02\x02 \x03' \
+            b'\x03\x01\x1e' \
+            b'\xff\x00' \
+            b'\x03\x0b' \
+            b'\x01\x02\x80\x02' \
+            b'\x02\x02\xe0\x01' \
+            b'\x03\x01\x1e'
         self.assertEqual(result, expected_data)
 
     def test_autodetection_of_types(self):
@@ -239,7 +239,12 @@ def test_encode_error_2(self):
         self.assertRaises(ValueError, tlv8.encode, [1])
 
     def test_encode_128bit_int(self):
-        self.assertRaises(ValueError, tlv8.encode, [tlv8.Entry(1, 85070591730234615865843651857942052864)])
+        self.assertRaises(ValueError, tlv8.encode,
+                          [tlv8.Entry(1, 85070591730234615865843651857942052864, tlv8.DataType.UNSIGNED_INTEGER)])
+
+    def test_encode_128bit_signed_int(self):
+        self.assertRaises(ValueError, tlv8.encode,
+                          [tlv8.Entry(1, -85070591730234615865843651857942052864, tlv8.DataType.INTEGER)])
 
     def test_encode_64bit_int(self):
         result = tlv8.encode([tlv8.Entry(1, 4611686018427387904)])
@@ -253,8 +258,12 @@ def test_encode_16bit_int(self):
         result = tlv8.encode([tlv8.Entry(1, 16384)])
         self.assertEqual(b'\x01\x02\x00@', result)
 
-    def test_encode_8bit_int(self):
-        result = tlv8.encode([tlv8.Entry(1, 64)])
+    def test_encode_8bit_signed_int(self):
+        result = tlv8.encode([tlv8.Entry(1, -64, tlv8.DataType.INTEGER)])
+        self.assertEqual(b'\x01\x01\xc0', result)
+
+    def test_encode_8bit_unsigned_int(self):
+        result = tlv8.encode([tlv8.Entry(1, 64, tlv8.DataType.UNSIGNED_INTEGER)])
         self.assertEqual(b'\x01\x01@', result)
 
     def test_encode_non_encodable(self):
diff --git a/tlv8/__init__.py b/tlv8/__init__.py
index d0670cc..87bb814 100644
--- a/tlv8/__init__.py
+++ b/tlv8/__init__.py
@@ -296,7 +296,25 @@ def decode_int(tlv_entry):
         elif tlv_len == 8:
             tlv_entry.data = unpack('<q', tlv_entry.data)[0]
         else:
-            raise ValueError('Integer of unknown length: {len}'.format(len=tlv_len))
+            raise ValueError('Signed integer of unknown length: {len}'.format(len=tlv_len))
+
+    def decode_unsigned_int(tlv_entry):
+        """
+        Decode an int value from a tlv entry. This respects the length of the integer. The entry will be updated in
+        place.
+
+        :param tlv_entry: the tlv entry to decode
+        """
+        if tlv_len == 1:
+            tlv_entry.data = unpack('<B', tlv_entry.data)[0]
+        elif tlv_len == 2:
+            tlv_entry.data = unpack('<H', tlv_entry.data)[0]
+        elif tlv_len == 4:
+            tlv_entry.data = unpack('<I', tlv_entry.data)[0]
+        elif tlv_len == 8:
+            tlv_entry.data = unpack('<Q', tlv_entry.data)[0]
+        else:
+            raise ValueError('Unsigned integer of unknown length: {len}'.format(len=tlv_len))
 
     result = EntryList()
     for entry in tmp:
@@ -308,6 +326,8 @@ def decode_int(tlv_entry):
             tlv_len = len(entry.data)
             if expected_data_type == DataType.INTEGER:
                 decode_int(entry)
+            elif expected_data_type == DataType.UNSIGNED_INTEGER:
+                decode_unsigned_int(entry)
             elif expected_data_type == DataType.FLOAT:
                 entry.data = unpack('<f', entry.data)[0]
             elif expected_data_type == DataType.STRING:
@@ -336,6 +356,7 @@ class DataType(enum.IntEnum):
     FLOAT = 4
     STRING = 5
     AUTODETECT = 6  # only during encoding
+    UNSIGNED_INTEGER = 7
 
 
 class Entry:
@@ -421,6 +442,15 @@ def encode(self, separator_type_id=0xff):
                     pass
             if not remaining_data:
                 raise ValueError('Integer {val} was to big for encoding'.format(val=self.data))
+        elif data_type == DataType.UNSIGNED_INTEGER:
+            for int_format in ['<B', '<H', '<I', '<Q']:
+                try:
+                    remaining_data = pack(int_format, self.data)
+                    break
+                except error:
+                    pass
+            if not remaining_data:
+                raise ValueError('Integer {val} was to big for encoding'.format(val=self.data))
         elif data_type == DataType.FLOAT:
             remaining_data = pack('<f', self.data)
         elif data_type == DataType.STRING: