Index: ammosreader/AbstractAmmosReader.py
===================================================================
--- ammosreader/AbstractAmmosReader.py	(revision 87b2e39cb8bf9d88c411397bf66ed7dcfc06fe70)
+++ ammosreader/AbstractAmmosReader.py	(revision d7ea5259cdee870b9b52a13c04a76ab46fa5825f)
@@ -7,5 +7,5 @@
 from ammosreader.AmmosSingleFrame import AmmosSingleFrame
 from ammosreader.AmmosContainer import AmmosContainer
-from ammosreader.CAConstants import FrameType
+from ammosreader.AmmosConstants import FrameType
 
 
Index: ammosreader/AmmosAudioDataBlock.py
===================================================================
--- ammosreader/AmmosAudioDataBlock.py	(revision d7ea5259cdee870b9b52a13c04a76ab46fa5825f)
+++ ammosreader/AmmosAudioDataBlock.py	(revision d7ea5259cdee870b9b52a13c04a76ab46fa5825f)
@@ -0,0 +1,15 @@
+"""I provide an AMMOS data block for audio data frames."""
+
+
+class AmmosAudioDataBlock():
+    """I implement an AMMOS data block for audio data frames."""
+
+    def __init__(self, audio_datablock_header, audio_data_body):
+        """I return a new AMMOS data block for IF data frames."""
+        self.__header = audio_datablock_header
+        self.__body = audio_data_body
+
+    @property
+    def body(self):
+        """I return the raw pcm data with channels interweaved."""
+        return self.__body
Index: ammosreader/AmmosAudioDataBody.py
===================================================================
--- ammosreader/AmmosAudioDataBody.py	(revision 87b2e39cb8bf9d88c411397bf66ed7dcfc06fe70)
+++ ammosreader/AmmosAudioDataBody.py	(revision d7ea5259cdee870b9b52a13c04a76ab46fa5825f)
@@ -1,6 +1,10 @@
-class AmmosAudioDataBlock:
+"""I provide an AMMOS data block for audio data frames."""
+
+
+class AmmosAudioDataBody:
+    """I implement an AMMOS data block for audio data frames."""
 
     def __init__(self, pcm_data, number_of_channels=1, samples_per_channel=1, sample_size=1):
-
+        """I return a new AMMOS data block for audio data frames."""
         self.__number_of_channels = number_of_channels
         self.__samples_per_channel = samples_per_channel
@@ -10,7 +14,9 @@
     @property
     def data(self):
+        """I return the raw pcm data with channels interweaved."""
         return self.__data
 
     def pcm_for_channel(self, channel_number):
+        """I return the raw pcm data for a given channel."""
         start_offset = channel_number * self.__sample_size
         step = self.__sample_size * self.__number_of_channels
@@ -22,4 +28,5 @@
 
     def __str__(self):
+        """I return the string representation of myself."""
         return ("Number of channels:" + str(self.__number_of_channels) +
                 "\nSamples per channel:" + str(self.__samples_per_channel) +
Index: ammosreader/AmmosAudioDataHeader.py
===================================================================
--- ammosreader/AmmosAudioDataHeader.py	(revision 87b2e39cb8bf9d88c411397bf66ed7dcfc06fe70)
+++ ammosreader/AmmosAudioDataHeader.py	(revision d7ea5259cdee870b9b52a13c04a76ab46fa5825f)
@@ -1,24 +1,17 @@
+"""I provide an AMMOS data header for audio data frames."""
+
 import struct
-import numpy
+from ammosreader.AmmosConstants import AmmosAudioDemodType
 
-class AmmosAudioDemodType():
-
-    @classmethod
-    @property
-    def mapping(cls):
-        return {0: 'FM', 1: 'AM', 5: 'ISB', 6: 'CW',
-                7: 'USB', 8: 'LSB', 256: 'DIGITAL',
-                0xFFFFFFFF: 'UNKNOWN'}
-
-    def __init__(self, demod_type):
-        self.demod_type = demod_type
-
-    def __str__(self):
-        return AmmosAudioDemodType.mapping[self.demod_type]
 
 class AmmosAudioDataHeader():
+    """I implement an AMMOS data header for audio data frames."""
+
+    HEADER_SIZE = 36  # 9 words
 
     @classmethod
     def from_bytes(cls, bytes):
+        """I return an AMMOS data header from given bytes."""
+        assert len(bytes) == cls.HEADER_SIZE
         elements = struct.unpack('<IIQIIIII', bytes)
         sample_rate = elements[0]
@@ -26,12 +19,14 @@
         frequency = elements[2]
         demod_bandwidth = elements[3]
-        demod_type = elements[4]
-        sample_count = elements[5]
-        channel_count = elements[6]
+        demod_type = AmmosAudioDemodType(elements[4])
+        number_of_samples = elements[5]
+        number_of_channels = elements[6]
         sample_size = elements[7]
         return AmmosAudioDataHeader(sample_rate, status, frequency, demod_bandwidth, demod_type,
-                                    sample_count, channel_count, sample_size)
+                                    number_of_samples, number_of_channels, sample_size)
 
