diff --git a/.appveyor.yml b/.appveyor.yml
index 500c71320..aa7c12293 100644
--- a/.appveyor.yml
+++ b/.appveyor.yml
@@ -15,7 +15,7 @@ install:
   - set PATH=%PYTHON%;%PYTHON%\\Scripts;%PATH%
 
   # We need to install the python-can library itself including the dependencies
-  - "python -m pip install .[test,neovi]"
+  - "python -m pip install .[test,neovi,mf4]"
 
 build: off
 
diff --git a/.travis.yml b/.travis.yml
index 8ecb4abd5..bdf79c016 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -16,12 +16,9 @@ python:
   # PyPy:
   - pypy3
 
-env:
-
-
 install:
   - if [[ "$TEST_SOCKETCAN" ]]; then sudo bash test/open_vcan.sh ; fi
-  - travis_retry pip install .[test]
+  - travis_retry pip install .[test,mf4]
 
 script:
   - |
@@ -74,6 +71,7 @@ jobs:
         #   -a Write all files
         #   -n nitpicky
         - python -m sphinx -an doc build
+
     - stage: linter
       name: "Linter Checks"
       python: "3.7"
@@ -109,6 +107,7 @@ jobs:
         - travis_retry pip install -r requirements-lint.txt
       script:
         - black --check --verbose .
+
     - stage: deploy
       name: "PyPi Deployment"
       python: "3.7"
diff --git a/README.rst b/README.rst
index 0214f2d4b..539267a37 100644
--- a/README.rst
+++ b/README.rst
@@ -67,7 +67,7 @@ Features
 - receiving, sending, and periodically sending messages
 - normal and extended arbitration IDs
 - limited `CAN FD <https://en.wikipedia.org/wiki/CAN_FD>`__ support
-- many different loggers and readers supporting playback: ASC (CANalyzer format), BLF (Binary Logging Format by Vector), CSV, SQLite and Canutils log
+- many different loggers and readers supporting playback: ASC (CANalyzer format), BLF (Binary Logging Format by Vector), CSV, SQLite, Canutils log and MF4 (Measurement Data Format v4 by ASAM)
 - efficient in-kernel or in-hardware filtering of messages on supported interfaces
 - bus configuration reading from file or environment variables
 - CLI tools for working with CAN buses (see the `docs <https://python-can.readthedocs.io/en/stable/scripts.html>`__)
diff --git a/can/__init__.py b/can/__init__.py
index 3c1ac8d75..a12a19c1f 100644
--- a/can/__init__.py
+++ b/can/__init__.py
@@ -29,6 +29,10 @@ class CanError(IOError):
 from .io import CanutilsLogReader, CanutilsLogWriter
 from .io import CSVWriter, CSVReader
 from .io import SqliteWriter, SqliteReader
+try:
+    from .io import MF4Writer, MF4Reader
+except ImportError:
+    pass
 
 from .util import set_logging_level
 
diff --git a/can/io/__init__.py b/can/io/__init__.py
index 3797d4b5d..dd2224c93 100644
--- a/can/io/__init__.py
+++ b/can/io/__init__.py
@@ -16,3 +16,7 @@
 from .csv import CSVWriter, CSVReader
 from .sqlite import SqliteReader, SqliteWriter
 from .printer import Printer
