diff --git a/.gitignore b/.gitignore
index d2d6f36..97e7d5a 100644
--- a/.gitignore
+++ b/.gitignore
@@ -33,3 +33,6 @@ nosetests.xml
 .mr.developer.cfg
 .project
 .pydevproject
+
+# Pycharm backup files
+*~
diff --git a/README.md b/README.md
index 16ca26c..71ee8ad 100644
--- a/README.md
+++ b/README.md
@@ -8,7 +8,7 @@ The `pynmea2` homepage is located at <http://github.com/Knio/pynmea2>
 
 ## Compatibility
 
-`pynmea2` is compatable with Python 2.7 and Python 3.4+
+`pynmea2` is compatible with Python 2.7 and Python 3.4+
 
 ![Python version](https://img.shields.io/pypi/pyversions/pynmea2.svg?style=flat)
 [![Build status](https://github.com/Knio/pynmea2/actions/workflows/ci.yml/badge.svg?branch=master)](https://github.com/Knio/pynmea2/actions/workflows/ci.yml?query=branch%3Amaster+)
diff --git a/examples/read_file.py b/examples/read_file.py
index ebd46ea..265ff71 100644
--- a/examples/read_file.py
+++ b/examples/read_file.py
@@ -1,6 +1,6 @@
 import pynmea2
 
-file = open('examples/data.log', encoding='utf-8')
+file = open('data.log', encoding='utf-8') # Replaced example/data.log with data.log
 
 for line in file.readlines():
     try:
diff --git a/pynmea2/nmea.py b/pynmea2/nmea.py
index a7c13d0..e72fbef 100644
--- a/pynmea2/nmea.py
+++ b/pynmea2/nmea.py
@@ -118,6 +118,14 @@ def parse(line, check=False):
             raise ChecksumError(
                 'strict checking requested but checksum missing', data)
 
+
+        # For PQTM messages, extract the manufacturer (always "QTM") and subtype from concatenated type
+        if sentence_type.startswith("PQTM") and len(sentence_type) > 4:
+            manufacturer = "QTM"
+            sentence_type = sentence_type[4:]  # Extract "SAVEPAR" part
+            data.insert(0, sentence_type)  # Add sentence_type to data for class handling
+            manufacturer += sentence_type  # Create full type for lookup
+
         talker_match = NMEASentence.talker_re.match(sentence_type)
         if talker_match:
             talker = talker_match.group('talker')
@@ -242,4 +250,4 @@ def __init__(self, manufacturer, data):
         self.data = list(data)
 
     def identifier(self):
-        return 'P%s' % (self.manufacturer)
+        return 'P%s' % self.manufacturer
\ No newline at end of file
diff --git a/pynmea2/types/__pycache__/talker.cpython-313.pyc.2311789097392 b/pynmea2/types/__pycache__/talker.cpython-313.pyc.2311789097392
new file mode 100644
index 0000000..82f738b
Binary files /dev/null and b/pynmea2/types/__pycache__/talker.cpython-313.pyc.2311789097392 differ
diff --git a/pynmea2/types/__pycache__/talker.cpython-313.pyc.2509003370928 b/pynmea2/types/__pycache__/talker.cpython-313.pyc.2509003370928
new file mode 100644
index 0000000..82f738b
Binary files /dev/null and b/pynmea2/types/__pycache__/talker.cpython-313.pyc.2509003370928 differ
diff --git a/pynmea2/types/__pycache__/talker.cpython-313.pyc.2953379525040 b/pynmea2/types/__pycache__/talker.cpython-313.pyc.2953379525040
new file mode 100644
index 0000000..82f738b
Binary files /dev/null and b/pynmea2/types/__pycache__/talker.cpython-313.pyc.2953379525040 differ
diff --git a/pynmea2/types/proprietary/__init__.py b/pynmea2/types/proprietary/__init__.py
index 83aff16..0bf2c25 100644
--- a/pynmea2/types/proprietary/__init__.py
+++ b/pynmea2/types/proprietary/__init__.py
@@ -10,4 +10,5 @@
 from . import ubx
 from . import vtx
 from . import nor
+from . import qtm
 
diff --git a/pynmea2/types/proprietary/__pycache__/__init__.cpython-313.pyc.2311788933552 b/pynmea2/types/proprietary/__pycache__/__init__.cpython-313.pyc.2311788933552
new file mode 100644
index 0000000..1e39332
Binary files /dev/null and b/pynmea2/types/proprietary/__pycache__/__init__.cpython-313.pyc.2311788933552 differ
diff --git a/pynmea2/types/proprietary/__pycache__/__init__.cpython-313.pyc.2509003206944 b/pynmea2/types/proprietary/__pycache__/__init__.cpython-313.pyc.2509003206944
new file mode 100644
index 0000000..1e39332
Binary files /dev/null and b/pynmea2/types/proprietary/__pycache__/__init__.cpython-313.pyc.2509003206944 differ
diff --git a/pynmea2/types/proprietary/__pycache__/__init__.cpython-313.pyc.2953377817360 b/pynmea2/types/proprietary/__pycache__/__init__.cpython-313.pyc.2953377817360
new file mode 100644
index 0000000..1e39332
Binary files /dev/null and b/pynmea2/types/proprietary/__pycache__/__init__.cpython-313.pyc.2953377817360 differ
diff --git a/pynmea2/types/proprietary/__pycache__/ash.cpython-313.pyc.2953379361200 b/pynmea2/types/proprietary/__pycache__/ash.cpython-313.pyc.2953379361200
new file mode 100644
index 0000000..b3b6564
Binary files /dev/null and b/pynmea2/types/proprietary/__pycache__/ash.cpython-313.pyc.2953379361200 differ
diff --git a/pynmea2/types/proprietary/__pycache__/fec.cpython-313.pyc.2311788929952 b/pynmea2/types/proprietary/__pycache__/fec.cpython-313.pyc.2311788929952
new file mode 100644
index 0000000..44a66db
Binary files /dev/null and b/pynmea2/types/proprietary/__pycache__/fec.cpython-313.pyc.2311788929952 differ
diff --git a/pynmea2/types/proprietary/__pycache__/fec.cpython-313.pyc.2509003206656 b/pynmea2/types/proprietary/__pycache__/fec.cpython-313.pyc.2509003206656
new file mode 100644
index 0000000..44a66db
Binary files /dev/null and b/pynmea2/types/proprietary/__pycache__/fec.cpython-313.pyc.2509003206656 differ
diff --git a/pynmea2/types/proprietary/__pycache__/fec.cpython-313.pyc.2953379357600 b/pynmea2/types/proprietary/__pycache__/fec.cpython-313.pyc.2953379357600
new file mode 100644
index 0000000..44a66db
Binary files /dev/null and b/pynmea2/types/proprietary/__pycache__/fec.cpython-313.pyc.2953379357600 differ
diff --git a/pynmea2/types/proprietary/__pycache__/grm.cpython-313.pyc.2953379357168 b/pynmea2/types/proprietary/__pycache__/grm.cpython-313.pyc.2953379357168
new file mode 100644
index 0000000..6892d0e
Binary files /dev/null and b/pynmea2/types/proprietary/__pycache__/grm.cpython-313.pyc.2953379357168 differ
diff --git a/pynmea2/types/proprietary/__pycache__/kwd.cpython-313.pyc.2311788928944 b/pynmea2/types/proprietary/__pycache__/kwd.cpython-313.pyc.2311788928944
new file mode 100644
index 0000000..1e87881
Binary files /dev/null and b/pynmea2/types/proprietary/__pycache__/kwd.cpython-313.pyc.2311788928944 differ
diff --git a/pynmea2/types/proprietary/__pycache__/kwd.cpython-313.pyc.2509003206224 b/pynmea2/types/proprietary/__pycache__/kwd.cpython-313.pyc.2509003206224
new file mode 100644
index 0000000..1e87881
Binary files /dev/null and b/pynmea2/types/proprietary/__pycache__/kwd.cpython-313.pyc.2509003206224 differ
diff --git a/pynmea2/types/proprietary/__pycache__/kwd.cpython-313.pyc.2953379356592 b/pynmea2/types/proprietary/__pycache__/kwd.cpython-313.pyc.2953379356592
new file mode 100644
index 0000000..1e87881
Binary files /dev/null and b/pynmea2/types/proprietary/__pycache__/kwd.cpython-313.pyc.2953379356592 differ
diff --git a/pynmea2/types/proprietary/__pycache__/mgn.cpython-313.pyc.2953379359040 b/pynmea2/types/proprietary/__pycache__/mgn.cpython-313.pyc.2953379359040
new file mode 100644
index 0000000..fb5f014
Binary files /dev/null and b/pynmea2/types/proprietary/__pycache__/mgn.cpython-313.pyc.2953379359040 differ
diff --git a/pynmea2/types/proprietary/__pycache__/nor.cpython-313.pyc.2311788933264 b/pynmea2/types/proprietary/__pycache__/nor.cpython-313.pyc.2311788933264
new file mode 100644
index 0000000..12d2848
Binary files /dev/null and b/pynmea2/types/proprietary/__pycache__/nor.cpython-313.pyc.2311788933264 differ
diff --git a/pynmea2/types/proprietary/__pycache__/nor.cpython-313.pyc.2509003204640 b/pynmea2/types/proprietary/__pycache__/nor.cpython-313.pyc.2509003204640
new file mode 100644
index 0000000..12d2848
Binary files /dev/null and b/pynmea2/types/proprietary/__pycache__/nor.cpython-313.pyc.2509003204640 differ
diff --git a/pynmea2/types/proprietary/__pycache__/nor.cpython-313.pyc.2953379357168 b/pynmea2/types/proprietary/__pycache__/nor.cpython-313.pyc.2953379357168
new file mode 100644
index 0000000..12d2848
Binary files /dev/null and b/pynmea2/types/proprietary/__pycache__/nor.cpython-313.pyc.2953379357168 differ
diff --git a/pynmea2/types/proprietary/__pycache__/qtm.cpython-313.pyc.2311788926784 b/pynmea2/types/proprietary/__pycache__/qtm.cpython-313.pyc.2311788926784
new file mode 100644
index 0000000..c015c9f
Binary files /dev/null and b/pynmea2/types/proprietary/__pycache__/qtm.cpython-313.pyc.2311788926784 differ
diff --git a/pynmea2/types/proprietary/__pycache__/qtm.cpython-313.pyc.2509003200896 b/pynmea2/types/proprietary/__pycache__/qtm.cpython-313.pyc.2509003200896
new file mode 100644
index 0000000..c015c9f
Binary files /dev/null and b/pynmea2/types/proprietary/__pycache__/qtm.cpython-313.pyc.2509003200896 differ
diff --git a/pynmea2/types/proprietary/__pycache__/qtm.cpython-313.pyc.2953379351408 b/pynmea2/types/proprietary/__pycache__/qtm.cpython-313.pyc.2953379351408
new file mode 100644
index 0000000..c015c9f
Binary files /dev/null and b/pynmea2/types/proprietary/__pycache__/qtm.cpython-313.pyc.2953379351408 differ
diff --git a/pynmea2/types/proprietary/__pycache__/srf.cpython-313.pyc.2953379358896 b/pynmea2/types/proprietary/__pycache__/srf.cpython-313.pyc.2953379358896
new file mode 100644
index 0000000..a7e8f55
Binary files /dev/null and b/pynmea2/types/proprietary/__pycache__/srf.cpython-313.pyc.2953379358896 differ
diff --git a/pynmea2/types/proprietary/__pycache__/sxn.cpython-313.pyc.2311788930528 b/pynmea2/types/proprietary/__pycache__/sxn.cpython-313.pyc.2311788930528
new file mode 100644
index 0000000..b6950b9
Binary files /dev/null and b/pynmea2/types/proprietary/__pycache__/sxn.cpython-313.pyc.2311788930528 differ
diff --git a/pynmea2/types/proprietary/__pycache__/sxn.cpython-313.pyc.2509003204496 b/pynmea2/types/proprietary/__pycache__/sxn.cpython-313.pyc.2509003204496
new file mode 100644
index 0000000..b6950b9
Binary files /dev/null and b/pynmea2/types/proprietary/__pycache__/sxn.cpython-313.pyc.2509003204496 differ
diff --git a/pynmea2/types/proprietary/__pycache__/sxn.cpython-313.pyc.2953379358032 b/pynmea2/types/proprietary/__pycache__/sxn.cpython-313.pyc.2953379358032
new file mode 100644
index 0000000..b6950b9
Binary files /dev/null and b/pynmea2/types/proprietary/__pycache__/sxn.cpython-313.pyc.2953379358032 differ
diff --git a/pynmea2/types/proprietary/__pycache__/tnl.cpython-313.pyc.2953379357456 b/pynmea2/types/proprietary/__pycache__/tnl.cpython-313.pyc.2953379357456
new file mode 100644
index 0000000..4538fe3
Binary files /dev/null and b/pynmea2/types/proprietary/__pycache__/tnl.cpython-313.pyc.2953379357456 differ
diff --git a/pynmea2/types/proprietary/qtm.py b/pynmea2/types/proprietary/qtm.py
new file mode 100644
index 0000000..e943d13
--- /dev/null
+++ b/pynmea2/types/proprietary/qtm.py
@@ -0,0 +1,1618 @@
+from ... import nmea
+
+class QTM(nmea.ProprietarySentence):
+    sentence_types = {}
+
+    def __new__(_cls, manufacturer, data):
+        # Dynamically derive the message class name
+        name = manufacturer + data[0]  # Use first data element as part of the name
+        cls = _cls.sentence_types.get(name, _cls)
+        return super(QTM, cls).__new__(cls)
+
+class QTMVERNO(QTM):
+    """
+    PQTMVERNO Message
+
+    Supports:
+    - $PQTMVERNO,<VerStr>,<BuildDate>,<BuildTime>*<Checksum>
+    """
+    fields = (
+        ('sentence_type', 'sentence_type'),  # VERNO
+        ('version', 'version'),  # Example: LC29HAANR01A04S
+        ('build_date', 'build_date'),  # Format: YYYY/MM/DD
+        ('build_time', 'build_time'),  # Format: HH:MM:SS
+    )
+
+    def __init__(self, manufacturer, data):
+        super(QTMVERNO, self).__init__(manufacturer, data)
+        # print(data)  # Debugging print to confirm input structure
+
+        # Assign attributes using the shared utils for formatting
+        self.sentence_type = data[0]
+        self.version = data[1]
+        self.date = data[2]  # Use the new date parser
+        self.build_time = data[3]  # Use the shared timestamp function
+
+    # def __repr__(self):
+    #     # Improved __repr__ for better readability
+    #     return ("<QTMVERNO(sentence_type={sentence_type}, version='{version}', "
+    #             "build_date={build_date}, build_time={build_time})>").format(
+    #         sentence_type=self.sentence_type,
+    #         version=self.version,
+    #         build_date=self.build_date,
+    #         build_time=self.build_time
+    #     )
+
+class QTMSAVEPAR(QTM):
+    """
+    PQTM SAVEPAR Message
+
+    Supports:
+    - $PQTMSAVEPAR,OK*72
+    """
+    fields = (
+        ('sentence_type', 'sentence_type'),
+        ('status', 'status')
+    )
+
+    def __init__(self, manufacturer, data):
+        super(QTMSAVEPAR, self).__init__(manufacturer, data)
+        self.status = data[1]  # Handle status field
+
+class QTMRESTOREPAR(QTM):
+    """
+    PQTM RESTOREPAR Message
+
+    Supports:
+    - $PQTMRESTOREPAR,OK*3B
+    """
+    fields = (
+        ('sentence_type', 'sentence_type'),
+        ('status', 'status')
+    )
+
+    def __init__(self, manufacturer, data):
+        super(QTMRESTOREPAR, self).__init__(manufacturer, data)
+        self.status = data[1]  # Handle status field
+
+class QTMEPE(QTM):
+    """
+    PQTMEPE Message
+
+    Outputs the estimated positioning error.
+
+    Supports:
+    - $PQTMEPE,<MsgVer>,<EPE_North>,<EPE_East>,<EPE_Down>,<EPE_2D>,<EPE_3D>*<Checksum>
+    """
+
+    fields = (
+        ('sentence_type', 'sentence_type'),  # EPE
+        ('msg_ver', 'msg_ver'),  # Message version (always 2)
+        ('epe_north', 'epe_north'),  # Estimated north error (in meters)
+        ('epe_east', 'epe_east'),  # Estimated east error (in meters)
+        ('epe_down', 'epe_down'),  # Estimated down error (in meters)
+        ('epe_2d', 'epe_2d'),  # Estimated 2D position error (in meters)
+        ('epe_3d', 'epe_3d'),  # Estimated 3D position error (in meters)
+    )
+
+    def __init__(self, manufacturer, data):
+        super(QTMEPE, self).__init__(manufacturer, data)
+        # print(data)  # Debugging print to confirm input structure
+
+        # Set attributes based on input data
+        self.sentence_type = data[0]
+        self.msg_ver = int(data[1])
+        self.epe_north = float(data[2])
+        self.epe_east = float(data[3])
+        self.epe_down = float(data[4])
+        self.epe_2d = float(data[5])
+        self.epe_3d = float(data[6])
+
+class QTMCFGGEOFENCE(QTM):
+    """
+    PQTMCFGGEOFENCE Message
+
+    Supports:
+    - $PQTMCFGGEOFENCE,OK,<Index>,<Status>,<Reserved>,<Shape>,<Lat0>,<Lon0>,<Lat1/Radius>,
+      [<Lon1>,<Lat2>,<Lon2>,<Lat3>,<Lon3>]*<Checksum>
+    """
+
+    fields = (
+        ('sentence_type', 'sentence_type'),  # Always "CFGGEOGENCE"
+        ('Status', 'status'),  # "OK"
+        ('Index', 'index'),  # Geofence index (0-3)
+        ('Enabled', 'enabled'),  # 0 = Disabled, 1 = Enabled
+        ('Reserved', 'reserved'),  # Always 0
+        ('Shape', 'shape'),  # Geofence shape (0-3)
+        ('Lat0', 'lat0'),  # Latitude of the first point
+        ('Lon0', 'lon0'),  # Longitude of the first point
+        ('Lat1_or_Radius', 'lat1_or_radius'),  # Latitude/Radius based on shape
+        ('Lon1', 'lon1'),  # Longitude of the second point (optional)
+        ('Lat2', 'lat2'),  # Latitude of the third point (optional)
+        ('Lon2', 'lon2'),  # Longitude of the third point (optional)
+        ('Lat3', 'lat3'),  # Latitude of the fourth point (optional)
+        ('Lon3', 'lon3')  # Longitude of the fourth point (optional)
+    )
+
+    def __init__(self, manufacturer, data):
+        super(QTMCFGGEOFENCE, self).__init__(manufacturer, data)
+        # print(data)  # Debugging print to confirm input structure
+
+        # Extract and assign the mandatory fields
+        self.sentence_type = data[0]  # Should always be "CFGGEOGENCE"
+        self.status = data[1]  # Should be "OK"
+        self.index = data[2]
+        self.enabled = data[3]  # 0 = Disabled, 1 = Enabled
+        self.reserved = data[4]
+        self.shape = data[5]
+        self.lat0 = data[6]
+        self.lon0 = data[7]
+        self.lat1_or_radius = data[8]
+
+        # Optional fields (only for specific shapes)
+        if len(data) > 9:
+            self.lon1 = data[9]
+        if len(data) > 10:
+            self.lat2 = data[10]
+        if len(data) > 11:
+            self.lon2 = data[11]
+        if len(data) > 12:
+            self.lat3 = data[12]
+        if len(data) > 13:
+            self.lon3 = data[13]
+
+class QTMGEOFENCESTATUS(QTM):
+    """
+    PQTMGEOFENCESTATUS Message
+
+    Supports:
+    - $PQTMGEOFENCESTATUS,<MsgVer>,<Time>,<State0>,<State1>,<State2>,<State3>*<Checksum>
+
+    Geofence State Meaning:
+    - 0 = Unknown (Not defined)
+    - 1 = Inside geofence
+    - 2 = Outside geofence
+    """
+
+    fields = (
+        ('sentence_type', 'sentence_type'),  # Always "GEOFENCESTATUS"
+        ('MsgVer', 'msg_ver'),  # Message version (Always 1)
+        ('Time', 'time'),  # UTC time (hhmmss.sss)
+        ('State0', 'state0'),  # Geofence state 0
+        ('State1', 'state1'),  # Geofence state 1
+        ('State2', 'state2'),  # Geofence state 2
+        ('State3', 'state3')  # Geofence state 3
+    )
+
+    def __init__(self, manufacturer, data):
+        super(QTMGEOFENCESTATUS, self).__init__(manufacturer, data)
+        # print(data)  # Debugging print to confirm input structure
+
+        # Assign the parsed fields
+        self.sentence_type = data[0]  # Should always be "GEOFENCESTATUS"
+        self.msg_ver = data[1]  # Always 1
+        self.time = data[2]  # UTC time in hhmmss.sss format
+
+        # Convert states from raw data to meaningful descriptions
+        self.state0 = self.parse_state(data[3])  # Geofence 0 state
+        self.state1 = self.parse_state(data[4])  # Geofence 1 state
+        self.state2 = self.parse_state(data[5])  # Geofence 2 state
+        self.state3 = self.parse_state(data[6])  # Geofence 3 state
+
+    @staticmethod
+    def parse_state(state_value):
+        """
+        Parse the state field and return the corresponding description.
+        """
+        state_map = {
+            "0": "Unknown",
+            "1": "Inside geofence",
+            "2": "Outside geofence"
+        }
+        return state_map.get(state_value, "Invalid state")  # Handle unexpected values
+
+class QTMJAMMINGSTATUS(QTM):
+    """
+    PQTMJAMMINGSTATUS Message
+
+    Supports:
+    - $PQTJAMMINGSTATUS,<MsgVer>,<Status>*<Checksum>
+
+    Jamming Detection Status Meaning:
+    - 0 = Unknown
+    - 1 = No jamming, healthy status
+    - 2 = Warning status
+    - 3 = Critical status
+    """
+
+    fields = (
+        ('sentence_type', 'sentence_type'),  # Always "JAMMINGSTATUS"
+        ('MsgVer', 'msg_ver'),  # Message version (Always 1)
+        ('Status', 'status')  # Jamming detection status
+    )
+
+    def __init__(self, manufacturer, data):
+        super(QTMJAMMINGSTATUS, self).__init__(manufacturer, data)
+        # print(data)  # Debugging print to confirm input structure
+
+        # Assign the parsed fields
+        self.sentence_type = data[0]  # Should always be "JAMMINGSTATUS"
+        self.msg_ver = data[1]  # Always 1 for this message version
+        self.status = self.parse_status(data[2])  # Jamming detection status
+
+    @staticmethod
+    def parse_status(status_value):
+        """
+        Parse the status field and return the corresponding description.
+        """
+        status_map = {
+            "0": "Unknown",
+            "1": "No jamming, healthy status",
+            "2": "Warning status",
+            "3": "Critical status"
+        }
+        return status_map.get(status_value, "Invalid status")  # Handle unexpected values
+
+class QTMUNIQID(QTM):
+    """
+    PQTMUNIQID Command Response
+
+    Supports:
+    - $PQTMUNIQID,OK,<Length>,<ID>*<Checksum>
+
+    Field Description:
+    - Length: Length of the chip unique ID in bytes
+    - ID: The chip unique ID in hexadecimal format
+    """
+
+    fields = (
+        ('sentence_type', 'sentence_type'),  # Always "UNIQID"
+        ('Response', 'response'),  # Response type, always "OK" for success
+        ('Length', 'length'),  # Length of chip unique ID in bytes
+        ('ID', 'chip_id')  # Chip unique ID in hexadecimal
+    )
+
+    def __init__(self, manufacturer, data):
+        super(QTMUNIQID, self).__init__(manufacturer, data)
+        # Assign the parsed fields
+        self.sentence_type = "UNIQID"
+        self.response = data[1]  # "OK"
+        self.length = data[2]  # Length of chip unique ID
+        self.chip_id = data[3]  # Chip unique ID in hexadecimal
+
+class QTMANTENNASTATUS(QTM):
+    """
+    PQTMTANTENNASTATUS Message
+
+    Supports:
+    - $PQTMTANTENNASTATUS,<MsgVer>,<AntStatus>,<AntPowerInd>,<ModeInd>*<Checksum>
+
+    Field Descriptions:
+    - MsgVer: Message version (Always 3 for this version)
+    - AntStatus: Antenna status
+        - 0 = Unknown
+        - 1 = Normal
+        - 2 = Open-circuit
+        - 3 = Short-circuit
+    - AntPowerInd: Antenna power indicator
+        - 0 = Power-off
+        - 1 = Power-on
+        - 2 = Unknown
+    - ModeInd: Antenna mode indicator
+        - 0 = Unknown
+        - 1 = Automatic mode, using integrated antenna
+        - 2 = Automatic mode, using external antenna
+        - 3 = Manual mode, using integrated antenna
+        - 4 = Manual mode, using external antenna
+    """
+
+    fields = (
+        ('sentence_type', 'sentence_type'),  # Always "ANTENNASTATUS"
+        ('MsgVer', 'msg_ver'),  # Message version, always "3"
+        ('AntStatus', 'ant_status'),  # Antenna status
+        ('AntPowerInd', 'ant_power_ind'),  # Antenna power indicator
+        ('ModeInd', 'mode_ind')  # Antenna mode indicator
+    )
+
+    def __init__(self, manufacturer, data):
+        super(QTMANTENNASTATUS, self).__init__(manufacturer, data)
+        # Assign the parsed fields
+        self.sentence_type = "ANTENNASTATUS"
+        self.msg_ver = data[1]  # Always 3 for this message version
+        self.ant_status = data[2]  # Antenna status
+        self.ant_power_ind = data[3]  # Antenna power indicator
+        self.mode_ind = data[4]  # Antenna mode indicator
+
+class QTMCFGSVIN(QTM):
+    """
+    PQTMCFGSVIN Message
+
+    Note: This command is supported on LC29H (DA, EA) only
+
+    Supports:
+    - $PQTMCFGSVIN,OK,<Mode>,<MinDur>,<3D_AccLimit>,<ECEF_X>,<ECEF_Y>,<ECEF_Z>*<Checksum>
+
+    Parameters:
+    - Mode: Configure the receiver mode (0 = Disable, 1 = Survey-in, 2 = Fixed mode).
+    - MinDur: Minimum survey-in duration (0-86400 seconds).
+    - 3D_AccLimit: Limit 3D position accuracy in meters (0 = No limit).
+    - ECEF_X/Y/Z: WGS84 ECEF X, Y, and Z coordinates in meters.
+    """
+
+    fields = (
+        ('sentence_type', 'sentence_type'),  # CFGSVIN
+        ('status', 'status'),  # OK
+        ('mode', 'mode'),  # Receiver mode (0, 1, 2)
+        ('min_dur', 'min_dur'),  # Survey-in duration (in seconds)
+        ('acc_limit', 'acc_limit'),  # 3D accuracy limit in meters
+        ('ecef_x', 'ecef_x'),  # ECEF X coordinate
+        ('ecef_y', 'ecef_y'),  # ECEF Y coordinate
+        ('ecef_z', 'ecef_z'),  # ECEF Z coordinate
+    )
+
+    def __init__(self, manufacturer, data):
+        super(QTMCFGSVIN, self).__init__(manufacturer, data)
+        # print(data)  # Debugging print to confirm input structure
+
+        # Set attributes based on input data
+        self.sentence_type = data[0]  # Always "CFGSVIN"
+        self.status = data[1]  # Should be "OK"
+        self.mode = data[2]  # Mode (0, 1, or 2)
+        self.min_dur = data[3]  # Survey-in minimum duration
+        self.acc_limit = data[4]  # 3D accuracy limit
+        self.ecef_x = data[5]  # ECEF X coordinate
+        self.ecef_y = data[6]  # ECEF Y coordinate
+        self.ecef_z = data[7]  # ECEF Z coordinate
+
+class QTMSVINSTATUS(QTM):
+    """
+    PQTMSVINSTATUS Message
+
+    Outputs the survey-in status.
+
+    Supports:
+    - $PQTMSVINSTATUS,<MsgVer>,<TOW>,<Valid>,<Res0>,<Res1>,<Obs>,<CfgDur>,<MeanX>,<MeanY>,
+      <MeanZ>,<MeanAcc>*<Checksum>
+
+    Parameters:
+    - MsgVer: Message version (Always 1).
+    - TOW: GPS Time of Week (milliseconds).
+    - Valid: Survey-in position validity flag (0 = Invalid, 1 = In-progress, 2 = Valid).
+    - Res0: Reserved field (Always 0).
+    - Res1: Reserved field (Always 0).
+    - Obs: Number of position observations.
+    - CfgDur: Configured duration from the PQTMCFGSVIN command.
+    - MeanX/Y/Z: Mean position along the X, Y, and Z axes in meters.
+    - MeanAcc: Mean position accuracy in meters.
+    """
+
+    fields = (
+        ('sentence_type', 'sentence_type'),  # Always "SVINSTATUS"
+        ('msg_ver', 'msg_ver'),  # Message version (Always 1)
+        ('tow', 'tow'),  # GPS Time of Week (milliseconds)
+        ('valid', 'valid'),  # Survey-in validity flag (0, 1, 2)
+        ('res0', 'res0'),  # Reserved (Always 0)
+        ('res1', 'res1'),  # Reserved (Always 0)
+        ('obs', 'obs'),  # Number of observations
+        ('cfg_dur', 'cfg_dur'),  # Configured duration
+        ('mean_x', 'mean_x'),  # Mean X position in meters
+        ('mean_y', 'mean_y'),  # Mean Y position in meters
+        ('mean_z', 'mean_z'),  # Mean Z position in meters
+        ('mean_acc', 'mean_acc'),  # Mean position accuracy in meters
+    )
+
+    def __init__(self, manufacturer, data):
+        super(QTMSVINSTATUS, self).__init__(manufacturer, data)
+        # print(data)  # Debugging print to confirm input structure
+
+        # Assign the parsed fields to class attributes
+        self.sentence_type = data[0]
+        self.msg_ver = data[1]
+        self.tow = data[2]
+        self.valid = self.parse_validity(data[3])
+        self.res0 = data[4]
+        self.res1 = data[5]
+        self.obs = data[6]
+        self.cfg_dur = data[7]
+        self.mean_x = data[8]
+        self.mean_y = data[9]
+        self.mean_z = data[10]
+        self.mean_acc = data[11]
+
+    @staticmethod
+    def parse_validity(value):
+        """
+        Parse the validity flag to a meaningful description.
+        """
+        validity_map = {
+            "0": "Invalid",
+            "1": "In-progress",
+            "2": "Valid"
+        }
+        return validity_map.get(value, "Unknown validity")
+
+class QTMGNSSSTART(QTM):
+    """
+    PQTMGNSSSTART Message
+
+    Starts the GNSS engine.
+
+    Supports:
+    - $PQTMGNSSSTART,OK*<Checksum>
+
+    If successful, the response is:
+    - OK
+    """
+
+    fields = (
+        ('sentence_type', 'sentence_type'),  # Always "GNSSSTART"
+        ('status', 'status'),  # Always "OK"
+    )
+
+    def __init__(self, manufacturer, data):
+        super(QTMGNSSSTART, self).__init__(manufacturer, data)
+        # print(data)  # Debugging print to confirm input structure
+
+        # Extract sentence_type and status
+        self.sentence_type = data[0]
+        self.status = data[1]
+
+class QTMGNSSSTOP(QTM):
+    """
+    PQTMGNSSSTOP Message
+
+    Stops the GNSS engine.
+
+    Supports:
+    - $PQTMGNSSSTOP,OK*<Checksum>
+
+    If successful, the response is:
+    - OK
+    """
+
+    fields = (
+        ('sentence_type', 'sentence_type'),  # Always "GNSSSTOP"
+        ('status', 'status'),  # Always "OK"
+    )
+
+    def __init__(self, manufacturer, data):
+        super(QTMGNSSSTOP, self).__init__(manufacturer, data)
+        # print(data)  # Debugging print to confirm input structure
+
+        # Extract sentence_type and status
+        self.sentence_type = data[0]
+        self.status = data[1]
+
+class QTMPVT(QTM):
+    """
+    PQTMPVT Message
+
+    Outputs the PVT (GNSS only) result.
+
+    Supports:
+    - $PQTMPVT,<MsgVer>,<TOW>,<Date>,<Time>,<Res>,<FixMode>,<NumSatUsed>,<LeapS>,
+      <Lat>,<Lon>,<Alt>,<Sep>,<VelN>,<VelE>,<VelD>,<Spd>,<Heading>,<HDOP>,<PDOP>*<Checksum>
+
+    """
+
+    fields = (
+        ('sentence_type', 'sentence_type'),  # PVT
+        ('msg_ver', 'msg_ver'),  # Always 1
+        ('tow', 'tow'),  # Time of week in milliseconds
+        ('date', 'date'),  # UTC Date in YYYYMMDD format
+        ('time', 'time'),  # UTC Time in hhmmss.sss format
+        ('res', 'res'),  # Reserved
+        ('fix_mode', 'fix_mode'),  # 0=No fix, 1=Reserved, 2=2D, 3=3D fix
+        ('num_sat_used', 'num_sat_used'),  # Number of satellites used
+        ('leap_seconds', 'leap_seconds'),  # Leap seconds
+        ('latitude', 'lat'),  # Latitude in degrees
+        ('longitude', 'lon'),  # Longitude in degrees
+        ('altitude', 'alt'),  # Altitude above mean sea-level in meters
+        ('geoid_sep', 'sep'),  # Geoid separation in meters
+        ('vel_n', 'vel_n'),  # North velocity in m/s
+        ('vel_e', 'vel_e'),  # East velocity in m/s
+        ('vel_d', 'vel_d'),  # Down velocity in m/s
+        ('speed', 'spd'),  # Ground speed in m/s
+        ('heading', 'heading'),  # Heading in degrees
+        ('hdop', 'hdop'),  # Horizontal dilution of precision
+        ('pdop', 'pdop')  # Position dilution of precision
+    )
+
+    def __init__(self, manufacturer, data):
+        super(QTMPVT, self).__init__(manufacturer, data)
+        # print(data)  # Debugging print to confirm input structure
+
+        # Assigning the values from the input data
+        self.sentence_type = data[0]
+        self.msg_ver = data[1]
+        self.tow = data[2]
+        self.date = data[3]
+        self.time = data[4]
+        self.res = data[5]
+        self.fix_mode = data[6]
+        self.num_sat_used = data[7]
+        self.leap_seconds = data[8]
+        self.lat = data[9]
+        self.lon = data[10]
+        self.alt = data[11]
+        self.sep = data[12]
+        self.vel_n = data[13]
+        self.vel_e = data[14]
+        self.vel_d = data[15]
+        self.spd = data[16]
+        self.heading = data[17]
+        self.hdop = data[18]
+        self.pdop = data[19]
+
+class QTMCFGNMEADP(QTM):
+    """
+    PQTMCFGNMEADP Message
+
+    Supports:
+    - Set command: $PQTMCFGNMEADP,W,<UTC_DP>,<POS_DP>,<ALT_DP>,<DOP_DP>,<SPD_DP>,<COG_DP>*<Checksum><CR><LF>
+    - Get command: $PQTMCFGNMEADP,OK,<UTC_DP>,<POS_DP>,<ALT_DP>,<DOP_DP>,<SPD_DP>,<COG_DP>*<Checksum><CR><LF>
+    """
+
+    fields = (
+        ('sentence_type', 'sentence_type'),  # Always "CFGNMEADP"
+        ('Status', 'status'),  # "OK"
+        ('UTC_DP', 'utc_dp'),  # Decimal places for UTC seconds in NMEA messages
+        ('POS_DP', 'pos_dp'),  # Decimal places for latitude/longitude in NMEA messages
+        ('ALT_DP', 'alt_dp'),  # Decimal places for altitude in NMEA messages
+        ('DOP_DP', 'dop_dp'),  # Decimal places for DOP in NMEA messages
+        ('SPD_DP', 'spd_dp'),  # Decimal places for speed in NMEA messages
+        ('COG_DP', 'cog_dp')   # Decimal places for COG in NMEA messages
+    )
+
+    def __init__(self, manufacturer, data):
+        super(QTMCFGNMEADP, self).__init__(manufacturer, data)
+        # print(data)  # Debugging print to confirm input structure
+
+        # Assign the parsed fields from the input data
+        self.sentence_type = data[0]  # Should always be "CFGNMEADP"
+        self.status = data[1]  # Should be "OK"
+        self.utc_dp = int(data[2])
+        self.pos_dp = int(data[3])
+        self.alt_dp = int(data[4])
+        self.dop_dp = int(data[5])
+        self.spd_dp = int(data[6])
+        self.cog_dp = int(data[7])
+
+class QTMCFGRCVRMODE(QTM):
+    """
+    PQTMCFGRCVRMODE Message
+
+    Supports:
+    - $PQTMCFGRCVRMODE,OK,<Mode>*<Checksum><CR><LF>
+
+    Receiver Working Modes:
+    - "0" = Unknown
+    - "1" = Rover (Restores to default NMEA output)
+    - "2" = Base Station (Disables NMEA output, enables RTCM MSM4 1005 messages)
+    """
+
+    fields = (
+        ('sentence_type', 'sentence_type'),  # Always "CFGRCVRMODE"
+        ('status', 'status'),  # "OK"
+        ('mode', 'mode'),  # Mode of operation as a string ("0", "1", or "2")
+    )
+
+    def __init__(self, manufacturer, data):
+        super(QTMCFGRCVRMODE, self).__init__(manufacturer, data)
+        # print(data)  # Debugging print to confirm input structure
+
+        # Assign fields for the successful set response
+        self.sentence_type = data[0]  # Should always be "CFGRCVRMODE"
+        self.status = data[1]  # Should be "OK"
+        self.mode = data[2]  # Mode should be parsed as a string
+
+    def get_mode_description(self):
+        """
+        Get the description of the mode from the set response.
+        """
+        mode_map = {
+            "0": "Unknown",
+            "1": "Rover",
+            "2": "Base Station"
+        }
+        # Return description based on the mode value
+        return mode_map.get(self.mode, "Invalid mode")
+
+class QTMPL(QTM):
+    """
+    PQTMPL Message
+
+    Outputs the protection levels (PL) and uncertainty metrics.
+
+    Supports:
+    - $PQTMPL,<MsgVer>,<TOW>,<PUL>,<Res1>,<Res2>,<PL_PosN>,<PL_PosE>,<PL_PosD>,
+      <PL_VelN>,<PL_VelE>,<PL_VelD>,<Res3>,<Res4>,<PL_Time>*<Checksum><CR><LF>
+
+    Field Descriptions:
+    - <MsgVer>: Message version (Always 1).
+    - <TOW>: Time of week (Milliseconds).
+    - <PUL>: Probability of uncertainty level per epoch (%).
+    - <PL_PosN>, <PL_PosE>, <PL_PosD>: Protection levels for North, East, Down (mm).
+    - <PL_VelN>, <PL_VelE>, <PL_VelD>: Protection levels for velocities (mm/s).
+    - <PL_Time>: Protection level of time (ns).
+    - Reserved fields are always null.
+    """
+
+    fields = (
+        ('sentence_type', 'sentence_type'),  # Always "PL"
+        ('msg_ver', 'msg_ver'),  # Message version (Always 1)
+        ('tow', 'tow'),  # Time of week in milliseconds
+        ('pul', 'pul'),  # Probability of uncertainty level (%)
+        ('res1', 'res1'),  # Reserved (Always 1)
+        ('res2', 'res2'),  # Reserved (Always 1)
+        ('pl_posn', 'pl_posn'),  # Protection level (North) in mm
+        ('pl_pose', 'pl_pose'),  # Protection level (East) in mm
+        ('pl_posd', 'pl_posd'),  # Protection level (Down) in mm
+        ('pl_veln', 'pl_veln'),  # Protection level of north velocity (mm/s)
+        ('pl_vele', 'pl_vele'),  # Protection level of east velocity (mm/s)
+        ('pl_veld', 'pl_veld'),  # Protection level of down velocity (mm/s)
+        ('res3', 'res3'),  # Reserved (Always null)
+        ('res4', 'res4'),  # Reserved (Always null)
+        ('pl_time', 'pl_time')  # Protection level of time (ns)
+    )
+
+    def __init__(self, manufacturer, data):
+        super(QTMPL, self).__init__(manufacturer, data)
+        # print(data)  # Debugging print to confirm input structure
+
+        # Assign parsed fields to the instance
+        self.sentence_type = data[0]
+        self.msg_ver = data[1]
+        self.tow = data[2]
+        self.pul = data[3]
+        self.res1 = data[4]
+        self.res2 = data[5]
+        self.pl_posn = data[6]
+        self.pl_pose = data[7]
+        self.pl_posd = data[8]
+        self.pl_veln = data[9]
+        self.pl_vele = data[10]
+        self.pl_veld = data[11]
+        self.res3 = data[12] if len(data) > 12 else None  # Optional reserved field
+        self.res4 = data[13] if len(data) > 13 else None  # Optional reserved field
+        self.pl_time = data[14] if len(data) > 14 else None  # Optional time protection level
+
+class QTMCFGSBAS(QTM):
+    """
+    PQTMCFGSBAS Message
+
+    Supports:
+    - $PQTMCFGSBAS,OK,<Value>*<Checksum><CR><LF>
+
+    SBAS Configuration:
+    - Bit 0 = WAAS
+    - Bit 2 = EGNOS
+    - Bit 4 = MSAS
+    - Bit 5 = GAGAN
+    """
+
+    fields = (
+        ('sentence_type', 'sentence_type'),  # Always "CFGSBAS"
+        ('status', 'status'),  # "OK"
+        ('value', 'value'),  # SBAS configuration value (Hexadecimal)
+    )
+
+    def __init__(self, manufacturer, data):
+        super(QTMCFGSBAS, self).__init__(manufacturer, data)
+        # print(data)  # Debugging print to confirm input structure
+
+        # Assign fields for the successful set response
+        self.sentence_type = data[0]  # Should always be "CFGSBAS"
+        self.status = data[1]  # Should be "OK"
+        self.value = data[2]  # Hexadecimal value representing SBAS configuration
+
+    def get_sbas_description(self):
+        """
+        Get the SBAS configuration description based on the hexadecimal value.
+        """
+        sbas_map = {
+            0: "WAAS",
+            2: "EGNOS",
+            4: "MSAS",
+            5: "GAGAN"
+        }
+        # Convert the hex value to integer and find the bit-enabled services
+        services = [sbas_map[bit] for bit in sbas_map if int(self.value, 16) & (1 << bit)]
+        return services if services else ["No SBAS Service Enabled"]
+
+class QTMCFGCNST(QTM):
+    """
+    PQTMCFGCNST Message
+
+    Supports:
+    - $PQTMCFGCNST,OK,<GPS>,<GLONASS>,<Galileo>,<BDS>,<QZSS>,<Reserved>*<Checksum><CR><LF>
+
+    Constellation Configuration:
+    - <GPS>: 0 = Disable, 1 = Enable
+    - <GLONASS>: 0 = Disable, 1 = Enable
+    - <Galileo>: 0 = Disable, 1 = Enable
+    - <BDS>: 0 = Disable, 1 = Enable
+    - <QZSS>: 0 = Disable, 1 = Enable
+    - <Reserved>: Always 0
+    """
+
+    fields = (
+        ('sentence_type', 'sentence_type'),  # Always "CFGCNST"
+        ('status', 'status'),  # "OK"
+        ('gps', 'gps'),  # GPS Enabled/Disabled
+        ('glonass', 'glonass'),  # GLONASS Enabled/Disabled
+        ('galileo', 'galileo'),  # Galileo Enabled/Disabled
+        ('bds', 'bds'),  # BDS Enabled/Disabled
+        ('qzss', 'qzss'),  # QZSS Enabled/Disabled
+        ('reserved', 'reserved')  # Always 0
+    )
+
+    def __init__(self, manufacturer, data):
+        super(QTMCFGCNST, self).__init__(manufacturer, data)
+        # print(data)  # Debugging print to confirm input structure
+
+        # Assign fields for the successful set response
+        self.sentence_type = data[0]  # Should always be "CFGCNST"
+        self.status = data[1]  # Should be "OK"
+        self.gps = data[2]
+        self.glonass = data[3]
+        self.galileo = data[4]
+        self.bds = data[5]
+        self.qzss = data[6]
+        self.reserved = data[7]
+
+    def get_constellation_status(self):
+        """
+        Get the status of all constellations based on the response.
+        """
+        status_map = {
+            '0': "Disabled",
+            '1': "Enabled"
+        }
+        return {
+            "GPS": status_map.get(self.gps, "Invalid"),
+            "GLONASS": status_map.get(self.glonass, "Invalid"),
+            "Galileo": status_map.get(self.galileo, "Invalid"),
+            "BDS": status_map.get(self.bds, "Invalid"),
+            "QZSS": status_map.get(self.qzss, "Invalid")
+        }
+
+class QTMDOP(QTM):
+    """
+    PQTMDOP Message
+
+    Supports:
+    - $PQTMDOP,<MsgVer>,<TOW>,<GDOP>,<PDOP>,<TDOP>,<VDOP>,<HDOP>,<NDOP>,<EDOP>*<Checksum><CR><LF>
+
+    DOP Values:
+    - GDOP: Geometric Dilution of Precision
+    - PDOP: Position Dilution of Precision (3D)
+    - TDOP: Time Dilution of Precision
+    - VDOP: Vertical Dilution of Precision
+    - HDOP: Horizontal Dilution of Precision
+    - NDOP: Northing Dilution of Precision
+    - EDOP: Easting Dilution of Precision
+
+    Note: If the value is invalid, it will be 99.99
+    """
+
+    fields = (
+        ('sentence_type', 'sentence_type'),  # Always "DOP"
+        ('msg_ver', 'msg_ver'),  # Message version (Always 1)
+        ('tow', 'tow'),  # Time of week (ms)
+        ('gdop', 'gdop'),  # Geometric DOP
+        ('pdop', 'pdop'),  # Position DOP
+        ('tdop', 'tdop'),  # Time DOP
+        ('vdop', 'vdop'),  # Vertical DOP
+        ('hdop', 'hdop'),  # Horizontal DOP
+        ('ndop', 'ndop'),  # Northing DOP
+        ('edop', 'edop'),  # Easting DOP
+    )
+
+    def __init__(self, manufacturer, data):
+        super(QTMDOP, self).__init__(manufacturer, data)
+        # print(data)  # Debugging print to confirm input structure
+
+        # Assign fields from the data
+        self.sentence_type = data[0]  # Always "DOP"
+        self.msg_ver = data[1]  # Always 1
+        self.tow = data[2]  # Time of week in milliseconds
+        self.gdop = data[3]
+        self.pdop = data[4]
+        self.tdop = data[5]
+        self.vdop = data[6]
+        self.hdop = data[7]
+        self.ndop = data[8]
+        self.edop = data[9]
+
+    @staticmethod
+    def get_dop_status(dop_value):
+        """
+        Interpret the DOP value and return 'Valid' or 'Invalid'.
+        """
+        return "Valid" if float(dop_value) < 99.99 else "Invalid"
+
+class QTMCFGFIXRATE(QTM):
+    """
+    PQTMCFGFIXRATE Message
+
+    Supports:
+    - $PQTMCFGFIXRATE,OK*<Checksum><CR><LF> (Successful Set Response)
+
+    Attributes:
+    - sentence_type: CFGFIXRATE (always)
+    - status: OK (indicates a successful set)
+    """
+
+    fields = (
+        ('sentence_type', 'sentence_type'),  # Always "CFGFIXRATE"
+        ('status', 'status')     # Always "OK"
+    )
+
+    def __init__(self, manufacturer, data):
+        super(QTMCFGFIXRATE, self).__init__(manufacturer, data)
+        # print(data)  # Debugging print to confirm input structure
+
+        # Assign the parsed data to attributes
+        self.sentence_type = data[0]  # "CFGFIXRATE"
+        self.status = data[1]   # "OK"
+
+class QTMVEL(QTM):
+    """
+    PQTMVEL Message
+
+    Outputs the velocity information.
+
+    Supports:
+    - $PQTMVEL,<Time>,<VelN>,<VelE>,<VelD>,<GrdSpd>,<Spd>,<Heading>,<GrdSpdAcc>,<SpdAcc>,<HeadingAcc>*<Checksum><CR><LF>
+
+    Attributes:
+    - time: UTC time (hhmmss.sss)
+    - vel_n: North velocity in m/s
+    - vel_e: East velocity in m/s
+    - vel_d: Down velocity in m/s
+    - grd_spd: 2D speed in m/s
+    - spd: 3D speed in m/s
+    - heading: Heading in degrees (0.00 - 360.00)
+    - grd_spd_acc: Estimate of 2D speed accuracy in m/s
+    - spd_acc: Estimate of 3D speed accuracy in m/s
+    - heading_acc: Estimate of heading accuracy in degrees
+    """
+
+    fields = (
+        ('sentence_type', 'sentence_type'),  # Always "VEL"
+        ('msg_ver', 'msg_ver'),  # Message version (Always 1)
+        ('time', 'time'),  # UTC time (hhmmss.sss)
+        ('vel_n', 'vel_n'),  # North velocity (m/s)
+        ('vel_e', 'vel_e'),  # East velocity (m/s)
+        ('vel_d', 'vel_d'),  # Down velocity (m/s)
+        ('grd_spd', 'grd_spd'),  # 2D speed (m/s)
+        ('spd', 'spd'),  # 3D speed (m/s)
+        ('heading', 'heading'),  # Heading (degrees)
+        ('grd_spd_acc', 'grd_spd_acc'),  # 2D speed accuracy (m/s)
+        ('spd_acc', 'spd_acc'),  # 3D speed accuracy (m/s)
+        ('heading_acc', 'heading_acc')  # Heading accuracy (degrees)
+    )
+
+    def __init__(self, manufacturer, data):
+        super(QTMVEL, self).__init__(manufacturer, data)
+        # print(data)  # Debugging print to confirm input structure
+
+        # Assign parsed values to attributes
+        self.sentence_type = data[0]
+        self.version = data[1]
+        self.time = data[2]
+        self.vel_n = float(data[3])
+        self.vel_e = float(data[4])
+        self.vel_d = float(data[5])
+        self.grd_spd = float(data[6])
+        self.spd = float(data[7])
+        self.heading = float(data[8])
+        self.grd_spd_acc = float(data[9])
+        self.spd_acc = float(data[10])
+        self.heading_acc = float(data[11])
+
+class QTMCFGODO(QTM):
+    """
+    PQTMCFGODO Message
+
+    Supports:
+    - $PQTMCFGODO,OK,<State>,<InitDist>*<Checksum><CR><LF>
+
+    Odometer Feature Configuration:
+    - State: 0 = Disabled, 1 = Enabled
+    - InitDist: Initial distance (meters), default value is 0.
+    """
+
+    fields = (
+        ('sentence_type', 'sentence_type'),  # Always "CFGODO"
+        ('status', 'status'),  # "OK"
+        ('state', 'state'),  # 0 = Disabled, 1 = Enabled
+        ('init_dist', 'init_dist')  # Initial distance in meters
+    )
+
+    def __init__(self, manufacturer, data):
+        super(QTMCFGODO, self).__init__(manufacturer, data)
+        # print(data)  # Debugging print to confirm input structure
+
+        # Assign fields for the successful set response
+        self.sentence_type = data[0]  # Should always be "CFGODO"
+        self.status = data[1]  # Should be "OK"
+        self.state = data[2]  # Odometer state: 0 = Disabled, 1 = Enabled
+        self.init_dist = data[3]  # Initial distance in meters
+
+    def get_state_description(self):
+        """
+        Get the description of the odometer state.
+        """
+        state_map = {
+            "0": "Disabled",
+            "1": "Enabled"
+        }
+        return state_map.get(self.state, "Unknown state")
+
+class QTMODO(QTM):
+    """
+    PQTMODO Message
+
+    Outputs the odometer information.
+
+    Supports:
+    - $PQTMODO,<MsgVer>,<Time>,<State>,<Dist>*<Checksum><CR><LF>
+
+    Fields:
+    - MsgVer: Message version (Always 1).
+    - Time: UTC time (hhmmss.sss).
+    - State: Odometer status (0 = Disabled, 1 = Enabled).
+    - Dist: Distance since last reset (meters).
+    """
+
+    fields = (
+        ('sentence_type', 'sentence_type'),  # Always "MODO"
+        ('msg_ver', 'msg_ver'),  # Message version (1)
+        ('time', 'time'),  # UTC time (hhmmss.sss)
+        ('state', 'state'),  # Odometer state: 0 = Disabled, 1 = Enabled
+        ('dist', 'dist')  # Distance since last reset (meters)
+    )
+
+    def __init__(self, manufacturer, data):
+        super(QTMODO, self).__init__(manufacturer, data)
+        # print(data)  # Debugging print to confirm input structure
+
+        # Assign the parsed fields
+        self.sentence_type = data[0]  # Should always be "MODO"
+        self.msg_ver = data[1]  # Always 1
+        self.time = data[2]  # UTC time in hhmmss.sss format
+        self.state = data[3]  # Odometer state
+        self.dist = data[4]  # Distance since last reset in meters
+
+    def get_state_description(self):
+        """
+        Get the description of the odometer state.
+        """
+        state_map = {
+            "0": "Disabled",
+            "1": "Enabled"
+        }
+        return state_map.get(self.state, "Unknown state")
+
+class QTMLS(QTM):
+    """
+    PQTMLS Message
+
+    Supports:
+    - $PQTMLS,<MsgVer>,<TOW>,<LS_Ref>,<WN>,<LS>,<Flag>,<LSF_Ref>,<Reserved>,<WNLSF>,<DN>,<LSF>*<Checksum>
+
+    Field Descriptions:
+    - MsgVer: Message version (Always 1)
+    - TOW: Time of week in seconds
+    - LS_Ref: Referenced constellation for current leap second information
+    - WN: UTC reference week number
+    - LS: Current number of leap seconds since January 6, 1980
+    - Flag: Marker for future occurrences of leap seconds
+    - LSF_Ref: Constellation for the leap second forecast
+    - Reserved: Always null
+    - WNLSF: Week number of the new leap second
+    - DN: Day of the week when the leap second takes effect
+    - LSF: Leap second count after future changes
+    """
+
+    fields = (
+        ('sentence_type', 'sentence_type'),  # Always "MLS"
+        ('MsgVer', 'msg_ver'),  # Message version
+        ('TOW', 'tow'),  # Time of week
+        ('LS_Ref', 'ls_ref'),  # Leap second reference
+        ('WN', 'wn'),  # UTC reference week number
+        ('LS', 'ls'),  # Current number of leap seconds
+        ('Flag', 'flag'),  # Leap second availability flag
+        ('LSF_Ref', 'lsf_ref'),  # Leap second forecast reference
+        ('Reserved', 'reserved'),  # Reserved field
+        ('WNLSF', 'wnlsf'),  # Week number of the new leap second
+        ('DN', 'dn'),  # Day of the week for the new leap second
+        ('LSF', 'lsf')  # Leap second count after future changes
+    )
+
+    def __init__(self, manufacturer, data):
+        super(QTMLS, self).__init__(manufacturer, data)
+        # Assign the parsed fields
+        self.sentence_type = "MLS"
+        self.msg_ver = data[1]  # Message version
+        self.tow = data[2]  # Time of week
+        self.ls_ref = self.parse_constellation(data[3])  # Leap second reference constellation
+        self.wn = data[4]  # UTC reference week number
+        self.ls = data[5]  # Current number of leap seconds
+        self.flag = "Available" if data[6] == "1" else "Invalid"  # Leap second flag
+        self.lsf_ref = self.parse_constellation(data[7])  # Leap second forecast reference
+        self.reserved = data[8]  # Reserved field (null)
+        self.wnlsf = data[9]  # Week number of the new leap second
+        self.dn = data[10]  # Day of the week for the new leap second
+        self.lsf = data[11]  # Leap second count after future changes
+
+    @staticmethod
+    def parse_constellation(value):
+        """
+        Parse the constellation reference and return the corresponding description.
+        """
+        constellation_map = {
+            "0": "No source",
+            "1": "GPS",
+            "2": "Reserved",
+            "3": "Galileo",
+            "4": "BDS"
+        }
+        return constellation_map.get(value, "Unknown")
+
+class QTMDRCAL(QTM):
+    """
+    PQTMDRCAL Message
+
+    Supports:
+    - $PQTMDRCAL,<MsgVer>,<CalState>,<NavType>*<Checksum>
+
+    Field Descriptions:
+    - MsgVer: Message version (Always 1)
+    - CalState: DR calibration state
+        - 0 = Not calibrated
+        - 1 = DR is lightly calibrated
+        - 2 = DR is fully calibrated
+        - 3 = DR is fully calibrated with high-precision heading
+    - NavType: Navigation type
+        - 0 = No position
+        - 1 = GNSS only
+        - 2 = DR only
+        - 3 = Combination (GNSS + DR)
+    """
+
+    fields = (
+        ('sentence_type', 'sentence_type'),  # Always "DRCAL"
+        ('MsgVer', 'msg_ver'),  # Message version
+        ('CalState', 'cal_state'),  # DR calibration state
+        ('NavType', 'nav_type')  # Navigation type
+    )
+
+    def __init__(self, manufacturer, data):
+        super(QTMDRCAL, self).__init__(manufacturer, data)
+        # Assign the parsed fields
+        self.sentence_type = "DRCAL"
+        self.msg_ver = data[1]  # Message version
+        self.cal_state = self.parse_cal_state(data[2])  # DR calibration state
+        self.nav_type = self.parse_nav_type(data[3])  # Navigation type
+
+    @staticmethod
+    def parse_cal_state(value):
+        """
+        Parse the calibration state and return the corresponding description.
+        """
+        cal_state_map = {
+            "0": "Not calibrated",
+            "1": "DR is lightly calibrated",
+            "2": "DR is fully calibrated",
+            "3": "DR is fully calibrated with high-precision heading"
+        }
+        return cal_state_map.get(value, "Unknown")
+
+    @staticmethod
+    def parse_nav_type(value):
+        """
+        Parse the navigation type and return the corresponding description.
+        """
+        nav_type_map = {
+            "0": "No position",
+            "1": "GNSS only",
+            "2": "DR only",
+            "3": "Combination (GNSS + DR)"
+        }
+        return nav_type_map.get(value, "Unknown")
+
+class QTMIMUTYPE(QTM):
+    """
+    PQTMIMUTYPE Message
+
+    Supports:
+    - $PQTMIMUTYPE,<MsgVer>,<Status>*<Checksum>
+
+    Field Descriptions:
+    - MsgVer: Message version (Always 1)
+    - Status: IMU initialization status
+        - 0 = IMU initialization failed
+        - Others = IMU initialization successful
+    """
+
+    fields = (
+        ('sentence_type', 'sentence_type'),  # Always "IMUTYPE"
+        ('MsgVer', 'msg_ver'),  # Message version
+        ('Status', 'status')  # IMU initialization status
+    )
+
+    def __init__(self, manufacturer, data):
+        super(QTMIMUTYPE, self).__init__(manufacturer, data)
+        # Assign the parsed fields
+        self.sentence_type = "IMUTYPE"
+        self.msg_ver = data[1]  # Message version
+        self.status = self.parse_status(data[2])  # IMU initialization status
+
+    @staticmethod
+    def parse_status(value):
+        """
+        Parse the IMU initialization status and return the corresponding description.
+        """
+        return "IMU initialization failed" if value == "0" else "IMU initialization successful"
+
+class QTMVEHMSG(QTM):
+    """
+    PQTMVEHMSG Message
+
+    Supports:
+    - $PQTMVEHMSG,<MsgVer>,<Timestamp>,<Param1>,<Param2>,...,<ParamN>*<Checksum>
+
+    Field Descriptions:
+    - MsgVer: Message version indicating the type of vehicle information
+        - 1: Vehicle speed (in m/s)
+        - 2: Cumulative wheel ticks
+        - 3: Speeds of four wheels (in m/s)
+        - 4: Cumulative wheel ticks of four wheels
+    - Timestamp: Time since power-on in milliseconds
+    - Parameters: Vary depending on MsgVer
+    """
+
+    fields = (
+        ('sentence_type', 'sentence_type'),  # Always "VEHMSG"
+        ('MsgVer', 'msg_ver'),  # Message version
+        ('Timestamp', 'timestamp')  # Timestamp since power-on
+    )
+
+    def __init__(self, manufacturer, data):
+        super(QTMVEHMSG, self).__init__(manufacturer, data)
+        self.sentence_type = "VEHMSG"
+        self.msg_ver = data[1]  # Message version
+        self.timestamp = data[2]  # Timestamp in milliseconds
+
+        # Parse parameters based on MsgVer
+        self.parameters = self.parse_parameters(data[3:], self.msg_ver)
+
+    def parse_parameters(self, params, msg_ver):
+        """
+        Parse parameters based on MsgVer.
+        """
+        if msg_ver == "1":
+            return {"VehSpeed": float(params[0])}  # Speed in m/s
+        elif msg_ver == "2":
+            return {
+                "WheelTickCNT": int(params[0]),  # Cumulative wheel ticks
+                "FWD_Ind": self.parse_fwd_ind(int(params[1]))  # Forward/backward indicator
+            }
+        elif msg_ver == "3":
+            return {
+                "LF_Spd": float(params[0]),  # Left front wheel speed
+                "RF_Spd": float(params[1]),  # Right front wheel speed
+                "LR_Spd": float(params[2]),  # Left rear wheel speed
+                "RR_Spd": float(params[3])   # Right rear wheel speed
+            }
+        elif msg_ver == "4":
+            return {
+                "LF_TickCNT": int(params[0]),  # Left front wheel tick count
+                "RF_TickCNT": int(params[1]),  # Right front wheel tick count
+                "LR_TickCNT": int(params[2]),  # Left rear wheel tick count
+                "RR_TickCNT": int(params[3]),  # Right rear wheel tick count
+                "FWD_Ind": self.parse_fwd_ind(int(params[4]))  # Forward/backward indicator
+            }
+        else:
+            return {}
+
+    @staticmethod
+    def parse_fwd_ind(value):
+        """
+        Parse the forward/backward indicator.
+        """
+        fwd_ind_map = {
+            0: "Invalid state",
+            1: "Forward",
+            2: "Backward"
+        }
+        return fwd_ind_map.get(value, "Unknown")
+
+class QTMINS(QTM):
+    """
+    PQTMINS Message
+
+    Supports:
+    - $PQTMINS,<Timestamp>,<SolType>,<Lat>,<Lon>,<Height>,<VEL_N>,<VEL_E>,<VEL_D>,<Roll>,<Pitch>,<Yaw>*<Checksum>
+
+    Field Descriptions:
+    - Timestamp: Time since power-on in milliseconds
+    - SolType: Solution type
+        - 0 = DR not ready. Roll and pitch ready.
+        - 1 = DR not ready. GNSS, roll, pitch, and relative heading ready.
+        - 2 = GNSS + DR mode. DR calibrated.
+        - 3 = DR only mode.
+    - Lat: Latitude in degrees
+    - Lon: Longitude in degrees
+    - Height: Height in meters
+    - VEL_N: Northward velocity in m/s
+    - VEL_E: Eastward velocity in m/s
+    - VEL_D: Downward velocity in m/s
+    - Roll: Roll angle in degrees, range: -180.0 to 180.0
+    - Pitch: Pitch angle in degrees, range: -90.0 to 90.0
+    - Yaw: Heading angle in degrees, range: 0.0 to 360.0
+    """
+
+    fields = (
+        ('sentence_type', 'sentence_type'),  # Always "INS"
+        ('Timestamp', 'timestamp'),  # Time since power-on
+        ('SolType', 'sol_type'),  # Solution type
+        ('Lat', 'latitude'),  # Latitude
+        ('Lon', 'longitude'),  # Longitude
+        ('Height', 'height'),  # Height in meters
+        ('VEL_N', 'vel_n'),  # Northward velocity
+        ('VEL_E', 'vel_e'),  # Eastward velocity
+        ('VEL_D', 'vel_d'),  # Downward velocity
+        ('Roll', 'roll'),  # Roll angle
+        ('Pitch', 'pitch'),  # Pitch angle
+        ('Yaw', 'yaw')  # Heading angle
+    )
+
+    def __init__(self, manufacturer, data):
+        super(QTMINS, self).__init__(manufacturer, data)
+        # Assign the parsed fields
+        self.sentence_type = "INS"
+        self.timestamp = int(data[1])  # Timestamp in milliseconds
+        self.sol_type = self.parse_solution_type(int(data[2]))  # Solution type
+        self.latitude = float(data[3])  # Latitude
+        self.longitude = float(data[4])  # Longitude
+        self.height = float(data[5])  # Height in meters
+        self.vel_n = float(data[6])  # Northward velocity
+        self.vel_e = float(data[7])  # Eastward velocity
+        self.vel_d = float(data[8])  # Downward velocity
+        self.roll = float(data[9])  # Roll angle
+        self.pitch = float(data[10])  # Pitch angle
+        self.yaw = float(data[11])  # Heading angle
+
+    @staticmethod
+    def parse_solution_type(value):
+        """
+        Parse the solution type and return the corresponding description.
+        """
+        solution_type_map = {
+            0: "DR not ready. Roll and pitch ready.",
+            1: "DR not ready. GNSS, roll, pitch, and relative heading ready.",
+            2: "GNSS + DR mode. DR calibrated.",
+            3: "DR only mode."
+        }
+        return solution_type_map.get(value, "Unknown")
+
+class QTMGPS(QTM):
+    """
+    PQTMGPS Message
+
+    Supports:
+    - $PQTMGPS,<Timestamp>,<TOW>,<Lat>,<Lon>,<Altitude>,<Speed>,<Heading>,<Accuracy>,<HDOP>,<PDOP>,<NumSatUsed>,<FixMode>*<Checksum>
+
+    Field Descriptions:
+    - Timestamp: Time since power-on in milliseconds (string)
+    - TOW: Time of week in seconds (string)
+    - Lat: Latitude in degrees (string)
+    - Lon: Longitude in degrees (string)
+    - Altitude: Altitude in meters (string)
+    - Speed: Ground speed in m/s (string)
+    - Heading: Heading of vehicle in degrees (string)
+    - Accuracy: Horizontal accuracy estimate in meters (string)
+    - HDOP: Horizontal dilution of precision (string)
+    - PDOP: Position dilution of precision (string)
+    - NumSatUsed: Number of satellites used in navigation (string)
+    - FixMode: Fix mode (string)
+    """
+
+    fields = (
+        ('sentence_type', 'sentence_type'),  # Always "GPS"
+        ('Timestamp', 'timestamp'),  # Time since power-on
+        ('TOW', 'tow'),  # Time of week
+        ('Lat', 'latitude'),  # Latitude
+        ('Lon', 'longitude'),  # Longitude
+        ('Altitude', 'altitude'),  # Altitude in meters
+        ('Speed', 'speed'),  # Ground speed in m/s
+        ('Heading', 'heading'),  # Heading in degrees
+        ('Accuracy', 'accuracy'),  # Horizontal accuracy in meters
+        ('HDOP', 'hdop'),  # Horizontal dilution of precision
+        ('PDOP', 'pdop'),  # Position dilution of precision
+        ('NumSatUsed', 'num_sat_used'),  # Number of satellites used
+        ('FixMode', 'fix_mode')  # Fix mode
+    )
+
+    def __init__(self, manufacturer, data):
+        super(QTMGPS, self).__init__(manufacturer, data)
+        # Assign the parsed fields, keeping them as strings
+        self.sentence_type = "GPS"
+        self.timestamp = data[1]  # Timestamp as string
+        self.tow = data[2]  # Time of week as string
+        self.latitude = data[3]  # Latitude as string
+        self.longitude = data[4]  # Longitude as string
+        self.altitude = data[5]  # Altitude as string
+        self.speed = data[6]  # Speed as string
+        self.heading = data[7]  # Heading as string
+        self.accuracy = data[8]  # Accuracy as string
+        self.hdop = data[9]  # HDOP as string
+        self.pdop = data[10]  # PDOP as string
+        self.num_sat_used = data[11]  # NumSatUsed as string
+        self.fix_mode = self.parse_fix_mode(data[12])  # FixMode as string
+
+    @staticmethod
+    def parse_fix_mode(value):
+        """
+        Parse the fix mode and return the corresponding description.
+        """
+        fix_mode_map = {
+            "0": "No fix",
+            "2": "2D fix",
+            "3": "3D fix (including RTK float or RTK fixed)"
+        }
+        return fix_mode_map.get(value, "Unknown")
+
+class QTMVEHMOT(QTM):
+    """
+    PQTMVEHMOT Message
+
+    Supports:
+    - Version 1: $PQTMVEHMOT,1,<PeakAcceleration>,<PeakAngularRate>*<Checksum>
+    - Version 2: $PQTMVEHMOT,2,<UTC>,<VehType>,<MotState>,<AccStatus>,<TurningStatus>,<Res0>,<Res1>,<Res2>,<Res3>,<Res4>*<Checksum>
+
+    Field Descriptions:
+    - MsgVer: Message version (1 or 2)
+    - Version 1:
+        - PeakAcceleration: Peak acceleration of the vehicle (string)
+        - PeakAngularRate: Peak angular rate of the vehicle (string)
+    - Version 2:
+        - UTC: UTC time in hhmmss.sss format (string)
+        - VehType: Vehicle type (1 to 4, string)
+        - MotState: Motion state of the vehicle (string)
+        - AccStatus: Vehicle acceleration status (string)
+        - TurningStatus: Vehicle turning status (string)
+        - Res0 to Res4: Reserved fields, always null (string)
+    """
+
+    fields = (
+        ('sentence_type', 'sentence_type'),  # Always "VEHMOT"
+        ('MsgVer', 'msg_ver'),  # Message version
+    )
+
+    def __init__(self, manufacturer, data):
+        super(QTMVEHMOT, self).__init__(manufacturer, data)
+        self.sentence_type = "VEHMOT"
+        self.msg_ver = data[1]  # Message version
+
+        if self.msg_ver == "1":
+            # Version 1: Peak Acceleration and Angular Rate
+            self.peak_acceleration = data[2]  # Peak acceleration as string
+            self.peak_angular_rate = data[3]  # Peak angular rate as string
+        elif self.msg_ver == "2":
+            # Version 2: Detailed Vehicle Motion Information
+            self.utc = data[2]  # UTC time as string
+            self.veh_type = data[3]  # Vehicle type as string
+            self.mot_state = data[4]  # Motion state as string
+            self.acc_status = data[5]  # Acceleration status as string
+            self.turning_status = data[6]  # Turning status as string
+            self.reserved = data[7:12]  # Reserved fields as list of strings
+
+    def parse_veh_type(self):
+        """
+        Parse the vehicle type and return the description.
+        """
+        veh_type_map = {
+            "1": "General-purpose vehicle",
+            "2": "Small vehicle",
+            "3": "Medium vehicle",
+            "4": "Large vehicle"
+        }
+        return veh_type_map.get(self.veh_type, "Unknown")
+
+    def parse_mot_state(self):
+        """
+        Parse the motion state and return the description.
+        """
+        mot_state_map = {
+            "1": "Stopped",
+            "2": "Moving"
+        }
+        return mot_state_map.get(self.mot_state, "Unknown")
+
+    def parse_acc_status(self):
+        """
+        Parse the acceleration status and return the description.
+        """
+        acc_status_map = {
+            "1": "None (No acceleration detected)",
+            "2": "Normal acceleration",
+            "3": "Rapid acceleration",
+            "4": "Normal deceleration",
+            "5": "Rapid deceleration"
+        }
+        return acc_status_map.get(self.acc_status, "Unknown")
+
+    def parse_turning_status(self):
+        """
+        Parse the turning status and return the description.
+        """
+        turning_status_map = {
+            "1": "None (No turning motion detected)",
+            "2": "Normal turn left",
+            "3": "Sharp turn left",
+            "4": "Normal turn right",
+            "5": "Sharp turn right"
+        }
+        return turning_status_map.get(self.turning_status, "Unknown")
+
+class QTMSENMSG(QTM):
+    """
+    PQTMSENMSG Message
+
+    Supports:
+    - MsgVer = 2: $PQTMSENMSG,2,<TimeStamp>,<IMU_Temp>,<IMU_GYRO_X>,<IMU_GYRO_Y>,<IMU_GYRO_Z>,<IMU_ACC_X>,<IMU_ACC_Y>,<IMU_ACC_Z>*<Checksum>
+    - MsgVer = 4: $PQTMSENMSG,4,<TimeStamp>,<IMU_Temp>,<IMU_GYRO_X>,<IMU_GYRO_Y>,<IMU_GYRO_Z>,<IMU_ACC_X>,<IMU_ACC_Y>,<IMU_ACC_Z>*<Checksum>
+
+    Field Descriptions:
+    - MsgVer: Message version (2 or 4)
+    - TimeStamp: Time since power-on in milliseconds (string)
+    - IMU_Temp: IMU temperature in Celsius (string)
+    - IMU_GYRO_X/Y/Z: IMU gyroscope values for X, Y, Z axes in degrees per second (string)
+    - IMU_ACC_X/Y/Z: IMU accelerometer values for X, Y, Z axes in g (string)
+    """
+
+    fields = (
+        ('sentence_type', 'sentence_type'),  # Always "SENMSG"
+        ('MsgVer', 'msg_ver'),  # Message version
+    )
+
+    def __init__(self, manufacturer, data):
+        super(QTMSENMSG, self).__init__(manufacturer, data)
+        self.sentence_type = "SENMSG"
+        self.msg_ver = data[1]  # Message version
+
+        if self.msg_ver in ["2", "4"]:
+            # Common fields for both MsgVer = 2 and 4
+            self.timestamp = data[2]  # Time since power-on as string
+            self.imu_temp = data[3]  # IMU temperature as string
+            self.imu_gyro_x = data[4]  # IMU gyroscope X-axis as string
+            self.imu_gyro_y = data[5]  # IMU gyroscope Y-axis as string
+            self.imu_gyro_z = data[6]  # IMU gyroscope Z-axis as string
+            self.imu_acc_x = data[7]  # IMU accelerometer X-axis as string
+            self.imu_acc_y = data[8]  # IMU accelerometer Y-axis as string
+            self.imu_acc_z = data[9]  # IMU accelerometer Z-axis as string
+        else:
+            raise ValueError("Unsupported MsgVer: Only 2 and 4 are supported.")
+
+class QTMDRPVA(QTM):
+    """
+    PQTMDRPVA Message
+
+    Supports:
+    - $PQTMDRPVA,<MsgVer>,<Timestamp>,<Time>,<SolType>,<Lat>,<Lon>,<Alt>,<Sep>,<VelN>,<VelE>,<VelD>,<Spd>,<Roll>,<Pitch>,<Heading>*<Checksum>
+
+    Field Descriptions:
+    - MsgVer: Message version (Always 1 for this version)
+    - Timestamp: Milliseconds since module turn-on (string)
+    - Time: UTC time in hhmmss.sss format (string)
+    - SolType: Solution type (0 = No fix, 1 = GNSS only, 2 = Combination (GNSS + DR), 3 = DR only) (string)
+    - Lat: Latitude in degrees (string)
+    - Lon: Longitude in degrees (string)
+    - Alt: Altitude in meters (string)
+    - Sep: Geoidal separation in meters (string)
+    - VelN: North velocity in m/s (string)
+    - VelE: East velocity in m/s (string)
+    - VelD: Down velocity in m/s (string)
+    - Spd: Ground speed in m/s (string)
+    - Roll: Roll angle in degrees, range: -180.000000 to 180.000000 (string)
+    - Pitch: Pitch angle in degrees, range: -90.000000 to 90.000000 (string)
+    - Heading: Heading in degrees, range: 0.000000 to 360.000000 (string)
+    """
+
+    fields = (
+        ('sentence_type', 'sentence_type'),  # Always "DRPVA"
+        ('MsgVer', 'msg_ver'),  # Message version
+        ('Timestamp', 'timestamp'),  # Milliseconds since turn-on
+        ('Time', 'time'),  # UTC time
+        ('SolType', 'sol_type'),  # Solution type
+        ('Lat', 'latitude'),  # Latitude
+        ('Lon', 'longitude'),  # Longitude
+        ('Alt', 'altitude'),  # Altitude
+        ('Sep', 'sep'),  # Geoidal separation
+        ('VelN', 'vel_n'),  # North velocity
+        ('VelE', 'vel_e'),  # East velocity
+        ('VelD', 'vel_d'),  # Down velocity
+        ('Spd', 'speed'),  # Ground speed
+        ('Roll', 'roll'),  # Roll angle
+        ('Pitch', 'pitch'),  # Pitch angle
+        ('Heading', 'heading')  # Heading
+    )
+
+    def __init__(self, manufacturer, data):
+        super(QTMDRPVA, self).__init__(manufacturer, data)
+        self.sentence_type = "DRPVA"
+        self.msg_ver = data[1]  # Message version as string
+        self.timestamp = data[2]  # Timestamp as string
+        self.time = data[3]  # UTC time as string
+        self.sol_type = self.parse_solution_type(data[4])  # Parse Solution type
+        self.latitude = data[5]  # Latitude as string
+        self.longitude = data[6]  # Longitude as string
+        self.altitude = data[7]  # Altitude as string
+        self.sep = data[8]  # Geoidal separation as string
+        self.vel_n = data[9]  # North velocity as string
+        self.vel_e = data[10]  # East velocity as string
+        self.vel_d = data[11]  # Down velocity as string
+        self.speed = data[12]  # Ground speed as string
+        self.roll = data[13]  # Roll angle as string
+        self.pitch = data[14]  # Pitch angle as string
+        self.heading = data[15]  # Heading as string
+
+    @staticmethod
+    def parse_solution_type(value):
+        """
+        Parse the solution type and return the corresponding description.
+        """
+        sol_type_map = {
+            "0": "No fix",
+            "1": "GNSS only",
+            "2": "Combination (GNSS + DR)",
+            "3": "DR only"
+        }
+        return sol_type_map.get(value, "Unknown")
+
+class QTMVEHATT(QTM):
+    """
+    PQTMVEHATT Message
+
+    Supports:
+    - $PQTMVEHATT,<MsgVer>,<Timestamp>,<Roll>,<Pitch>,<Heading>,<Acc_Roll>,<Acc_Pitch>,<Acc_Heading>*<Checksum>
+
+    Field Descriptions:
+    - MsgVer: Message version (Always 1 for this version)
+    - Timestamp: Milliseconds since power-on (string)
+    - Roll: Vehicle roll angle in degrees, range: -180.000000 to 180.000000 (string)
+    - Pitch: Vehicle pitch angle in degrees, range: -90.000000 to 90.000000 (string)
+    - Heading: Vehicle heading angle in degrees, range: 0.000000 to 360.000000 (string)
+    - Acc_Roll: Vehicle roll accuracy in degrees, range: 0.000000 to 360.000000 (string)
+    - Acc_Pitch: Vehicle pitch accuracy in degrees, range: 0.000000 to 180.000000 (string)
+    - Acc_Heading: Vehicle heading accuracy in degrees, range: 0.000000 to 360.000000 (string)
+    """
+
+    fields = (
+        ('sentence_type', 'sentence_type'),  # Always "VEHATT"
+        ('MsgVer', 'msg_ver'),  # Message version
+        ('Timestamp', 'timestamp'),  # Milliseconds since power-on
+        ('Roll', 'roll'),  # Roll angle
+        ('Pitch', 'pitch'),  # Pitch angle
+        ('Heading', 'heading'),  # Heading angle
+        ('Acc_Roll', 'acc_roll'),  # Roll accuracy
+        ('Acc_Pitch', 'acc_pitch'),  # Pitch accuracy
+        ('Acc_Heading', 'acc_heading')  # Heading accuracy
+    )
+
+    def __init__(self, manufacturer, data):
+        super(QTMVEHATT, self).__init__(manufacturer, data)
+        self.sentence_type = "VEHATT"
+        self.msg_ver = data[1]  # Message version as string
+        self.timestamp = data[2]  # Timestamp as string
+        self.roll = data[3]  # Roll angle as string
+        self.pitch = data[4]  # Pitch angle as string
+        self.heading = data[5]  # Heading angle as string
+        self.acc_roll = data[6]  # Roll accuracy as string
+        self.acc_pitch = data[7]  # Pitch accuracy as string
+        self.acc_heading = data[8]  # Heading accuracy as string
diff --git a/setup.py b/setup.py
index d9d3eb8..638fcc5 100644
--- a/setup.py
+++ b/setup.py
@@ -49,6 +49,7 @@ def load_source(modname, filename):
         'Programming Language :: Python :: 3.10',
         'Programming Language :: Python :: 3.11',
         'Programming Language :: Python :: 3.12',
+        'Programming Language :: Python :: 3.13',
         'Programming Language :: Python :: Implementation :: PyPy',
         'Topic :: Scientific/Engineering :: GIS',
         'Topic :: Software Development :: Libraries :: Python Modules',
diff --git a/test/__pycache__/test_ash.cpython-313-pytest-8.3.3.pyc.34172 b/test/__pycache__/test_ash.cpython-313-pytest-8.3.3.pyc.34172
new file mode 100644
index 0000000..5582b38
Binary files /dev/null and b/test/__pycache__/test_ash.cpython-313-pytest-8.3.3.pyc.34172 differ
diff --git a/test/__pycache__/test_nor.cpython-313-pytest-8.3.3.pyc.34172 b/test/__pycache__/test_nor.cpython-313-pytest-8.3.3.pyc.34172
new file mode 100644
index 0000000..e80da87
Binary files /dev/null and b/test/__pycache__/test_nor.cpython-313-pytest-8.3.3.pyc.34172 differ
diff --git a/test/__pycache__/test_nor.cpython-313-pytest-8.3.3.pyc.36136 b/test/__pycache__/test_nor.cpython-313-pytest-8.3.3.pyc.36136
new file mode 100644
index 0000000..e80da87
Binary files /dev/null and b/test/__pycache__/test_nor.cpython-313-pytest-8.3.3.pyc.36136 differ
diff --git a/test/__pycache__/test_nor.cpython-313-pytest-8.3.3.pyc.49024 b/test/__pycache__/test_nor.cpython-313-pytest-8.3.3.pyc.49024
new file mode 100644
index 0000000..e80da87
Binary files /dev/null and b/test/__pycache__/test_nor.cpython-313-pytest-8.3.3.pyc.49024 differ
diff --git a/test/__pycache__/test_proprietary.cpython-313-pytest-8.3.3.pyc.34172 b/test/__pycache__/test_proprietary.cpython-313-pytest-8.3.3.pyc.34172
new file mode 100644
index 0000000..50985cd
Binary files /dev/null and b/test/__pycache__/test_proprietary.cpython-313-pytest-8.3.3.pyc.34172 differ
diff --git a/test/__pycache__/test_proprietary.cpython-313-pytest-8.3.3.pyc.36136 b/test/__pycache__/test_proprietary.cpython-313-pytest-8.3.3.pyc.36136
new file mode 100644
index 0000000..50985cd
Binary files /dev/null and b/test/__pycache__/test_proprietary.cpython-313-pytest-8.3.3.pyc.36136 differ
diff --git a/test/__pycache__/test_proprietary.cpython-313-pytest-8.3.3.pyc.49024 b/test/__pycache__/test_proprietary.cpython-313-pytest-8.3.3.pyc.49024
new file mode 100644
index 0000000..50985cd
Binary files /dev/null and b/test/__pycache__/test_proprietary.cpython-313-pytest-8.3.3.pyc.49024 differ
diff --git a/test/__pycache__/test_pynmea.cpython-313-pytest-8.3.3.pyc.34172 b/test/__pycache__/test_pynmea.cpython-313-pytest-8.3.3.pyc.34172
new file mode 100644
index 0000000..0a1beca
Binary files /dev/null and b/test/__pycache__/test_pynmea.cpython-313-pytest-8.3.3.pyc.34172 differ
diff --git a/test/__pycache__/test_pynmea.cpython-313-pytest-8.3.3.pyc.36136 b/test/__pycache__/test_pynmea.cpython-313-pytest-8.3.3.pyc.36136
new file mode 100644
index 0000000..0a1beca
Binary files /dev/null and b/test/__pycache__/test_pynmea.cpython-313-pytest-8.3.3.pyc.36136 differ
diff --git a/test/__pycache__/test_qtm.cpython-313-pytest-8.3.3.pyc.13136 b/test/__pycache__/test_qtm.cpython-313-pytest-8.3.3.pyc.13136
new file mode 100644
index 0000000..5c3e7a2
Binary files /dev/null and b/test/__pycache__/test_qtm.cpython-313-pytest-8.3.3.pyc.13136 differ
diff --git a/test/__pycache__/test_qtm.cpython-313-pytest-8.3.3.pyc.15432 b/test/__pycache__/test_qtm.cpython-313-pytest-8.3.3.pyc.15432
new file mode 100644
index 0000000..d06a033
Binary files /dev/null and b/test/__pycache__/test_qtm.cpython-313-pytest-8.3.3.pyc.15432 differ
diff --git a/test/__pycache__/test_qtm.cpython-313-pytest-8.3.3.pyc.15924 b/test/__pycache__/test_qtm.cpython-313-pytest-8.3.3.pyc.15924
new file mode 100644
index 0000000..4789252
Binary files /dev/null and b/test/__pycache__/test_qtm.cpython-313-pytest-8.3.3.pyc.15924 differ
diff --git a/test/__pycache__/test_qtm.cpython-313-pytest-8.3.3.pyc.16672 b/test/__pycache__/test_qtm.cpython-313-pytest-8.3.3.pyc.16672
new file mode 100644
index 0000000..183d7ae
Binary files /dev/null and b/test/__pycache__/test_qtm.cpython-313-pytest-8.3.3.pyc.16672 differ
diff --git a/test/__pycache__/test_qtm.cpython-313-pytest-8.3.3.pyc.22756 b/test/__pycache__/test_qtm.cpython-313-pytest-8.3.3.pyc.22756
new file mode 100644
index 0000000..fad9555
Binary files /dev/null and b/test/__pycache__/test_qtm.cpython-313-pytest-8.3.3.pyc.22756 differ
diff --git a/test/__pycache__/test_qtm.cpython-313-pytest-8.3.3.pyc.26752 b/test/__pycache__/test_qtm.cpython-313-pytest-8.3.3.pyc.26752
new file mode 100644
index 0000000..31e699c
Binary files /dev/null and b/test/__pycache__/test_qtm.cpython-313-pytest-8.3.3.pyc.26752 differ
diff --git a/test/__pycache__/test_qtm.cpython-313-pytest-8.3.3.pyc.27132 b/test/__pycache__/test_qtm.cpython-313-pytest-8.3.3.pyc.27132
new file mode 100644
index 0000000..9438319
Binary files /dev/null and b/test/__pycache__/test_qtm.cpython-313-pytest-8.3.3.pyc.27132 differ
diff --git a/test/__pycache__/test_qtm.cpython-313-pytest-8.3.3.pyc.27900 b/test/__pycache__/test_qtm.cpython-313-pytest-8.3.3.pyc.27900
new file mode 100644
index 0000000..fd35435
Binary files /dev/null and b/test/__pycache__/test_qtm.cpython-313-pytest-8.3.3.pyc.27900 differ
diff --git a/test/__pycache__/test_qtm.cpython-313-pytest-8.3.3.pyc.33340 b/test/__pycache__/test_qtm.cpython-313-pytest-8.3.3.pyc.33340
new file mode 100644
index 0000000..5237587
Binary files /dev/null and b/test/__pycache__/test_qtm.cpython-313-pytest-8.3.3.pyc.33340 differ
diff --git a/test/__pycache__/test_qtm.cpython-313-pytest-8.3.3.pyc.34172 b/test/__pycache__/test_qtm.cpython-313-pytest-8.3.3.pyc.34172
new file mode 100644
index 0000000..cfd084d
Binary files /dev/null and b/test/__pycache__/test_qtm.cpython-313-pytest-8.3.3.pyc.34172 differ
diff --git a/test/__pycache__/test_qtm.cpython-313-pytest-8.3.3.pyc.36964 b/test/__pycache__/test_qtm.cpython-313-pytest-8.3.3.pyc.36964
new file mode 100644
index 0000000..db4e675
Binary files /dev/null and b/test/__pycache__/test_qtm.cpython-313-pytest-8.3.3.pyc.36964 differ
diff --git a/test/__pycache__/test_qtm.cpython-313-pytest-8.3.3.pyc.41592 b/test/__pycache__/test_qtm.cpython-313-pytest-8.3.3.pyc.41592
new file mode 100644
index 0000000..98c5255
Binary files /dev/null and b/test/__pycache__/test_qtm.cpython-313-pytest-8.3.3.pyc.41592 differ
diff --git a/test/__pycache__/test_qtm.cpython-313-pytest-8.3.3.pyc.43132 b/test/__pycache__/test_qtm.cpython-313-pytest-8.3.3.pyc.43132
new file mode 100644
index 0000000..c3795b2
Binary files /dev/null and b/test/__pycache__/test_qtm.cpython-313-pytest-8.3.3.pyc.43132 differ
diff --git a/test/__pycache__/test_qtm.cpython-313-pytest-8.3.3.pyc.43968 b/test/__pycache__/test_qtm.cpython-313-pytest-8.3.3.pyc.43968
new file mode 100644
index 0000000..9b6912e
Binary files /dev/null and b/test/__pycache__/test_qtm.cpython-313-pytest-8.3.3.pyc.43968 differ
diff --git a/test/__pycache__/test_qtm.cpython-313-pytest-8.3.3.pyc.44552 b/test/__pycache__/test_qtm.cpython-313-pytest-8.3.3.pyc.44552
new file mode 100644
index 0000000..334d100
Binary files /dev/null and b/test/__pycache__/test_qtm.cpython-313-pytest-8.3.3.pyc.44552 differ
diff --git a/test/__pycache__/test_qtm.cpython-313-pytest-8.3.3.pyc.44760 b/test/__pycache__/test_qtm.cpython-313-pytest-8.3.3.pyc.44760
new file mode 100644
index 0000000..183d7ae
Binary files /dev/null and b/test/__pycache__/test_qtm.cpython-313-pytest-8.3.3.pyc.44760 differ
diff --git a/test/__pycache__/test_qtm.cpython-313-pytest-8.3.3.pyc.47628 b/test/__pycache__/test_qtm.cpython-313-pytest-8.3.3.pyc.47628
new file mode 100644
index 0000000..5c7d169
Binary files /dev/null and b/test/__pycache__/test_qtm.cpython-313-pytest-8.3.3.pyc.47628 differ
diff --git a/test/__pycache__/test_qtm.cpython-313-pytest-8.3.3.pyc.47908 b/test/__pycache__/test_qtm.cpython-313-pytest-8.3.3.pyc.47908
new file mode 100644
index 0000000..c970922
Binary files /dev/null and b/test/__pycache__/test_qtm.cpython-313-pytest-8.3.3.pyc.47908 differ
diff --git a/test/__pycache__/test_qtm.cpython-313-pytest-8.3.3.pyc.8348 b/test/__pycache__/test_qtm.cpython-313-pytest-8.3.3.pyc.8348
new file mode 100644
index 0000000..334d100
Binary files /dev/null and b/test/__pycache__/test_qtm.cpython-313-pytest-8.3.3.pyc.8348 differ
diff --git a/test/__pycache__/test_qtm.cpython-313-pytest-8.3.3.pyc.8948 b/test/__pycache__/test_qtm.cpython-313-pytest-8.3.3.pyc.8948
new file mode 100644
index 0000000..8c9407e
Binary files /dev/null and b/test/__pycache__/test_qtm.cpython-313-pytest-8.3.3.pyc.8948 differ
diff --git a/test/__pycache__/test_rdi.cpython-313-pytest-8.3.3.pyc.34172 b/test/__pycache__/test_rdi.cpython-313-pytest-8.3.3.pyc.34172
new file mode 100644
index 0000000..f91b13b
Binary files /dev/null and b/test/__pycache__/test_rdi.cpython-313-pytest-8.3.3.pyc.34172 differ
diff --git a/test/__pycache__/test_rdi.cpython-313-pytest-8.3.3.pyc.36136 b/test/__pycache__/test_rdi.cpython-313-pytest-8.3.3.pyc.36136
new file mode 100644
index 0000000..f91b13b
Binary files /dev/null and b/test/__pycache__/test_rdi.cpython-313-pytest-8.3.3.pyc.36136 differ
diff --git a/test/__pycache__/test_rdi.cpython-313-pytest-8.3.3.pyc.47744 b/test/__pycache__/test_rdi.cpython-313-pytest-8.3.3.pyc.47744
new file mode 100644
index 0000000..f91b13b
Binary files /dev/null and b/test/__pycache__/test_rdi.cpython-313-pytest-8.3.3.pyc.47744 differ
diff --git a/test/__pycache__/test_rdi.cpython-313-pytest-8.3.3.pyc.48780 b/test/__pycache__/test_rdi.cpython-313-pytest-8.3.3.pyc.48780
new file mode 100644
index 0000000..f91b13b
Binary files /dev/null and b/test/__pycache__/test_rdi.cpython-313-pytest-8.3.3.pyc.48780 differ
diff --git a/test/__pycache__/test_rdi.cpython-313-pytest-8.3.3.pyc.49024 b/test/__pycache__/test_rdi.cpython-313-pytest-8.3.3.pyc.49024
new file mode 100644
index 0000000..f91b13b
Binary files /dev/null and b/test/__pycache__/test_rdi.cpython-313-pytest-8.3.3.pyc.49024 differ
diff --git a/test/__pycache__/test_rdi.cpython-313-pytest-8.3.3.pyc.49816 b/test/__pycache__/test_rdi.cpython-313-pytest-8.3.3.pyc.49816
new file mode 100644
index 0000000..f91b13b
Binary files /dev/null and b/test/__pycache__/test_rdi.cpython-313-pytest-8.3.3.pyc.49816 differ
diff --git a/test/__pycache__/test_rdi.cpython-313-pytest-8.3.3.pyc.500 b/test/__pycache__/test_rdi.cpython-313-pytest-8.3.3.pyc.500
new file mode 100644
index 0000000..f91b13b
Binary files /dev/null and b/test/__pycache__/test_rdi.cpython-313-pytest-8.3.3.pyc.500 differ
diff --git a/test/__pycache__/test_stream.cpython-313-pytest-8.3.3.pyc.34172 b/test/__pycache__/test_stream.cpython-313-pytest-8.3.3.pyc.34172
new file mode 100644
index 0000000..116c535
Binary files /dev/null and b/test/__pycache__/test_stream.cpython-313-pytest-8.3.3.pyc.34172 differ
diff --git a/test/__pycache__/test_stream.cpython-313-pytest-8.3.3.pyc.36136 b/test/__pycache__/test_stream.cpython-313-pytest-8.3.3.pyc.36136
new file mode 100644
index 0000000..116c535
Binary files /dev/null and b/test/__pycache__/test_stream.cpython-313-pytest-8.3.3.pyc.36136 differ
diff --git a/test/__pycache__/test_stream.cpython-313-pytest-8.3.3.pyc.49024 b/test/__pycache__/test_stream.cpython-313-pytest-8.3.3.pyc.49024
new file mode 100644
index 0000000..116c535
Binary files /dev/null and b/test/__pycache__/test_stream.cpython-313-pytest-8.3.3.pyc.49024 differ
diff --git a/test/__pycache__/test_stream.cpython-313-pytest-8.3.3.pyc.49816 b/test/__pycache__/test_stream.cpython-313-pytest-8.3.3.pyc.49816
new file mode 100644
index 0000000..116c535
Binary files /dev/null and b/test/__pycache__/test_stream.cpython-313-pytest-8.3.3.pyc.49816 differ
diff --git a/test/__pycache__/test_stream.cpython-313-pytest-8.3.3.pyc.500 b/test/__pycache__/test_stream.cpython-313-pytest-8.3.3.pyc.500
new file mode 100644
index 0000000..116c535
Binary files /dev/null and b/test/__pycache__/test_stream.cpython-313-pytest-8.3.3.pyc.500 differ
diff --git a/test/__pycache__/test_sxn.cpython-313-pytest-8.3.3.pyc.34172 b/test/__pycache__/test_sxn.cpython-313-pytest-8.3.3.pyc.34172
new file mode 100644
index 0000000..515a204
Binary files /dev/null and b/test/__pycache__/test_sxn.cpython-313-pytest-8.3.3.pyc.34172 differ
diff --git a/test/__pycache__/test_utils.cpython-313-pytest-8.3.3.pyc.34172 b/test/__pycache__/test_utils.cpython-313-pytest-8.3.3.pyc.34172
new file mode 100644
index 0000000..5b49bf8
Binary files /dev/null and b/test/__pycache__/test_utils.cpython-313-pytest-8.3.3.pyc.34172 differ
diff --git a/test/__pycache__/test_utils.cpython-313-pytest-8.3.3.pyc.36136 b/test/__pycache__/test_utils.cpython-313-pytest-8.3.3.pyc.36136
new file mode 100644
index 0000000..5b49bf8
Binary files /dev/null and b/test/__pycache__/test_utils.cpython-313-pytest-8.3.3.pyc.36136 differ
diff --git a/test/__pycache__/test_utils.cpython-313-pytest-8.3.3.pyc.49024 b/test/__pycache__/test_utils.cpython-313-pytest-8.3.3.pyc.49024
new file mode 100644
index 0000000..5b49bf8
Binary files /dev/null and b/test/__pycache__/test_utils.cpython-313-pytest-8.3.3.pyc.49024 differ
diff --git a/test/__pycache__/test_utils.cpython-313-pytest-8.3.3.pyc.49816 b/test/__pycache__/test_utils.cpython-313-pytest-8.3.3.pyc.49816
new file mode 100644
index 0000000..5b49bf8
Binary files /dev/null and b/test/__pycache__/test_utils.cpython-313-pytest-8.3.3.pyc.49816 differ
diff --git a/test/test_qtm.py b/test/test_qtm.py
new file mode 100644
index 0000000..7812104
--- /dev/null
+++ b/test/test_qtm.py
@@ -0,0 +1,589 @@
+import pynmea2
+
+def test_pqtmverno():
+    """Test PQTMVERNO with successful version response."""
+    data = "$PQTMVERNO,LC29HAANR01A04S,2022/11/04,16:39:48*34"
+    msg = pynmea2.parse(data)
+    assert type(msg) == pynmea2.qtm.QTMVERNO
+    assert msg.sentence_type == "VERNO"
+    assert msg.version == "LC29HAANR01A04S"
+    assert msg.build_date == "2022/11/04"
+    assert msg.build_time == "16:39:48"
+
+def test_pqtmsavepar():
+    """Test PQTMSAVEPAR with OK status."""
+    data = "$PQTMSAVEPAR,OK*72"
+    msg = pynmea2.parse(data)
+    assert type(msg) == pynmea2.qtm.QTMSAVEPAR
+    assert msg.status == "OK"
+
+def test_pqtmrestorepar():
+    """Test PQTMRESTOREPAR with OK status."""
+    data = "$PQTMRESTOREPAR,OK*3B"
+    msg = pynmea2.parse(data)
+    assert type(msg) == pynmea2.qtm.QTMRESTOREPAR
+    assert msg.status == "OK"
+
+def test_qtmepe():
+    """Test QTMEPE with example data."""
+    data = "$PQTMEPE,2,3.393,3.476,12.713,4.857,13.609*5D"
+    msg = pynmea2.parse(data)
+    assert type(msg) == pynmea2.qtm.QTMEPE
+    assert msg.sentence_type == "EPE"
+    assert msg.msg_ver == "2"
+    assert msg.epe_north == "3.393"
+    assert msg.epe_east == "3.476"
+    assert msg.epe_down == "12.713"
+    assert msg.epe_2d == "4.857"
+    assert msg.epe_3d == "13.609"
+
+def test_pqtmcfggeofence():
+    """Test PQTMCFGGEOFENCE with a successful response."""
+    data = "$PQTMCFGGEOFENCE,OK,1,1,0,2,30.123,-90.123,5.0,-91.456,31.789,-92.012,32.000,-93.000*41"
+    msg = pynmea2.parse(data)
+    assert type(msg) == pynmea2.qtm.QTMCFGGEOFENCE
+    assert msg.sentence_type == "CFGGEOFENCE"
+    assert msg.status == "OK"
+    assert msg.index == "1"
+    assert msg.enabled == "1"
+    assert msg.reserved == "0"
+    assert msg.shape == "2"
+    assert msg.lat0 == "30.123"
+    assert msg.lon0 == "-90.123"
+    assert msg.lat1_or_radius == "5.0"
+    assert msg.lon1 == "-91.456"
+    assert msg.lat2 == "31.789"
+    assert msg.lon2 == "-92.012"
+    assert msg.lat3 == "32.000"
+    assert msg.lon3 == "-93.000"
+
+def test_pqtmgeofencestatus():
+    """Test PQTMGEOFENCESTATUS with example data."""
+    data = "$PQTMGEOFENCESTATUS,1,093444.000,2,0,0,1*28"
+    msg = pynmea2.parse(data)
+
+    assert type(msg) == pynmea2.qtm.QTMGEOFENCESTATUS
+    assert msg.sentence_type == "GEOFENCESTATUS"
+    assert msg.msg_ver == "1"
+    assert msg.time == "093444.000"
+    assert msg.state0 == "Outside geofence"
+    assert msg.state1 == "Unknown"
+    assert msg.state2 == "Unknown"
+    assert msg.state3 == "Inside geofence"
+
+def test_qtmuniqid():
+    """Test QTMUNIQID Command Response with successful example data."""
+    # Example of a successful response
+    data_success = "$PQTMUNIQID,OK,8,1A2B3C4D5E6F7A8B*0A"
+    msg_success = pynmea2.parse(data_success)
+
+    assert type(msg_success) == pynmea2.qtm.QTMUNIQID
+    assert msg_success.sentence_type == "UNIQID"
+    assert msg_success.response == "OK"
+    assert msg_success.length == "8"  # Length of chip unique ID
+    assert msg_success.chip_id == "1A2B3C4D5E6F7A8B"  # Chip unique ID
+
+def test_pqtmjammingstatus():
+    """Test PQTMJAMMINGSTATUS with example data."""
+    data = "$PQTMJAMMINGSTATUS,1,2*44"  # Example NMEA sentence with MsgVer=1, Status=2
+    msg = pynmea2.parse(data)
+
+    assert type(msg) == pynmea2.qtm.QTMJAMMINGSTATUS
+    assert msg.sentence_type == "JAMMINGSTATUS"
+    assert msg.msg_ver == "1"
+    assert msg.status == "Warning status"  # Status 2 should be "Warning status"
+
+def test_pqtmcfgsvin():
+    """Test PQTMCFGSVIN with a successful response."""
+    data = "$PQTMCFGSVIN,OK,2,300,1.5,6378137.0,0.0,0.0*7A"
+    msg = pynmea2.parse(data)
+
+    assert type(msg) == pynmea2.qtm.QTMCFGSVIN
+    assert msg.sentence_type == "CFGSVIN"
+    assert msg.status == "OK"
+    assert msg.mode == "2"
+    assert msg.min_dur == "300"
+    assert msg.acc_limit == "1.5"
+    assert msg.ecef_x == "6378137.0"
+    assert msg.ecef_y == "0.0"
+    assert msg.ecef_z == "0.0"
+
+def test_pqtmsvinstatus():
+    """Test PQTMSVINSTATUS with example data."""
+    data = "$PQTMSVINSTATUS,1,2241,1,0,0,538,43200,-2472436.0802,4828833.0026,3343698.4839,9.5*39"
+    msg = pynmea2.parse(data)
+
+    assert type(msg) == pynmea2.qtm.QTMSVINSTATUS
+    assert msg.sentence_type == "SVINSTATUS"
+    assert msg.msg_ver == "1"
+    assert msg.tow == "2241"
+    assert msg.valid == "In-progress"
+    assert msg.res0 == "0"
+    assert msg.res1 == "0"
+    assert msg.obs == "538"
+    assert msg.cfg_dur == "43200"
+    assert msg.mean_x == "-2472436.0802"
+    assert msg.mean_y == "4828833.0026"
+    assert msg.mean_z == "3343698.4839"
+    assert msg.mean_acc == "9.5"
+
+def test_pqtmgpsstart():
+    """Test PQTMGNSSSTART with OK response."""
+    data = "$PQTMGNSSSTART,OK*79"
+    msg = pynmea2.parse(data)
+    assert type(msg) == pynmea2.qtm.QTMGNSSSTART
+    assert msg.sentence_type == "GNSSSTART"
+    assert msg.status == "OK"
+
+def test_pqtmgnssstop():
+    """Test PQTMGNSSSTOP with OK response."""
+    data = "$PQTMGNSSSTOP,OK*21"
+    msg = pynmea2.parse(data)
+    assert type(msg) == pynmea2.qtm.QTMGNSSSTOP
+    assert msg.sentence_type == "GNSSSTOP"
+    assert msg.status == "OK"
+
+def test_pqtmpvt():
+    """Test PQTMPVT with example data."""
+    data = "$PQTMPVT,1,31075000,20221225,083737.000,0,3,9,18,31.12738291,117.26372910,34.212,5.267,3.212,2.928,0.238,4.346,34.12,2.16,4.38*51"
+    msg = pynmea2.parse(data)
+
+    assert type(msg) == pynmea2.qtm.QTMPVT
+    assert msg.sentence_type == "PVT"
+    assert msg.msg_ver == "1"
+    assert msg.tow == "31075000"
+    assert msg.date == "20221225"
+    assert msg.time == "083737.000"
+    assert msg.res == "0"
+    assert msg.fix_mode == "3"
+    assert msg.num_sat_used == "9"
+    assert msg.leap_seconds == "18"
+    assert msg.lat == "31.12738291"
+    assert msg.lon == "117.26372910"
+    assert msg.alt == "34.212"
+    assert msg.sep == "5.267"
+    assert msg.vel_n == "3.212"
+    assert msg.vel_e == "2.928"
+    assert msg.vel_d == "0.238"
+    assert msg.spd == "4.346"
+    assert msg.heading == "34.12"
+    assert msg.hdop == "2.16"
+    assert msg.pdop == "4.38"
+
+def test_pqtmcfgnmeadp():
+    """Test PQTMCFGNMEADP with a successful set response."""
+    data = "$PQTMCFGNMEADP,OK,3,6,1,2,3,2*66"
+    msg = pynmea2.parse(data)
+
+    assert type(msg) == pynmea2.qtm.QTMCFGNMEADP
+    assert msg.sentence_type == "CFGNMEADP"
+    assert msg.status == "OK"
+    assert msg.utc_dp == "3"
+    assert msg.pos_dp == "6"
+    assert msg.alt_dp == "1"
+    assert msg.dop_dp == "2"
+    assert msg.spd_dp == "3"
+    assert msg.cog_dp == "2"
+
+def test_pqtmcfgrcvrmode():
+    """Test PQTMCFGRCVRMODE with a successful set response."""
+    data = "$PQTMCFGRCVRMODE,OK,2*7A"
+    msg = pynmea2.parse(data)
+
+    assert type(msg) == pynmea2.qtm.QTMCFGRCVRMODE
+    assert msg.sentence_type == "CFGRCVRMODE"
+    assert msg.status == "OK"
+    assert msg.mode == "2"
+
+    # Check if the mode description matches
+    description = msg.get_mode_description()
+    assert description == "Base Station"
+
+def test_pqtmpl():
+    """Test PQTMPL with example data."""
+    data = "$PQTMPL,1,55045200,5.00,1,1,2879,2718,4766,5344,4323,10902,,,1*2D"
+    msg = pynmea2.parse(data)
+
+    assert type(msg) == pynmea2.qtm.QTMPL
+    assert msg.sentence_type == "PL"
+    assert msg.msg_ver == "1"
+    assert msg.tow == "55045200"
+    assert msg.pul == "5.00"
+    assert msg.res1 == "1"
+    assert msg.res2 == "1"
+    assert msg.pl_posn == "2879"
+    assert msg.pl_pose == "2718"
+    assert msg.pl_posd == "4766"
+    assert msg.pl_veln == "5344"
+    assert msg.pl_vele == "4323"
+    assert msg.pl_veld == "10902"
+    assert msg.res3 == ""  # Null field
+    assert msg.res4 == ""  # Null field
+    assert msg.pl_time == "1"
+
+def test_pqtmcfgsbas():
+    """Test PQTMCFGSBAS with example data."""
+    data = "$PQTMCFGSBAS,OK,2A*2E"
+    msg = pynmea2.parse(data)
+
+    assert type(msg) == pynmea2.qtm.QTMCFGSBAS
+    assert msg.sentence_type == "CFGSBAS"
+    assert msg.status == "OK"
+    assert msg.value == "2A"  # Hexadecimal value for SBAS configuration
+
+    # Validate SBAS configuration description
+    description = msg.get_sbas_description()
+    assert "WAAS" not in description
+    assert "EGNOS" not in description
+    assert "MSAS" not in description
+    assert "GAGAN" in description  # MSAS not enabled with this value
+
+def test_pqtmcfgcnst():
+    """Test PQTMCFGCNST with example data."""
+    data = "$PQTMCFGCNST,OK,1,1,0,1,0,0*79"
+    msg = pynmea2.parse(data)
+
+    assert type(msg) == pynmea2.qtm.QTMCFGCNST
+    assert msg.sentence_type == "CFGCNST"
+    assert msg.status == "OK"
+    assert msg.gps == "1"
+    assert msg.glonass == "1"
+    assert msg.galileo == "0"
+    assert msg.bds == "1"
+    assert msg.qzss == "0"
+    assert msg.reserved == "0"
+
+    # Validate constellation status descriptions
+    statuses = msg.get_constellation_status()
+    assert statuses["GPS"] == "Enabled"
+    assert statuses["GLONASS"] == "Enabled"
+    assert statuses["Galileo"] == "Disabled"
+    assert statuses["BDS"] == "Enabled"
+    assert statuses["QZSS"] == "Disabled"
+
+def test_pqtmdop():
+    """Test PQTMDOP with example data."""
+    data = "$PQTMDOP,1,570643000,1.01,0.88,0.49,0.73,0.50,0.36,0.35*7C"
+    msg = pynmea2.parse(data)
+
+    assert type(msg) == pynmea2.qtm.QTMDOP
+    assert msg.sentence_type == "DOP"
+    assert msg.msg_ver == "1"
+    assert msg.tow == "570643000"
+    assert msg.gdop == "1.01"
+    assert msg.pdop == "0.88"
+    assert msg.tdop == "0.49"
+    assert msg.vdop == "0.73"
+    assert msg.hdop == "0.50"
+    assert msg.ndop == "0.36"
+    assert msg.edop == "0.35"
+
+    # Validate DOP status descriptions
+    assert msg.get_dop_status(msg.gdop) == "Valid"
+    assert msg.get_dop_status("99.99") == "Invalid"
+
+def test_pqtmcfgfixrate():
+    """Test PQTMCFGFIXRATE with a successful set response."""
+    data = "$PQTMCFGFIXRATE,OK*27"
+    msg = pynmea2.parse(data)
+
+    assert type(msg) == pynmea2.qtm.QTMCFGFIXRATE
+    assert msg.sentence_type == "CFGFIXRATE"
+    assert msg.status == "OK"
+
+def test_pqtmvel():
+    """Test PQTMVEL with example data."""
+    data = "$PQTMVEL,1,154512.100,1.251,2.452,1.245,2.752,3.021,180.512,0.124,0.254,0.250*67"
+    msg = pynmea2.parse(data)
+
+    assert type(msg) == pynmea2.qtm.QTMVEL
+    assert msg.version == "1"
+    assert msg.sentence_type == "VEL"
+    assert msg.time == "154512.100"
+    assert msg.vel_n == "1.251"
+    assert msg.vel_e == "2.452"
+    assert msg.vel_d == "1.245"
+    assert msg.grd_spd == "2.752"
+    assert msg.spd == "3.021"
+    assert msg.heading == "180.512"
+    assert msg.grd_spd_acc == "0.124"
+    assert msg.spd_acc == "0.254"
+    assert msg.heading_acc == "0.25"
+
+def test_pqtmantennastatus():
+    """Test PQTMTANTENNASTATUS Message with example data."""
+    # Example of a successful message
+    data = "$PQTMANTENNASTATUS,3,2,1,1*52"
+    msg = pynmea2.parse(data)
+
+    assert type(msg) == pynmea2.qtm.QTMANTENNASTATUS
+    assert msg.sentence_type == "ANTENNASTATUS"
+    assert msg.msg_ver == "3"  # Message version
+    assert msg.ant_status == "2"  # Open-circuit status
+    assert msg.ant_power_ind == "1"  # Power-on
+    assert msg.mode_ind == "1"  # Automatic mode, using integrated antenna
+
+def test_pqtmcfgodo():
+    """Test PQTMCFGODO with a successful response."""
+    data = "$PQTMCFGODO,OK,1,100*36"
+    msg = pynmea2.parse(data)
+
+    assert type(msg) == pynmea2.qtm.QTMCFGODO
+    assert msg.sentence_type == "CFGODO"
+    assert msg.status == "OK"
+    assert msg.state == "1"
+    assert msg.init_dist == "100"
+    assert msg.get_state_description() == "Enabled"
+
+def test_pqtmodo():
+    """Test PQTMODO with example data"""
+    data = "$PQTMODO,1,120635.000,1,112.3*6E"
+    msg = pynmea2.parse(data)
+
+    assert type(msg) == pynmea2.qtm.QTMODO
+    assert msg.sentence_type == "ODO"
+    assert msg.msg_ver == "1"
+    assert msg.time == "120635.000"
+    assert msg.state == "1"
+    assert msg.dist == "112.3"
+    assert msg.get_state_description() == "Enabled"
+
+def test_pqtmls():
+    """Test PQTMLS Message with example data."""
+    # Example of a PQTMLS message
+    data = "$PQTMLS,1,195494,1,2299,18,0,1,,137,7,18*2C"
+    msg = pynmea2.parse(data)
+
+    assert type(msg) == pynmea2.qtm.QTMLS
+    assert msg.sentence_type == "MLS"
+    assert msg.msg_ver == "1"  # Message version
+    assert msg.tow == "195494"  # Time of week
+    assert msg.ls_ref == "GPS"  # Leap second reference: GPS
+    assert msg.wn == "2299"  # UTC reference week number
+    assert msg.ls == "18"  # Current number of leap seconds
+    assert msg.flag == "Invalid"  # Leap second flag: Invalid
+    assert msg.lsf_ref == "GPS"  # Leap second forecast reference: GPS
+    assert msg.reserved == ""  # Reserved field
+    assert msg.wnlsf == "137"  # Week number of the new leap second
+    assert msg.dn == "7"  # Day of the week: Saturday
+    assert msg.lsf == "18"  # Leap second count after changes
+
+def test_pqtmdrcal():
+    """Test PQTMDRCAL Message with example data."""
+    # Example of a PQTMDRCAL message
+    data = "$PQTMDRCAL,1,0,1*5C"
+    msg = pynmea2.parse(data)
+
+    assert type(msg) == pynmea2.qtm.QTMDRCAL
+    assert msg.sentence_type == "DRCAL"
+    assert msg.msg_ver == "1"  # Message version
+    assert msg.cal_state == "Not calibrated"  # DR calibration state
+    assert msg.nav_type == "GNSS only"  # Navigation type
+
+def test_pqtmimutype():
+    """Test PQTMIMUTYPE Message with example data."""
+    # Example of a PQTMIMUTYPE message
+    data = "$PQTMIMUTYPE,1,2*52"
+    msg = pynmea2.parse(data)
+
+    assert type(msg) == pynmea2.qtm.QTMIMUTYPE
+    assert msg.sentence_type == "IMUTYPE"
+    assert msg.msg_ver == "1"  # Message version
+    assert msg.status == "IMU initialization successful"  # IMU initialization status
+
+def test_pqtmvehmsg():
+    """Test PQTMVEHMSG Message with different MsgVer examples."""
+
+    # Example for MsgVer = 1
+    data1 = "$PQTMVEHMSG,1,0,3.6*1C"
+    msg1 = pynmea2.parse(data1)
+    assert type(msg1) == pynmea2.qtm.QTMVEHMSG
+    assert msg1.sentence_type == "VEHMSG"
+    assert msg1.msg_ver == "1"
+    assert msg1.timestamp == "0"
+    assert msg1.parameters["VehSpeed"] == 3.6
+
+    # Example for MsgVer = 2
+    data2 = "$PQTMVEHMSG,2,0,100,1*18"
+    msg2 = pynmea2.parse(data2)
+    assert msg2.msg_ver == "2"
+    assert msg2.timestamp == "0"
+    assert msg2.parameters["WheelTickCNT"] == 100
+    assert msg2.parameters["FWD_Ind"] == "Forward"
+
+    # Example for MsgVer = 3
+    data3 = "$PQTMVEHMSG,3,0,3.6,3.6,3.6,3.6*19"
+    msg3 = pynmea2.parse(data3)
+    assert msg3.msg_ver == "3"
+    assert msg3.parameters["LF_Spd"] == 3.6
+    assert msg3.parameters["RF_Spd"] == 3.6
+    assert msg3.parameters["LR_Spd"] == 3.6
+    assert msg3.parameters["RR_Spd"] == 3.6
+    assert msg3.parameters["RR_Spd"] == 3.6
+
+    # Example for MsgVer = 4
+    data4 = "$PQTMVEHMSG,4,0,100,100,100,100,1*03"
+    msg4 = pynmea2.parse(data4)
+    assert msg4.msg_ver == "4"
+    assert msg4.parameters["LF_TickCNT"] == 100
+    assert msg4.parameters["RF_TickCNT"] == 100
+    assert msg4.parameters["LR_TickCNT"] == 100
+    assert msg4.parameters["RR_TickCNT"] == 100
+    assert msg4.parameters["FWD_Ind"] == "Forward"
+
+def test_pqtmins():
+    """Test PQTMINS Message with example data."""
+    # Example of a PQTMINS message
+    data = "$PQTMINS,240951,1,31.82222216,117.11578436,62.555605,-0.004233,0.005535,-0.004011,0.00,0.00,127.41*40"
+    msg = pynmea2.parse(data)
+
+    assert type(msg) == pynmea2.qtm.QTMINS
+    assert msg.sentence_type == "INS"
+    assert msg.timestamp == "240951"
+    assert msg.sol_type == "DR not ready. GNSS, roll, pitch, and relative heading ready."
+    assert msg.latitude == "31.82222216"
+    assert msg.longitude == "117.11578436"
+    assert msg.height == "62.555605"
+    assert msg.vel_n == "-0.004233"
+    assert msg.vel_e == "0.005535"
+    assert msg.vel_d == "-0.004011"
+    assert msg.roll == "0.0"
+    assert msg.pitch == "0.0"
+    assert msg.yaw == "127.41"
+
+def test_pqtmgps():
+    """Test PQTMGPS Message with example data."""
+    # Example of a PQTMGPS message
+    data = "$PQTMGPS,86139,94183,31.82218794,117.11579022,65.755080,0.027,94.68,2.533952,0.555471,0.886183,29,3*6B"
+    msg = pynmea2.parse(data)
+
+    assert type(msg) == pynmea2.qtm.QTMGPS
+    assert msg.sentence_type == "GPS"
+    assert msg.timestamp == "86139"
+    assert msg.tow == "94183"
+    assert msg.latitude == "31.82218794"
+    assert msg.longitude == "117.11579022"
+    assert msg.altitude == "65.755080"
+    assert msg.speed == "0.027"
+    assert msg.heading == "94.68"
+    assert msg.accuracy == "2.533952"
+    assert msg.hdop == "0.555471"
+    assert msg.pdop == "0.886183"
+    assert msg.num_sat_used == "29"
+    assert msg.fix_mode == "3D fix (including RTK float or RTK fixed)"
+
+def test_pqtmvehmot():
+    """Test PQTMVEHMOT Message with both MsgVer examples."""
+
+    # Example for MsgVer = 1
+    data1 = "$PQTMVEHMOT,1,0.288124,0.159930*0A"
+    msg1 = pynmea2.parse(data1)
+    assert type(msg1) == pynmea2.qtm.QTMVEHMOT
+    assert msg1.sentence_type == "VEHMOT"
+    assert msg1.msg_ver == "1"
+    assert msg1.peak_acceleration == "0.288124"
+    assert msg1.peak_angular_rate == "0.159930"
+
+    # Example for MsgVer = 2
+    data2 = "$PQTMVEHMOT,2,204159.000,1,2,1,1,,,,,*1D"
+    msg2 = pynmea2.parse(data2)
+    assert msg2.msg_ver == "2"
+    assert msg2.utc == "204159.000"
+    assert msg2.veh_type == "1"
+    assert msg2.mot_state == "2"
+    assert msg2.acc_status == "1"
+    assert msg2.turning_status == "1"
+    assert msg2.reserved == ["", "", "", "", ""]
+
+def test_pqtmsenmsg():
+    """Test PQTMSENMSG Message with both MsgVer examples."""
+
+    # Example for MsgVer = 2
+    data2 = "$PQTMSENMSG,2,1000,22.21,0.124521,1.241541,0.912451,0.145785,1.241541,8.954214*2D"
+    msg2 = pynmea2.parse(data2)
+    assert type(msg2) == pynmea2.qtm.QTMSENMSG
+    assert msg2.sentence_type == "SENMSG"
+    assert msg2.msg_ver == "2"
+    assert msg2.timestamp == "1000"
+    assert msg2.imu_temp == "22.21"
+    assert msg2.imu_gyro_x == "0.124521"
+    assert msg2.imu_gyro_y == "1.241541"
+    assert msg2.imu_gyro_z == "0.912451"
+    assert msg2.imu_acc_x == "0.145785"
+    assert msg2.imu_acc_y == "1.241541"
+    assert msg2.imu_acc_z == "8.954214"
+
+    # Example for MsgVer = 4
+    data4 = "$PQTMSENMSG,4,1000,22.21,0.124521,1.241541,0.912451,0.145785,1.241541,8.954214*2B"
+    msg4 = pynmea2.parse(data4)
+    assert msg4.msg_ver == "4"
+    assert msg4.timestamp == "1000"
+    assert msg4.imu_temp == "22.21"
+    assert msg4.imu_gyro_x == "0.124521"
+    assert msg4.imu_gyro_y == "1.241541"
+    assert msg4.imu_gyro_z == "0.912451"
+    assert msg4.imu_acc_x == "0.145785"
+    assert msg4.imu_acc_y == "1.241541"
+    assert msg4.imu_acc_z == "8.954214"
+
+def test_pqtmdrpva():
+    """Test PQTMDRPVA Message with example data."""
+
+    # Example with no fix
+    data1 = "$PQTMDRPVA,1,1000,163355.000,0,,,,,,,,,,,*7C"
+    msg1 = pynmea2.parse(data1)
+    assert type(msg1) == pynmea2.qtm.QTMDRPVA
+    assert msg1.sentence_type == "DRPVA"
+    assert msg1.msg_ver == "1"
+    assert msg1.timestamp == "1000"
+    assert msg1.time == "163355.000"
+    assert msg1.sol_type == "No fix"  # Human-readable description
+    assert msg1.latitude == ""
+    assert msg1.longitude == ""
+    assert msg1.altitude == ""
+    assert msg1.sep == ""
+    assert msg1.vel_n == ""
+    assert msg1.vel_e == ""
+    assert msg1.vel_d == ""
+    assert msg1.speed == ""
+    assert msg1.roll == ""
+    assert msg1.pitch == ""
+    assert msg1.heading == ""
+
+    # Example with GNSS + DR fix
+    data2 = "$PQTMDRPVA,1,75000,083737.000,2,31.12738291,117.26372910,34.212,5.267,3.212,2.928,0.238,4.346,0.392663,1.300793,0.030088*5E"
+    msg2 = pynmea2.parse(data2)
+    assert msg2.msg_ver == "1"
+    assert msg2.timestamp == "75000"
+    assert msg2.time == "083737.000"
+    assert msg2.sol_type == "Combination (GNSS + DR)"  # Human-readable description
+    assert msg2.latitude == "31.12738291"
+    assert msg2.longitude == "117.26372910"
+    assert msg2.altitude == "34.212"
+    assert msg2.sep == "5.267"
+    assert msg2.vel_n == "3.212"
+    assert msg2.vel_e == "2.928"
+    assert msg2.vel_d == "0.238"
+    assert msg2.speed == "4.346"
+    assert msg2.roll == "0.392663"
+    assert msg2.pitch == "1.300793"
+    assert msg2.heading == "0.030088"
+
+
+def test_pqtmvehatt():
+    """Test PQTMVEHATT Message with example data."""
+
+    # Example data
+    data = "$PQTMVEHATT,1,1000,10.002154,20.235412,160.145185,1.254123,5.451214,5.012154*3D"
+    msg = pynmea2.parse(data)
+
+    assert type(msg) == pynmea2.qtm.QTMVEHATT
+    assert msg.sentence_type == "VEHATT"
+    assert msg.msg_ver == "1"
+    assert msg.timestamp == "1000"
+    assert msg.roll == "10.002154"
+    assert msg.pitch == "20.235412"
+    assert msg.heading == "160.145185"
+    assert msg.acc_roll == "1.254123"
+    assert msg.acc_pitch == "5.451214"
+    assert msg.acc_heading == "5.012154"