-    def __init__(self, sample_rate, status, frequency, demod_bandwidth, demod_type, sample_count, channel_count, sample_size):
+    def __init__(self, sample_rate, status, frequency, demod_bandwidth, demod_type, number_of_samples,
+                 number_of_channels, sample_size):
+        """I create a new instance of myself using the above parameters."""
         self.sample_rate = sample_rate
         self.status = status
@@ -39,9 +34,10 @@
         self.demod_bandwidth = demod_bandwidth
         self.demod_type = AmmosAudioDemodType(demod_type)
-        self.sample_count = sample_count
-        self.channel_count = channel_count
+        self.number_of_samples = number_of_samples
+        self.number_of_channels = number_of_channels
         self.sample_size = sample_size
 
     def __str__(self):
+        """I return the string representation of myself."""
         return ("\nAmmosAudioDataHeader\n" +
                 "Sample rate:" + str(self.sample_rate) + "\n" +
@@ -50,5 +46,5 @@
                 "Demodulation bandwidth:" + str(self.demod_bandwidth) + "\n" +
                 "Demodulation type:" + str(self.demod_type) + "\n" +
-                "Sample count:" + str(self.sample_count) + "\n" +
-                "Channel count:" + str(self.channel_count) + "\n" +
+                "Sample count:" + str(self.number_of_samples) + "\n" +
+                "Channel count:" + str(self.number_of_channels) + "\n" +
                 "Sample size:" + str(self.sample_size) + "\n")
Index: ammosreader/AmmosAudioReader.py
===================================================================
--- ammosreader/AmmosAudioReader.py	(revision 87b2e39cb8bf9d88c411397bf66ed7dcfc06fe70)
+++ ammosreader/AmmosAudioReader.py	(revision d7ea5259cdee870b9b52a13c04a76ab46fa5825f)
@@ -1,3 +1,4 @@
 """I provide a specialized Ammos Reader for audio data."""
+import logging
 
 from ammosreader.AbstractAmmosReader import AbstractAmmosReader
@@ -10,7 +11,4 @@
 class AmmosAudioReader(AbstractAmmosReader):
     """I read the audio data embedded in an R&S AMMOS recording."""
-
-    STANDARD_AUDIO_DATA_HEADER_SIZE = 36  # 9 words
-    EXTENDED_AUDIO_DATA_HEADER_SIZE = 44  # 11 words
 
     def __init__(self, file_name):
@@ -32,10 +30,11 @@
         :rtype: AmmosAudioDataHeader
         """
-        bytes = self.ammos_file.read(AmmosAudioReader.STANDARD_AUDIO_DATA_HEADER_SIZE)
+        header_size = AmmosAudioDataHeader.HEADER_SIZE
 
-        # print("\nReading global frame body standard data header\n")
-        if ((not bytes) or (len(bytes) < AmmosAudioReader.STANDARD_AUDIO_DATA_HEADER_SIZE)):
-            print("Can not read all", AmmosAudioReader.STANDARD_AUDIO_DATA_HEADER_SIZE,
-                  "bytes of global frame body data header")
+        bytes = self.ammos_file.read(header_size)
+
+        logging.info("\nReading global frame body standard data header\n")
+        if ((not bytes) or (len(bytes) < header_size)):
+            logging.debug("Can not read all %s bytes of global frame body data header", header_size)
             return None
         return AmmosAudioDataHeader.from_bytes(bytes)
@@ -48,21 +47,22 @@
         :rtype: AmmosExtendedAudioDataHeader
         """