+try:
+    from .mf4 import MF4Writer, MF4Reader 
+except ImportError:
+    pass
diff --git a/can/io/mf4.py b/can/io/mf4.py
new file mode 100644
index 000000000..28d9bba1e
--- /dev/null
+++ b/can/io/mf4.py
@@ -0,0 +1,420 @@
+# coding: utf-8
+
+"""
+Contains handling of MF4 logging files.
+
+MF4 files represent Measurement Data Format (MDF) version 4 as specified by
+the ASAM MDF standard (see https://www.asam.net/standards/detail/mdf/)
+
+"""
+
+from __future__ import absolute_import
+
+from datetime import datetime
+from pathlib import Path
+import logging
+
+from ..message import Message
+from ..listener import Listener
+from ..util import channel2int
+from .generic import BaseIOHandler
+
+try:
+    from asammdf import MDF, Signal
+    import numpy as np
+
+    CAN_MSG_EXT = 0x80000000
+    CAN_ID_MASK = 0x1FFFFFFF
+
+    STD_DTYPE = np.dtype(
+        [
+            ('CAN_DataFrame.BusChannel', '<u1'),
+            ('CAN_DataFrame.ID', '<u4'),
+            ('CAN_DataFrame.IDE', '<u1'),
+            ('CAN_DataFrame.DLC', '<u1'),
+            ('CAN_DataFrame.DataLength', '<u1'),
+            ('CAN_DataFrame.DataBytes', '(64,)u1'),
+            ('CAN_DataFrame.Dir', '<u1'),
+            ('CAN_DataFrame.EDL', '<u1'),
+            ('CAN_DataFrame.BRS', '<u1'),
+            ('CAN_DataFrame.ESI', '<u1'),
+        ]
+    )
+
+    ERR_DTYPE = np.dtype(
+        [
+            ('CAN_ErrorFrame.BusChannel', '<u1'),
+            ('CAN_ErrorFrame.ID', '<u4'),
+            ('CAN_ErrorFrame.IDE', '<u1'),
+            ('CAN_ErrorFrame.DLC', '<u1'),
+            ('CAN_ErrorFrame.DataLength', '<u1'),
+            ('CAN_ErrorFrame.DataBytes', '(64,)u1'),
+            ('CAN_ErrorFrame.Dir', '<u1'),
+            ('CAN_ErrorFrame.EDL', '<u1'),
+            ('CAN_ErrorFrame.BRS', '<u1'),
+            ('CAN_ErrorFrame.ESI', '<u1'),
+        ]
+    )
+
+    RTR_DTYPE = np.dtype(
+        [
+            ('CAN_DataFrame.BusChannel', '<u1'),
+            ('CAN_DataFrame.ID', '<u4'),
+            ('CAN_DataFrame.IDE', '<u1'),
+            ('CAN_DataFrame.DLC', '<u1'),
+            ('CAN_DataFrame.Dir', '<u1'),
+        ]
+    )
+
+    FD_LEN2DLC = {
+        12: 9,
+        16: 10,
+        20: 11,
+        24: 12,
+        32: 13,
+        48: 14,
+        64: 15,
+    }
+
+    FD_DLC2LEN = {
+        value: key
+        for key, value in FD_LEN2DLC.items()
+    }
+
+    logger = logging.getLogger('can.io.mf4')
+
+
+    class MF4Writer(BaseIOHandler, Listener):
+        """Logs CAN data to an ASAM Measurement Data File v4 (.mf4).
+
+        MF4Writer does not support append mode.
+
+        If a message has a timestamp smaller than the previous one or None,
+        it gets assigned the timestamp that was written for the last message.
+        It the first message does not have a timestamp, it is set to zero.
+        """
+
+        def __init__(self, file, database=None):
+            """
+            :param file: a path-like object or as file-like object to write to
+                         If this is a file-like object, is has to be opened in
+                         binary write mode, not text write mode.
+            :param database: optional path to a DBC or ARXML file that contains
+                             message description.
+            """
+            super(MF4Writer, self).__init__(file, mode='r+b')
+            now = datetime.now()
+            self._mdf = MDF()
+            self._mdf.header.start_time = now
+            self.last_timestamp = self._start_time = now.timestamp()
+
+            if database:
+                database = Path(database).resolve()
+                if database.exists():
+                    data = database.read_bytes()
+                    attachment = data, database.name
+                else:
+                    attachment = None
+            else:
+                attachment = None
+
+            # standard frames group
+            self._mdf.append(
+                Signal(
+                    name="CAN_DataFrame",
+                    samples=np.array([], dtype=STD_DTYPE),
+                    timestamps=np.array([], dtype='<f8'),
+                    attachment=attachment,
+                )
+            )
+
+            # error frames group
+            self._mdf.append(
+                Signal(
+                    name="CAN_ErrorFrame",
+                    samples=np.array([], dtype=ERR_DTYPE),
+                    timestamps=np.array([], dtype='<f8'),
+                    attachment=attachment,
+                )
+            )
+
+            # remote frames group
+            self._mdf.append(
+                Signal(
+                    name="CAN_DataFrame",
+                    samples=np.array([], dtype=RTR_DTYPE),
+                    timestamps=np.array([], dtype='<f8'),
+                    attachment=attachment,
+                )
+            )
+
+            self._buffer = np.zeros(1, dtype=STD_DTYPE)
+            self._rtr_buffer = np.zeros(1, dtype=RTR_DTYPE)
+
+        def stop(self):
+            self._mdf.save(self.file, compression=2)
+            self._mdf.close()
+            super(MF4Writer, self).stop()
+
+        def on_message_received(self, msg):
+
+            channel = channel2int(msg.channel)
+
+            buffer = self._buffer
+            rtr_buffer = self._rtr_buffer
+
+            if msg.is_remote_frame:
+                if channel is not None:
+                    rtr_buffer['CAN_DataFrame.BusChannel'] = channel
+
+                rtr_buffer['CAN_DataFrame.ID'] = msg.arbitration_id
+                rtr_buffer['CAN_DataFrame.IDE'] = int(msg.is_extended_id)
+                rtr_buffer['CAN_DataFrame.DLC'] = msg.dlc
+
+            else:
+                if channel is not None:
+                    buffer['CAN_DataFrame.BusChannel'] = channel
+
+                buffer['CAN_DataFrame.ID'] = msg.arbitration_id
+                buffer['CAN_DataFrame.IDE'] = int(msg.is_extended_id)
+                data = msg.data
+                size = len(data)
+                buffer['CAN_DataFrame.DataLength'] = size
+                buffer['CAN_DataFrame.DataBytes'][0, :size] = data
+                if msg.is_fd:
+                    buffer['CAN_DataFrame.DLC'] = FD_LEN2DLC[msg.dlc]
+                    buffer['CAN_DataFrame.ESI'] = int(msg.error_state_indicator)
+                    buffer['CAN_DataFrame.BRS'] = int(msg.bitrate_switch)
+                    buffer['CAN_DataFrame.EDL'] = 1
+                else:
+                    buffer['CAN_DataFrame.DLC'] = msg.dlc
+                    buffer['CAN_DataFrame.ESI'] = 0
+                    buffer['CAN_DataFrame.BRS'] = 0
+                    buffer['CAN_DataFrame.EDL'] = 0
+
+            timestamp = msg.timestamp
+            if timestamp is None:
+                timestamp = self.last_timestamp
+            else:
+                self.last_timestamp = max(
+                    self.last_timestamp,
+                    timestamp,
+                )
+
+            timestamp -= self._start_time
+
+            if msg.is_remote_frame:
+                sigs = [
+                    (np.array([timestamp]), None),
+                    (rtr_buffer, None)
+                ]
+            else:
+                sigs = [
+                    (np.array([timestamp]), None),
+                    (buffer, None)
+                ]
+
+            if msg.is_remote_frame:
+                self._mdf.extend(2, sigs)
+            elif msg.is_error_frame:
+                self._mdf.extend(1, sigs)
+            else:
+                self._mdf.extend(0, sigs)
+
+
+    class MF4Reader(BaseIOHandler):
+        """
+        Iterator of CAN messages from a MF4 logging file.
+
+        """
+
+        def __init__(self, file):
+            """
+            :param file: a path-like object or as file-like object to read from
+                         If this is a file-like object, is has to be opened in
+                         binary read mode, not text read mode.
+            """
+            super(MF4Reader, self).__init__(file, mode='rb')
+
+            self._mdf = MDF(file)
+
+            self.start_timestamp = self._mdf.header.start_time.timestamp()
+
+            masters = [
+                self._mdf.get_master(i, copy_master=False)
+                for i in range(3)
+            ]
+
+            masters = [
+                np.core.records.fromarrays(
+                    (master, np.ones(len(master)) * i)
+                )
+                for i, master in enumerate(masters)
+            ]
+
+            self.masters = np.sort(np.concatenate(masters))
+
+        def __iter__(self):
+            standard_counter = 0
+            error_counter = 0
+            rtr_counter = 0
+
+            for timestamp, group_index in self.masters:
+
+                # standard frames
+                if group_index == 0:
+                    sample = self._mdf.get(
+                        'CAN_DataFrame',
+                        group=group_index,
+                        raw=True,
+                        record_offset=standard_counter,
+                        record_count=1,
+                    )
+
+                    if sample['CAN_DataFrame.EDL'] == 0:
+
+                        is_extended_id = bool(sample['CAN_DataFrame.IDE'])
+                        channel = sample['CAN_DataFrame.ID']
+                        arbitration_id = int(sample['CAN_DataFrame.ID'])
+                        size = int(sample['CAN_DataFrame.DataLength'])
+                        dlc = int(sample['CAN_DataFrame.DLC'])
+                        data = sample['CAN_DataFrame.DataBytes'][0, :size].tobytes()
+
+                        msg = Message(
+                            timestamp=timestamp + self.start_timestamp,
+                            is_error_frame=False,
+                            is_remote_frame=False,
+                            is_fd=False,
+                            is_extended_id=is_extended_id,
+                            channel=channel,
+                            arbitration_id=arbitration_id,
+                            data=data,
+                            dlc=dlc,
+                        )
+
+                    else:
+                        is_extended_id = bool(sample['CAN_DataFrame.IDE'])
+                        channel = sample['CAN_DataFrame.ID']
+                        arbitration_id = int(sample['CAN_DataFrame.ID'])
+                        size = int(sample['CAN_DataFrame.DataLength'])
+                        dlc = FD_DLC2LEN(sample['CAN_DataFrame.DLC'])
+                        data = sample['CAN_DataFrame.DataBytes'][0, :size].tobytes()
+                        error_state_indicator = int(sample['CAN_DataFrame.ESI'])
+                        bitrate_switch = int(sample['CAN_DataFrame.BRS'])
+
+                        msg = Message(
+                            timestamp=timestamp + self.start_timestamp,
+                            is_error_frame=False,
+                            is_remote_frame=False,
+                            is_fd=True,
+                            is_extended_id=is_extended_id,
+                            channel=channel,
+                            arbitration_id=arbitration_id,
+                            data=data,
+                            dlc=dlc,
+                            bitrate_switch=bitrate_switch,
+                            error_state_indicator=error_state_indicator,
+                        )
+
+                    yield msg
+                    standard_counter += 1
+
+                # error frames
+                elif group_index == 1:
+
+                    sample = self._mdf.get(
+                        'CAN_ErrorFrame',
+                        group=group_index,
+                        raw=True,
+                        record_offset=error_counter,
+                        record_count=1,
+                    )
+
+                    if sample['CAN_ErrorFrame.EDL'] == 0:
+
+                        is_extended_id = bool(sample['CAN_ErrorFrame.IDE'])
+                        channel = sample['CAN_ErrorFrame.ID']
+                        arbitration_id = int(sample['CAN_ErrorFrame.ID'])
+                        size = int(sample['CAN_ErrorFrame.DataLength'])
+                        dlc = int(sample['CAN_ErrorFrame.DLC'])
+                        data = sample['CAN_ErrorFrame.DataBytes'][0, :size].tobytes()
+
+                        msg = Message(
+                            timestamp=timestamp + self.start_timestamp,
+                            is_error_frame=True,
+                            is_remote_frame=False,
+                            is_fd=False,
+                            is_extended_id=is_extended_id,
+                            channel=channel,
+                            arbitration_id=arbitration_id,
+                            data=data,
+                            dlc=dlc,
+                        )
+
+                    else:
+                        is_extended_id = bool(sample['CAN_ErrorFrame.IDE'])
+                        channel = sample['CAN_ErrorFrame.ID']
+                        arbitration_id = int(sample['CAN_ErrorFrame.ID'])
+                        size = int(sample['CAN_ErrorFrame.DataLength'])
+                        dlc = FD_DLC2LEN(sample['CAN_ErrorFrame.DLC'])
+                        data = sample['CAN_ErrorFrame.DataBytes'][0, :size].tobytes()
+                        error_state_indicator = int(sample['CAN_ErrorFrame.ESI'])
+                        bitrate_switch = int(sample['CAN_ErrorFrame.BRS'])
+
+                        msg = Message(
+                            timestamp=timestamp + self.start_timestamp,
+                            is_error_frame=True,
+                            is_remote_frame=False,
+                            is_fd=True,
+                            is_extended_id=is_extended_id,
+                            channel=channel,
+                            arbitration_id=arbitration_id,
+                            data=data,
+                            dlc=dlc,
+                            bitrate_switch=bitrate_switch,
+                            error_state_indicator=error_state_indicator,
+                        )
+
+                    yield msg
+                    error_counter += 1
+
+                # remote frames
+                else:
+                    sample = self._mdf.get(
+                        'CAN_DataFrame',
+                        group=group_index,
+                        raw=True,
+                        record_offset=rtr_counter,
+                        record_count=1,
+                    )
+
+                    is_extended_id = bool(sample['CAN_DataFrame.IDE'])
+                    channel = sample['CAN_DataFrame.ID']
+                    arbitration_id = int(sample['CAN_DataFrame.ID'])
+                    dlc = int(sample['CAN_DataFrame.DLC'])
+
+                    msg = Message(
+                        timestamp=timestamp + self.start_timestamp,
+                        is_error_frame=False,
+                        is_remote_frame=True,
+                        is_fd=False,
+                        is_extended_id=is_extended_id,
+                        channel=channel,
+                        arbitration_id=arbitration_id,
+                        dlc=dlc,
+                    )
+
+                    yield msg
+
+                    rtr_counter += 1
+
+            self.stop()
+
+        def stop(self):
+            self._mdf.close()
+            super(MF4Reader, self).stop()
+
+    ASAMMDF_AVAILABLE = True
+
+except ImportError:
+    ASAMMDF_AVAILABLE = False
diff --git a/doc/listeners.rst b/doc/listeners.rst
index fcdc32f52..0160eb80d 100644
--- a/doc/listeners.rst
+++ b/doc/listeners.rst
@@ -167,3 +167,32 @@ The following class can be used to read messages from BLF file:
 
 .. autoclass:: can.BLFReader
     :members:
