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 e0a4b0b3f..a83d461af 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -74,6 +74,7 @@ jobs:
         #   -a Write all files
         #   -n nitpicky
         - python -m sphinx -an doc build
+
     - stage: linter
       name: "Linter Checks"
       python: "3.7"
@@ -85,6 +86,8 @@ jobs:
         # Slowly enable all pylint warnings by adding addressed classes of
         # warnings to the .pylintrc-wip file to prevent them from being
         # re-introduced
+
+
         # check the entire main codebase
         - pylint --rcfile=.pylintrc-wip can/**.py
         # check setup.py
@@ -116,6 +119,7 @@ jobs:
           can/io/**.py
           scripts/**.py
           examples/**.py
+
     - stage: linter
       name: "Formatting Checks"
       python: "3.7"
@@ -123,6 +127,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 457546307..6ce56c9d9 100644
--- a/can/__init__.py
+++ b/can/__init__.py
@@ -28,6 +28,11 @@ class CanError(IOError):
 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
 
 from .message import Message
diff --git a/can/io/__init__.py b/can/io/__init__.py
index 53389e91b..e09f969ad 100644
--- a/can/io/__init__.py
+++ b/can/io/__init__.py
@@ -14,3 +14,8 @@
 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/logger.py b/can/io/logger.py
index 3c9cf5e46..9582ee5be 100644
--- a/can/io/logger.py
+++ b/can/io/logger.py
@@ -1,7 +1,10 @@
+# coding: utf-8
+
 """
 See the :class:`Logger` class.
 """
 
+import logging
 import pathlib
 import typing
 
@@ -16,6 +19,12 @@
 from .sqlite import SqliteWriter
 from .printer import Printer
 
+try:
+    from .mf4 import MF4Writer
+except ImportError:
+    # be careful when using MF4Writer, it might NameError
+    pass
+
 
 class Logger(BaseIOHandler, Listener):  # pylint: disable=abstract-method
     """
@@ -27,6 +36,7 @@ class Logger(BaseIOHandler, Listener):  # pylint: disable=abstract-method
       * .csv: :class:`can.CSVWriter`
       * .db: :class:`can.SqliteWriter`
       * .log :class:`can.CanutilsLogWriter`
+      * .mf4 :class:`can.MF4Writer`
       * .txt :class:`can.Printer`
 
     The **filename** may also be *None*, to fall back to :class:`can.Printer`.
@@ -59,6 +69,11 @@ def __new__(
             ".log": CanutilsLogWriter,
             ".txt": Printer,
         }
+        try:
+            lookup[".mf4"] = MF4Writer
+        except NameError:
+            pass
+
         suffix = pathlib.PurePath(filename).suffix
         try:
             return lookup[suffix](filename, *args, **kwargs)
diff --git a/can/io/mf4.py b/can/io/mf4.py
new file mode 100644
index 000000000..4ad85ce8a
--- /dev/null
+++ b/can/io/mf4.py
@@ -0,0 +1,401 @@
+"""
+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 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 MDF4, Signal
+    import numpy as np
+
+    ASAMMDF_AVAILABLE = True
+
+except ImportError as error:
+    ASAMMDF_AVAILABLE = False
+    raise error
+
+
+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().__init__(file, mode="r+b")
+        now = datetime.now()
+        self._mdf = MDF4()
+        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, compression=2):
+        """
+        :param file: compression option as integer (default 2)
+                        * 0 - no compression
+                        * 1 - deflate (slower, but produces smaller files)
+                        * 2 - transposition + deflate (slowest, but produces
+                        the smallest files)
+        """
+        self._mdf.save(self.file, compression=compression)
+        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
+
+            self._buffer = np.zeros(1, dtype=STD_DTYPE)
+            self._rtr_buffer = np.zeros(1, dtype=RTR_DTYPE)
+
+        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().__init__(file, mode="rb")
+
+        self._mdf = MDF4(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().stop()
diff --git a/can/io/player.py b/can/io/player.py
index bd206061c..85eb00df8 100644
--- a/can/io/player.py
+++ b/can/io/player.py
@@ -18,6 +18,12 @@
 from .csv import CSVReader
 from .sqlite import SqliteReader
 
+try:
+    from .mf4 import MF4Reader
+except ImportError:
+    # be careful when using MF4Writer, it might NameError
+    pass
+
 
 class LogReader(BaseIOHandler):
     """
@@ -59,6 +65,11 @@ def __new__(cls, filename: "can.typechecking.PathLike", *args, **kwargs):
             ".db": SqliteReader,
             ".log": CanutilsLogReader,
         }
+        try:
+            lookup[".mf4"] = MF4Reader
+        except NameError:
+            pass
+
         suffix = pathlib.PurePath(filename).suffix
         try:
             return lookup[suffix](filename, *args, **kwargs)
diff --git a/doc/listeners.rst b/doc/listeners.rst
index fcdc32f52..1830eaeed 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 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 the 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/setup.py b/setup.py
index d7d2feca6..3fd636fb9 100644
--- a/setup.py
+++ b/setup.py
@@ -13,10 +13,13 @@
 import re
 import logging
 import sys
+import platform
 from setuptools import setup, find_packages
 
 logging.basicConfig(level=logging.WARNING)
 
+IS_CPYTHON = platform.python_implementation() == "CPython"
+
 with open("can/__init__.py", "r") as fd:
     version = re.search(
         r'^__version__\s*=\s*[\'"]([^\'"]*)[\'"]', fd.read(), re.MULTILINE
@@ -28,11 +31,12 @@
 # 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"],
 }
 
-tests_require = [
+extras_require["test"] = [
     "pytest~=4.3",
     "pytest-timeout~=1.3",
     "pytest-cov~=2.6",
@@ -40,7 +44,9 @@
     "hypothesis",
 ] + extras_require["serial"]
 
-extras_require["test"] = tests_require
+# see GitHub issue #696: MF4 does not run on PyPy
+if IS_CPYTHON:
+    extras_require["test"] += extras_require["mf4"]
 
 # Check for 'pytest-runner' only if setup.py was invoked with 'test'.
 # This optimizes setup.py for cases when pytest-runner is not needed,
@@ -104,10 +110,10 @@
         "aenum",
         'windows-curses;platform_system=="Windows"',
         "filelock",
-        "mypy_extensions >= 0.4.0, < 0.5.0",
+        "mypy_extensions~=0.4.0",
         'pywin32;platform_system=="Windows"',
     ],
     setup_requires=pytest_runner,
     extras_require=extras_require,
-    tests_require=tests_require,
+    tests_require=extras_require["test"],
 )
diff --git a/test/logformats_test.py b/test/logformats_test.py
index 9983b0ecb..46dbcde67 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,28 @@ def _setup_instance(self):
         )
 
 
+try:
+    from can import MF4Writer, MF4Reader
+except ImportError:
+    # seems to unsupported on this platform
+    # see GitHub issue #696: MF4 does not run on PyPy
+    pass
+else:
+
+    class TestMF4FileFormat(ReaderWriterTest):
+        """Tests can.MF4Writer and can.MF4Reader"""
+
+        def _setup_instance(self):
+            super()._setup_instance_helper(
+                MF4Writer,
+                MF4Reader,
+                binary_file=True,
+                check_comments=False,
+                preserves_channel=False,
+                adds_default_channel=0,
+            )
+
+
 class TestSqliteDatabaseFormat(ReaderWriterTest):
     """Tests can.SqliteWriter and can.SqliteReader"""