-        bytes = self.ammos_file.read(AmmosAudioReader.EXTENDED_AUDIO_DATA_HEADER_SIZE)
+        header_size = AmmosExtendedAudioDataHeader.HEADER_SIZE
 
-        if ((not bytes) or (len(bytes) < AmmosAudioReader.EXTENDED_AUDIO_DATA_HEADER_SIZE)):
-            print("Can not read all ", AmmosAudioReader.EXTENDED_AUDIO_DATA_HEADER_SIZE,
-                  " bytes of global frame extended data header")
+        bytes = self.ammos_file.read(header_size)
+
+        if ((not bytes) or (len(bytes) < header_size)):
+            logging.debug("Can not read all %s bytes of global frame extended data header", header_size)
             return None
         return AmmosExtendedAudioDataHeader.from_bytes(bytes)
 
-    def read_next_audio_data_body(self, sample_count, channel_count, sample_size):
+    def read_next_audio_data_body(self, number_of_samples, number_of_channels, sample_size):
         """
         I return the next audio data read from current position in file.
 
-        :param sample_count: the number of samples per channel inside data body
-        :type sample_count: int
+        :param number_of_samples: the number of samples per channel inside data body
+        :type number_of_samples: int
 
-        :param channel_count: number of channels (e.g. mono, stereo or even more)
-        :type channel_count: int
+        :param number_of_channels: number of channels (e.g. mono, stereo or even more)
+        :type number_of_channels: int
 
         :param sample_size: sample size in bytes (1, 2 or 4 bytes)
@@ -72,15 +72,12 @@
         :rtype: bytes
         """
-        # FIXME: Describe the parameters better
-
-        total = sample_count*channel_count*sample_size
+        total = number_of_samples*number_of_channels*sample_size
 
         byte_string = self.ammos_file.read(total)
 
         if len(byte_string) != total:
-            print("Can not read all", total, "bytes of data body")
+            logging.debug("Can not read all %s bytes of data body", total)
             return None
-        # print([hex(c) for c in byte_string])
-        return AmmosAudioDataBlock(byte_string, channel_count, sample_count, sample_size)
+        return AmmosAudioDataBlock(byte_string, number_of_channels, number_of_samples, sample_size)
 
     def read_next_global_frame_body(self, data_header_length):
@@ -92,23 +89,23 @@
         audio_data_header = None
 
-        if data_header_length == AmmosAudioReader.STANDARD_AUDIO_DATA_HEADER_SIZE:
-            print("Read standard data header")
+        if data_header_length == AmmosAudioDataHeader.HEADER_SIZE:
+            logging.info("Read standard data header")
             audio_data_header = self.read_next_global_frame_body_data_header()
 
-        print("Data header length", data_header_length)
-        if data_header_length == AmmosAudioReader.EXTENDED_AUDIO_DATA_HEADER_SIZE:
-            print("Read extended data header")
+        logging.info("Data header length %s", data_header_length)
+        if data_header_length == AmmosExtendedAudioDataHeader.HEADER_SIZE:
+            logging.info("Read extended data header")
             audio_data_header = self.read_next_global_frame_body_extended_data_header()
 
         if audio_data_header is None:
-            print("Data header missing or format unknown")
+            logging.debug("Data header missing or format unknown")
             return None
 