+    
+  
+MF4 (Measurement Data Format v4)
+--------------------------------
+
+Implements support for MF4 (Measurement Data Format v4) which is a proprietary
+format from ASAM, widely used in many automotive software (Vector CANape, ETAS INCA, dSPACE ControlDesk, etc.).
+
+The data is stored in a compressed format which makes it compact.
+
+.. note:: MF4 support requires Python >= 3.6 and has to be installed as an extra with for example ``pip install python-can[mf4]``.
+
+.. note:: Channels will be converted to integers.
+
+.. note:: MF4Writer does not suppport append mode.
+
+
+.. autoclass:: can.MF4Writer
+    :members:
+
+The MDF format is very flexible regarding the internal structure and it is used to handle data from multiple sources, not just CAN bus logging.
+MDF4Writer will always create a fixed internal file structure where there will be three channel groups (for standard, error and remote frames). 
+Using this fixed file structure allows for a simple implementation of MDF4Writer and MF4Reader classes.
+Therefor MF4Reader can only replay files created with MF4Writer. 
+
+The following class can be used to read messages from MF4 file:
+
+.. autoclass:: can.MF4Reader
+    :members:
diff --git a/examples/receive_all.py b/examples/receive_all.py
index ced8841bc..544b086ef 100755
--- a/examples/receive_all.py
+++ b/examples/receive_all.py
@@ -8,7 +8,7 @@
 
 def receive_all():
 