-        audio_data_body = self.read_next_audio_data_body(audio_data_header.sample_count,
-                                                         audio_data_header.channel_count,
+        audio_data_body = self.read_next_audio_data_body(audio_data_header.number_of_samples,
+                                                         audio_data_header.number_of_channels,
                                                          audio_data_header.sample_size)
 
         if audio_data_body is None:
-            print("Data body missing")
+            logging.debug("Data body missing")
             return None
 
@@ -124,5 +121,3 @@
         :rtype: bytes
         """
-        for each in self.container.global_frames:
-            print(each.global_frame_body)
         return b"".join([each.global_frame_body.data_body.pcm_for_channel(a_channel) for each in self.container.global_frames])
Index: ammosreader/AmmosConstants.py
===================================================================
--- ammosreader/AmmosConstants.py	(revision d7ea5259cdee870b9b52a13c04a76ab46fa5825f)
+++ ammosreader/AmmosConstants.py	(revision d7ea5259cdee870b9b52a13c04a76ab46fa5825f)
@@ -0,0 +1,56 @@
+"""I provide several constants used in R&S software."""
+
+from enum import Enum
+
+
+class FrameType(int, Enum):
+    """I map numbers to human readable format specifiers."""
+
+    TEST_DATA = 0x00
+    IF_DATA_32BIT_REAL_IMAGINARY_FIXEDPOINT = 0x01
+    IF_DATA_16BIT_REAL_IMAGINARY_FIXEDPOINT = 0x02
+    IF_DATA_16BIT_REAL_REAL = 0x03
+    IF_DATA_32BIT_REAL_IMAGINARY_FIXEDPOINT_RESCALED = 0x04
+    IF_DATA_32BIT_REAL_IMAGINARY_FLOATINGPOINT_RESCALED = 0x05
+    SPECTRUM_DATA_8BIT = 0x10
+    SPECTRUM_DATA_16BIT = 0x11
+    SPECTRUM_DATA_32BIT = 0x12
+    SPECTRUM_DATA_32BIT_FLOATINGPOINT = 0x13
+    SEGMENTATION_SPECTRUM_DATA_32BIT_FLOATINGPOINT = 0x14
+    HF_TUNING_INDICATOR_DATA = 0x20
+    HF_SCAN_CHANNEL_FOUND_DATA = 0x22
+    HF_SCAN_FREQUENCY_FOUND_DATA = 0x23
+    HF_SCAN_SWEEP_RESTARTED_DATA = 0x24
+    HF_DEMODULATION_SYMBOL_STREAM_DATA = 0x30
+    HF_DECODER_TEXT_DATA = 0x40
+    HF_SPECTRUM_VISUALIZATION_DATA = 0x50
+    HF_TIMEDOMAIN_VISUALIZATION_DATA = 0x51
+    AUDIO_DATA = 0x100
+    EMISSION_LIST_DATA = 0x110
+    LEVEL_DATA = 0x120
+    SYMBOL_DATA = 0x130
+    INSTANTANEOUS_DATA = 0x140
+    BURST_EMMISION_LIST = 0x150
+    IMAGE_DATA = 0x160
+    TRANSMISSION_SYSTEM_RESULT_DATA = 0x170
+    PULSE_DESCRIPTION_WORD_DATA = 0x200
+    PULSE_REPETITION_WORD_DATA = 0x210
+    EM050_SCAN_DATA = 0x4000
+    SCAN_LEVEL = 0x4001
+    SCAN_TUNING = 0x4002
+    SCAN_LEVEL_TUNING = 0x4003
+    DDF_RESERVED_START = 0x5000
+    DDF_RESERVED_END = 0x50FF
+
+
+class AmmosAudioDemodType(int, Enum):
+    """I map numbers to human readable demodulation types."""
+
+    FM = 0
+    AM = 1
+    ISB = 5
+    CW = 6
+    USB = 7
+    LSB = 8
+    DIGITAL = 256
+    UNKNOWN = 0xFFFFFFFF
Index: ammosreader/AmmosExtendedAudioDataHeader.py
===================================================================
--- ammosreader/AmmosExtendedAudioDataHeader.py	(revision 87b2e39cb8bf9d88c411397bf66ed7dcfc06fe70)
+++ ammosreader/AmmosExtendedAudioDataHeader.py	(revision d7ea5259cdee870b9b52a13c04a76ab46fa5825f)
@@ -1,4 +1,5 @@
+"""I provide an Ammos extended data header for audio data frames."""
+
 import struct
-import numpy as np
 from ammosreader.AmmosAudioDataHeader import AmmosAudioDataHeader
 
@@ -6,8 +7,12 @@
 class AmmosExtendedAudioDataHeader():
 
+    HEADER_SIZE = 44  # 11 words
+
     @classmethod
     def from_bytes(cls, bytes):
-        standard_header = AmmosAudioDataHeader.from_bytes(bytes[0:36])
-        extended_header_elements = struct.unpack('Q', bytes[36:])
+        """I return a new AMMOS extended data header for audio frames built from given bytes."""
+        assert len(bytes) == cls.HEADER_SIZE
+        standard_header = AmmosAudioDataHeader.from_bytes(bytes[0:AmmosAudioDataHeader.HEADER_SIZE])
+        extended_header_elements = struct.unpack('Q', bytes[AmmosAudioDataHeader.HEADER_SIZE:])
         timestamp = extended_header_elements[0]
         sample_rate = standard_header.sample_rate
@@ -16,12 +21,13 @@
         demod_bandwidth = standard_header.demod_bandwidth
         demod_type = standard_header.demod_type
-        sample_count = standard_header.sample_count
-        channel_count = standard_header.channel_count
+        number_of_samples = standard_header.number_of_samples
+        number_of_channels = standard_header.number_of_channels
         sample_size = standard_header.sample_size
         return AmmosExtendedAudioDataHeader(sample_rate, status, frequency, demod_bandwidth, demod_type,
-                                            sample_count, channel_count, sample_size, timestamp)
+                                            number_of_samples, number_of_channels, sample_size, timestamp)
 
     def __init__(self, sample_rate, status, frequency, demod_bandwidth, demod_type,
-                 sample_count, channel_count, sample_size, timestamp):
+                 number_of_samples, number_of_channels, sample_size, timestamp):
+        """I return a new AMMOS extended data header for audio frames built from given parameters."""
         self.sample_rate = sample_rate
         self.status = status
@@ -29,6 +35,6 @@
         self.demod_bandwidth = demod_bandwidth
         self.demod_type = demod_type
-        self.sample_count = sample_count
-        self.channel_count = channel_count
+        self.number_of_samples = number_of_samples
+        self.number_of_channels = number_of_channels
         self.sample_size = sample_size
         self.timestamp = timestamp
Index: ammosreader/AmmosExtendedIFDataHeader.py
===================================================================
--- ammosreader/AmmosExtendedIFDataHeader.py	(revision 87b2e39cb8bf9d88c411397bf66ed7dcfc06fe70)
+++ ammosreader/AmmosExtendedIFDataHeader.py	(revision d7ea5259cdee870b9b52a13c04a76ab46fa5825f)
@@ -5,9 +5,13 @@
 
 class AmmosExtendedIFDataHeader():
+    """I implement an Ammos extended data header for IF data frames."""
+
+    HEADER_SIZE = 76
 
     @classmethod
     def from_bytes(cls, bytes):
-        standard_header = AmmosIFDataHeader.from_bytes(bytes[0:56])
-        extended_header_elements = struct.unpack('QQI', bytes[56:76])
+        """I return an AMMOS extended data header from given bytes."""
+        standard_header = AmmosIFDataHeader.from_bytes(bytes[0:AmmosIFDataHeader.HEADER_SIZE])
+        extended_header_elements = struct.unpack('QQI', bytes[AmmosIFDataHeader.HEADER_SIZE:cls.HEADER_SIZE])
         block_count = standard_header.block_count
         block_length = standard_header.block_length
@@ -34,5 +38,5 @@
                  bandwidth, sample_rate, interpolation, decimation, voltage_ref, stream_start, sample_counter,
                  antenna_correction):
-
+        """I create a new instance of myself using the above parameters."""
         self.size = size
         self.block_count = block_count
@@ -64,6 +68,4 @@
             "Stream start:" + str(self.stream_start) + "\n" +
             "Sample counter:" + str(self.sample_counter) + "\n" +
-            "Antenna correction:" + str(self.antenna_correction) + "\n"
-        )
-
+            "Antenna correction:" + str(self.antenna_correction) + "\n")
         return output
Index: ammosreader/AmmosIFDataBlock.py
===================================================================
--- ammosreader/AmmosIFDataBlock.py	(revision 87b2e39cb8bf9d88c411397bf66ed7dcfc06fe70)
+++ ammosreader/AmmosIFDataBlock.py	(revision d7ea5259cdee870b9b52a13c04a76ab46fa5825f)
@@ -1,5 +1,20 @@
+"""I provide an AMMOS data block for IF data frames."""
+
+
 class AmmosIFDataBlock():
+    """I implement an AMMOS data block for IF data frames."""
 
-    def __init__(self, if_datablock_header, if_data):
-        self.if_datablock_header = if_datablock_header
-        self.if_data = if_data
+    def __init__(self, if_datablock_header, if_data_body):
+        """I return a new AMMOS data block for IF data frames."""
+        self.__header = if_datablock_header
+        self.__body = if_data_body
+
+    @property
+    def header(self):
+        """I return my data block header."""
+        return self.__header
+
+    @property
+    def body(self):
+        """I return the raw pcm data with channels interweaved."""
+        return self.__body
Index: ammosreader/AmmosIFDataHeader.py
===================================================================
--- ammosreader/AmmosIFDataHeader.py	(revision 87b2e39cb8bf9d88c411397bf66ed7dcfc06fe70)
+++ ammosreader/AmmosIFDataHeader.py	(revision d7ea5259cdee870b9b52a13c04a76ab46fa5825f)
@@ -1,2 +1,4 @@
+"""I provide a Ammos data header for IF data frames."""
+
 import struct
 import numpy as np
@@ -4,7 +6,12 @@
 
 class AmmosIFDataHeader():
+    """I implement a Ammos data header for IF data frames."""
+
+    HEADER_SIZE = 56
 
     @classmethod
     def from_bytes(cls, bytes):
+        """I return an AMMOS data header from given bytes."""
+        assert len(bytes) == cls.HEADER_SIZE
         elements = struct.unpack('<IIQIIIQIIIIi', bytes)
         block_count = elements[0]
@@ -27,4 +34,5 @@
     def __init__(self, block_count, block_length, timestamp, status, source_id, source_state, frequency,
                  bandwidth, sample_rate, interpolation, decimation, voltage_ref):
+        """I create a new instance of myself using the above parameters."""
         self.block_count = block_count
         self.block_length = block_length
@@ -40,7 +48,4 @@
         self.voltage_ref = voltage_ref
 
-    def header_size(self):
-        return 56
-
     def __str_(self):
         output = ("\nGlobal frame body data header\n" +
Index: mosreader/CAConstants.py
===================================================================
--- ammosreader/CAConstants.py	(revision 87b2e39cb8bf9d88c411397bf66ed7dcfc06fe70)
+++ 	(revision )
@@ -1,43 +1,0 @@
-"""I provide several constants used in R&S software."""
-
-from enum import Enum
-
-
-class FrameType(int, Enum):
-    """I map numbers to human readable format specifiers."""
-
-    TEST_DATA = 0x00
-    IF_DATA_32BIT_REAL_IMAGINARY_FIXEDPOINT = 0x01
-    IF_DATA_16BIT_REAL_IMAGINARY_FIXEDPOINT = 0x02
-    IF_DATA_16BIT_REAL_REAL = 0x03
-    IF_DATA_32BIT_REAL_IMAGINARY_FIXEDPOINT_RESCALED = 0x04
-    IF_DATA_32BIT_REAL_IMAGINARY_FLOATINGPOINT_RESCALED = 0x05
-    SPECTRUM_DATA_8BIT = 0x10
-    SPECTRUM_DATA_16BIT = 0x11
-    SPECTRUM_DATA_32BIT = 0x12
-    SPECTRUM_DATA_32BIT_FLOATINGPOINT = 0x13
-    SEGMENTATION_SPECTRUM_DATA_32BIT_FLOATINGPOINT = 0x14
-    HF_TUNING_INDICATOR_DATA = 0x20
-    HF_SCAN_CHANNEL_FOUND_DATA = 0x22
-    HF_SCAN_FREQUENCY_FOUND_DATA = 0x23
-    HF_SCAN_SWEEP_RESTARTED_DATA = 0x24
-    HF_DEMODULATION_SYMBOL_STREAM_DATA = 0x30
-    HF_DECODER_TEXT_DATA = 0x40
-    HF_SPECTRUM_VISUALIZATION_DATA = 0x50
-    HF_TIMEDOMAIN_VISUALIZATION_DATA = 0x51
-    AUDIO_DATA = 0x100
-    EMISSION_LIST_DATA = 0x110
-    LEVEL_DATA = 0x120
-    SYMBOL_DATA = 0x130
-    INSTANTANEOUS_DATA = 0x140
-    BURST_EMMISION_LIST = 0x150
-    IMAGE_DATA = 0x160
-    TRANSMISSION_SYSTEM_RESULT_DATA = 0x170
-    PULSE_DESCRIPTION_WORD_DATA = 0x200
-    PULSE_REPETITION_WORD_DATA = 0x210
-    EM050_SCAN_DATA = 0x4000
-    SCAN_LEVEL = 0x4001
-    SCAN_TUNING = 0x4002
-    SCAN_LEVEL_TUNING = 0x4003
-    DDF_RESERVED_START = 0x5000
-    DDF_RESERVED_END = 0x50FF