-    bus = can.interface.Bus(bustype="pcan", channel="PCAN_USBBUS1", bitrate=250000)
+    bus = can.interface.Bus(bustype='pcan', channel='PCAN_USBBUS1', bitrate=250000)
     # bus = can.interface.Bus(bustype='ixxat', channel=0, bitrate=250000)
     # bus = can.interface.Bus(bustype='vector', app_name='CANalyzer', channel=0, bitrate=250000)
 
diff --git a/setup.py b/setup.py
index 2b1bf2296..3982bfbd9 100644
--- a/setup.py
+++ b/setup.py
@@ -27,6 +27,7 @@
 # Dependencies
 extras_require = {
     "seeedstudio": ["pyserial>=3.0"],
+    "mf4": ["asammdf>=5.5.0", "numpy>=1.16.0", "Cython"],
     "serial": ["pyserial~=3.0"],
     "neovi": ["python-ics>=2.12", "filelock"],
 }
diff --git a/test/logformats_test.py b/test/logformats_test.py
index 9983b0ecb..23ca62e21 100644
--- a/test/logformats_test.py
+++ b/test/logformats_test.py
@@ -142,6 +142,7 @@ def test_path_like_explicit_stop(self):
         writer = self.writer_constructor(self.test_file_name)
         self._write_all(writer)
         self._ensure_fsync(writer)
+
         writer.stop()
         if hasattr(writer.file, "closed"):
             self.assertTrue(writer.file.closed)
@@ -412,6 +413,27 @@ def _setup_instance(self):
         )
 
 
+try:
+    from can import MF4Writer, MF4Reader
+
+    class TestMF4FileFormat(ReaderWriterTest):
+        """Tests can.MF4Writer and can.MF4Reader"""
+
+        __test__ = True
+
+        def _setup_instance(self):
+            super(TestMF4FileFormat, self)._setup_instance_helper(
+                MF4Writer, MF4Reader,
+                binary_file=True,
+                check_comments=False,
+                preserves_channel=False,
+                adds_default_channel=0,
+            )
+
+except ImportError:
+    pass
+
+
 class TestSqliteDatabaseFormat(ReaderWriterTest):
     """Tests can.SqliteWriter and can.SqliteReader"""