diff --git a/master/datagram.c b/master/datagram.c
index 5f478c9692fcba5500a1162042c418273d4e1dfe..fabe9d6ac8517a7b320e534f00f416cfc9e4c395 100644
--- a/master/datagram.c
+++ b/master/datagram.c
@@ -500,6 +500,43 @@ int ec_datagram_lrw(
 
 /*****************************************************************************/
 
+/** Prints the state of a datagram.
+ *
+ * Outputs a text message.
+ */
+void ec_datagram_print_state(
+        const ec_datagram_t *datagram /**< EtherCAT datagram */
+        )
+{
+    printk("Datagram ");
+    switch (datagram->state) {
+        case EC_DATAGRAM_INIT:
+            printk("initialized");
+            break;
+        case EC_DATAGRAM_QUEUED:
+            printk("queued");
+            break;
+        case EC_DATAGRAM_SENT:
+            printk("sent");
+            break;
+        case EC_DATAGRAM_RECEIVED:
+            printk("received");
+            break;
+        case EC_DATAGRAM_TIMED_OUT:
+            printk("timed out");
+            break;
+        case EC_DATAGRAM_ERROR:
+            printk("error");
+            break;
+        default:
+            printk("???");
+    }
+
+    printk(".\n");
+}
+
+/*****************************************************************************/
+
 /** Evaluates the working counter of a single-cast datagram.
  *
  * Outputs an error message.
diff --git a/master/datagram.h b/master/datagram.h
index 42bba49fb03fa6de587d6c377b8a32f2e66eb39a..5e07c10ffcdb4e6816c41a67e66635f14e14da21 100644
--- a/master/datagram.h
+++ b/master/datagram.h
@@ -134,6 +134,7 @@ int ec_datagram_lrd(ec_datagram_t *, uint32_t, size_t, uint8_t *);
 int ec_datagram_lwr(ec_datagram_t *, uint32_t, size_t, uint8_t *);
 int ec_datagram_lrw(ec_datagram_t *, uint32_t, size_t, uint8_t *);
 
+void ec_datagram_print_state(const ec_datagram_t *);
 void ec_datagram_print_wc_error(const ec_datagram_t *);
 void ec_datagram_output_stats(ec_datagram_t *);
 const char *ec_datagram_type_string(const ec_datagram_t *);
diff --git a/master/fsm_change.c b/master/fsm_change.c
index 63bd62d39025d7dca49d9d14754b696ff1b3b6d6..9e299cb83b46aa98a9d64d70a75a996ad8f9f163 100644
--- a/master/fsm_change.c
+++ b/master/fsm_change.c
@@ -182,9 +182,9 @@ void ec_fsm_change_state_check(ec_fsm_change_t *fsm
 
     if (datagram->state != EC_DATAGRAM_RECEIVED) {
         fsm->state = ec_fsm_change_state_error;
-        EC_ERR("Failed to receive state datagram from slave %u"
-                " (datagram state %u)!\n",
-               fsm->slave->ring_position, datagram->state);
+        EC_ERR("Failed to receive state datagram from slave %u: ",
+               fsm->slave->ring_position);
+        ec_datagram_print_state(datagram);
         return;
     }
 
@@ -248,9 +248,9 @@ void ec_fsm_change_state_status(ec_fsm_change_t *fsm
 
     if (datagram->state != EC_DATAGRAM_RECEIVED) {
         fsm->state = ec_fsm_change_state_error;
-        EC_ERR("Failed to receive state checking datagram from slave %u"
-                " (datagram state %u).\n",
-               slave->ring_position, datagram->state);
+        EC_ERR("Failed to receive state checking datagram from slave %u: ",
+               slave->ring_position);
+        ec_datagram_print_state(datagram);
         return;
     }
 
@@ -386,9 +386,9 @@ void ec_fsm_change_state_code(ec_fsm_change_t *fsm
 
     if (datagram->state != EC_DATAGRAM_RECEIVED) {
         fsm->state = ec_fsm_change_state_error;
-        EC_ERR("Failed to receive AL status code datagram from slave %u"
-                " (datagram state %u).\n",
-               fsm->slave->ring_position, datagram->state);
+        EC_ERR("Failed to receive AL status code datagram from slave %u: ",
+               fsm->slave->ring_position);
+        ec_datagram_print_state(datagram);
         return;
     }
 
@@ -445,9 +445,9 @@ void ec_fsm_change_state_ack(ec_fsm_change_t *fsm /**< finite state machine */)
 
     if (datagram->state != EC_DATAGRAM_RECEIVED) {
         fsm->state = ec_fsm_change_state_error;
-        EC_ERR("Failed to receive state ack datagram for slave %u"
-                " (datagram state %u).\n",
-               slave->ring_position, datagram->state);
+        EC_ERR("Failed to receive state ack datagram for slave %u: ",
+               slave->ring_position);
+        ec_datagram_print_state(datagram);
         return;
     }
 
@@ -485,9 +485,9 @@ void ec_fsm_change_state_check_ack(ec_fsm_change_t *fsm
 
     if (datagram->state != EC_DATAGRAM_RECEIVED) {
         fsm->state = ec_fsm_change_state_error;
-        EC_ERR("Failed to receive state ack check datagram from slave %u"
-                " (datagram state %u).\n",
-               slave->ring_position, datagram->state);
+        EC_ERR("Failed to receive state ack check datagram from slave %u: ",
+               slave->ring_position);
+        ec_datagram_print_state(datagram);
         return;
     }
 
diff --git a/master/fsm_coe.c b/master/fsm_coe.c
index d29008650caed20b00049be3824085f9c1fc8cf4..fe338ce55dde908ef17c8ab75496cecb8cac863e 100644
--- a/master/fsm_coe.c
+++ b/master/fsm_coe.c
@@ -327,8 +327,8 @@ void ec_fsm_coe_dict_request(ec_fsm_coe_t *fsm /**< finite state machine */)
     if (datagram->state != EC_DATAGRAM_RECEIVED) {
         fsm->state = ec_fsm_coe_error;
         EC_ERR("Failed to receive CoE dictionary request datagram for"
-               " slave %u (datagram state %u).\n",
-               slave->ring_position, datagram->state);
+               " slave %u: ", slave->ring_position);
+        ec_datagram_print_state(datagram);
         return;
     }
 
@@ -363,9 +363,9 @@ void ec_fsm_coe_dict_check(ec_fsm_coe_t *fsm /**< finite state machine */)
 
     if (datagram->state != EC_DATAGRAM_RECEIVED) {
         fsm->state = ec_fsm_coe_error;
-        EC_ERR("Failed to receive CoE mailbox check datagram for slave %u"
-                " (datagram state %u).\n",
-               slave->ring_position, datagram->state);
+        EC_ERR("Failed to receive CoE mailbox check datagram for slave %u: ",
+               slave->ring_position);
+        ec_datagram_print_state(datagram);
         return;
     }
 
@@ -421,8 +421,8 @@ void ec_fsm_coe_dict_response(ec_fsm_coe_t *fsm /**< finite state machine */)
     if (datagram->state != EC_DATAGRAM_RECEIVED) {
         fsm->state = ec_fsm_coe_error;
         EC_ERR("Failed to receive CoE dictionary response datagram for"
-               " slave %u (datagram state %u).\n",
-               slave->ring_position, datagram->state);
+               " slave %u: ", slave->ring_position);
+        ec_datagram_print_state(datagram);
         return;
     }
 
@@ -572,8 +572,8 @@ void ec_fsm_coe_dict_desc_request(ec_fsm_coe_t *fsm /**< finite state machine */
     if (datagram->state != EC_DATAGRAM_RECEIVED) {
         fsm->state = ec_fsm_coe_error;
         EC_ERR("Failed to receive CoE SDO description request datagram for"
-               " slave %u (datagram state %u).\n",
-               slave->ring_position, datagram->state);
+               " slave %u: ", slave->ring_position);
+        ec_datagram_print_state(datagram);
         return;
     }
 
@@ -608,9 +608,9 @@ void ec_fsm_coe_dict_desc_check(ec_fsm_coe_t *fsm /**< finite state machine */)
 
     if (datagram->state != EC_DATAGRAM_RECEIVED) {
         fsm->state = ec_fsm_coe_error;
-        EC_ERR("Failed to receive CoE mailbox check datagram from slave %u"
-                " (datagram state %u).\n",
-                slave->ring_position, datagram->state);
+        EC_ERR("Failed to receive CoE mailbox check datagram from slave %u: ",
+                slave->ring_position);
+        ec_datagram_print_state(datagram);
         return;
     }
 
@@ -666,8 +666,8 @@ void ec_fsm_coe_dict_desc_response(ec_fsm_coe_t *fsm
     if (datagram->state != EC_DATAGRAM_RECEIVED) {
         fsm->state = ec_fsm_coe_error;
         EC_ERR("Failed to receive CoE SDO description response datagram from"
-               " slave %u (datagram state %u).\n",
-               slave->ring_position, datagram->state);
+               " slave %u: ", slave->ring_position);
+        ec_datagram_print_state(datagram);
         return;
     }
 
@@ -808,8 +808,8 @@ void ec_fsm_coe_dict_entry_request(ec_fsm_coe_t *fsm
     if (datagram->state != EC_DATAGRAM_RECEIVED) {
         fsm->state = ec_fsm_coe_error;
         EC_ERR("Failed to receive CoE SDO entry request datagram for"
-               " slave %u (datagram state %u).\n",
-               slave->ring_position, datagram->state);
+               " slave %u: ", slave->ring_position);
+        ec_datagram_print_state(datagram);
         return;
     }
 
@@ -846,8 +846,8 @@ void ec_fsm_coe_dict_entry_check(ec_fsm_coe_t *fsm
     if (datagram->state != EC_DATAGRAM_RECEIVED) {
         fsm->state = ec_fsm_coe_error;
         EC_ERR("Failed to receive CoE mailbox check datagram from slave %u"
-                " (datagram state %u).\n",
-               slave->ring_position, datagram->state);
+                ": ", slave->ring_position);
+        ec_datagram_print_state(datagram);
         return;
     }
 
@@ -905,8 +905,8 @@ void ec_fsm_coe_dict_entry_response(ec_fsm_coe_t *fsm
     if (datagram->state != EC_DATAGRAM_RECEIVED) {
         fsm->state = ec_fsm_coe_error;
         EC_ERR("Failed to receive CoE SDO description response datagram from"
-               " slave %u (datagram state %u).\n",
-               slave->ring_position, datagram->state);
+               " slave %u: ", slave->ring_position);
+        ec_datagram_print_state(datagram);
         return;
     }
 
@@ -1209,8 +1209,8 @@ void ec_fsm_coe_down_request(ec_fsm_coe_t *fsm /**< finite state machine */)
     if (datagram->state != EC_DATAGRAM_RECEIVED) {
         fsm->state = ec_fsm_coe_error;
         EC_ERR("Failed to receive CoE download request datagram for"
-               " slave %u (datagram state %u).\n",
-               slave->ring_position, datagram->state);
+               " slave %u: ", slave->ring_position);
+        ec_datagram_print_state(datagram);
         return;
     }
 
@@ -1270,9 +1270,9 @@ void ec_fsm_coe_down_check(ec_fsm_coe_t *fsm /**< finite state machine */)
 
     if (datagram->state != EC_DATAGRAM_RECEIVED) {
         fsm->state = ec_fsm_coe_error;
-        EC_ERR("Failed to receive CoE mailbox check datagram for slave %u"
-                " (datagram state %u).\n",
-               slave->ring_position, datagram->state);
+        EC_ERR("Failed to receive CoE mailbox check datagram for slave %u: ",
+                slave->ring_position);
+        ec_datagram_print_state(datagram);
         return;
     }
 
@@ -1391,8 +1391,8 @@ void ec_fsm_coe_down_response(ec_fsm_coe_t *fsm /**< finite state machine */)
     if (datagram->state != EC_DATAGRAM_RECEIVED) {
         fsm->state = ec_fsm_coe_error;
         EC_ERR("Failed to receive CoE download response datagram from"
-               " slave %u (datagram state %u).\n",
-               slave->ring_position, datagram->state);
+               " slave %u: ", slave->ring_position);
+        ec_datagram_print_state(datagram);
         return;
     }
 
@@ -1498,9 +1498,9 @@ void ec_fsm_coe_down_seg_check(ec_fsm_coe_t *fsm /**< finite state machine */)
 
     if (datagram->state != EC_DATAGRAM_RECEIVED) {
         fsm->state = ec_fsm_coe_error;
-        EC_ERR("Failed to receive CoE mailbox check datagram for slave %u"
-                " (datagram state %u).\n",
-               slave->ring_position, datagram->state);
+        EC_ERR("Failed to receive CoE mailbox check datagram for slave %u: ",
+               slave->ring_position);
+        ec_datagram_print_state(datagram);
         return;
     }
 
@@ -1556,8 +1556,8 @@ void ec_fsm_coe_down_seg_response(
     if (datagram->state != EC_DATAGRAM_RECEIVED) {
         fsm->state = ec_fsm_coe_error;
         EC_ERR("Failed to receive CoE download response datagram from"
-               " slave %u (datagram state %u).\n",
-               slave->ring_position, datagram->state);
+               " slave %u: ", slave->ring_position);
+        ec_datagram_print_state(datagram);
         return;
     }
 
@@ -1716,9 +1716,9 @@ void ec_fsm_coe_up_request(ec_fsm_coe_t *fsm /**< finite state machine */)
 
     if (datagram->state != EC_DATAGRAM_RECEIVED) {
         fsm->state = ec_fsm_coe_error;
-        EC_ERR("Failed to receive CoE upload request for slave %u"
-                " (datagram state %u).\n",
-               slave->ring_position, datagram->state);
+        EC_ERR("Failed to receive CoE upload request for slave %u: ",
+               slave->ring_position);
+        ec_datagram_print_state(datagram);
         return;
     }
 
@@ -1778,9 +1778,9 @@ void ec_fsm_coe_up_check(ec_fsm_coe_t *fsm /**< finite state machine */)
 
     if (datagram->state != EC_DATAGRAM_RECEIVED) {
         fsm->state = ec_fsm_coe_error;
-        EC_ERR("Failed to receive CoE mailbox check datagram from slave %u"
-                " (datagram state %u).\n",
-               slave->ring_position, datagram->state);
+        EC_ERR("Failed to receive CoE mailbox check datagram from slave %u: ",
+               slave->ring_position);
+        ec_datagram_print_state(datagram);
         return;
     }
 
@@ -1865,8 +1865,8 @@ void ec_fsm_coe_up_response(ec_fsm_coe_t *fsm /**< finite state machine */)
     if (datagram->state != EC_DATAGRAM_RECEIVED) {
         fsm->state = ec_fsm_coe_error;
         EC_ERR("Failed to receive CoE upload response datagram for"
-               " slave %u (datagram state %u).\n",
-               slave->ring_position, datagram->state);
+               " slave %u: ", slave->ring_position);
+        ec_datagram_print_state(datagram);
         return;
     }
 
@@ -2043,8 +2043,8 @@ void ec_fsm_coe_up_seg_request(ec_fsm_coe_t *fsm /**< finite state machine */)
     if (datagram->state != EC_DATAGRAM_RECEIVED) {
         fsm->state = ec_fsm_coe_error;
         EC_ERR("Failed to receive CoE upload segment request datagram for"
-               " slave %u (datagram state %u).\n",
-               slave->ring_position, datagram->state);
+               " slave %u: ", slave->ring_position);
+        ec_datagram_print_state(datagram);
         return;
     }
 
@@ -2079,9 +2079,9 @@ void ec_fsm_coe_up_seg_check(ec_fsm_coe_t *fsm /**< finite state machine */)
 
     if (datagram->state != EC_DATAGRAM_RECEIVED) {
         fsm->state = ec_fsm_coe_error;
-        EC_ERR("Failed to receive CoE mailbox check datagram for slave %u"
-                " (datagram state %u).\n",
-               slave->ring_position, datagram->state);
+        EC_ERR("Failed to receive CoE mailbox check datagram for slave %u: ",
+               slave->ring_position);
+        ec_datagram_print_state(datagram);
         return;
     }
 
@@ -2137,8 +2137,8 @@ void ec_fsm_coe_up_seg_response(ec_fsm_coe_t *fsm /**< finite state machine */)
     if (datagram->state != EC_DATAGRAM_RECEIVED) {
         fsm->state = ec_fsm_coe_error;
         EC_ERR("Failed to receive CoE upload segment response datagram for"
-               " slave %u (datagram state %u).\n",
-               slave->ring_position, datagram->state);
+               " slave %u: ", slave->ring_position);
+        ec_datagram_print_state(datagram);
         return;
     }
 
diff --git a/master/fsm_foe.c b/master/fsm_foe.c
index 15abffa2eebbdfa7915881a685335d56ff47c446..e655d1c281c4ae7f958703c7d4a1659f928977c9 100644
--- a/master/fsm_foe.c
+++ b/master/fsm_foe.c
@@ -333,9 +333,9 @@ void ec_fsm_foe_state_ack_check(
 
     if (datagram->state != EC_DATAGRAM_RECEIVED) {
         ec_foe_set_rx_error(fsm, FOE_RECEIVE_ERROR);
-        EC_ERR("Failed to receive FoE mailbox check datagram for slave %u"
-                " (datagram state %u).\n",
-               slave->ring_position, datagram->state);
+        EC_ERR("Failed to receive FoE mailbox check datagram for slave %u: ",
+               slave->ring_position);
+        ec_datagram_print_state(datagram);
         return;
     }
 
@@ -391,8 +391,8 @@ void ec_fsm_foe_state_ack_read(
     if (datagram->state != EC_DATAGRAM_RECEIVED) {
         ec_foe_set_rx_error(fsm, FOE_RECEIVE_ERROR);
         EC_ERR("Failed to receive FoE ack response datagram for"
-               " slave %u (datagram state %u).\n",
-               slave->ring_position, datagram->state);
+               " slave %u: ", slave->ring_position);
+        ec_datagram_print_state(datagram);
         return;
     }
 
@@ -468,9 +468,9 @@ void ec_fsm_foe_state_wrq_sent(
 
     if (datagram->state != EC_DATAGRAM_RECEIVED) {
         ec_foe_set_rx_error(fsm, FOE_RECEIVE_ERROR);
-        EC_ERR("Failed to send FoE WRQ for slave %u"
-                " (datagram state %u).\n",
-                slave->ring_position, datagram->state);
+        EC_ERR("Failed to send FoE WRQ for slave %u: ",
+                slave->ring_position);
+        ec_datagram_print_state(datagram);
         return;
     }
 
@@ -512,8 +512,8 @@ void ec_fsm_foe_state_data_sent(
     if (fsm->datagram->state != EC_DATAGRAM_RECEIVED) {
         ec_foe_set_tx_error(fsm, FOE_RECEIVE_ERROR);
         EC_ERR("Failed to receive FoE ack response datagram for"
-               " slave %u (datagram state %u).\n",
-               slave->ring_position, datagram->state);
+               " slave %u: ", slave->ring_position);
+        ec_datagram_print_state(datagram);
         return;
     }
 
@@ -602,9 +602,9 @@ void ec_fsm_foe_state_rrq_sent(
 
     if (datagram->state != EC_DATAGRAM_RECEIVED) {
         ec_foe_set_rx_error(fsm, FOE_RECEIVE_ERROR);
-        EC_ERR("Failed to send FoE RRQ for slave %u"
-                " (datagram state %u).\n",
-                slave->ring_position, datagram->state);
+        EC_ERR("Failed to send FoE RRQ for slave %u" ": ",
+                slave->ring_position);
+        ec_datagram_print_state(datagram);
         return;
     }
 
@@ -695,9 +695,9 @@ void ec_fsm_foe_state_data_check(
 
     if (datagram->state != EC_DATAGRAM_RECEIVED) {
         ec_foe_set_rx_error(fsm, FOE_RECEIVE_ERROR);
-        EC_ERR("Failed to send FoE DATA READ for slave %u"
-                " (datagram state %u).\n",
-                slave->ring_position, datagram->state);
+        EC_ERR("Failed to send FoE DATA READ for slave %u: ",
+                slave->ring_position);
+        ec_datagram_print_state(datagram);
         return;
     }
 
@@ -753,8 +753,8 @@ void ec_fsm_foe_state_data_read(
     if (datagram->state != EC_DATAGRAM_RECEIVED) {
         ec_foe_set_rx_error(fsm, FOE_RECEIVE_ERROR);
         EC_ERR("Failed to receive FoE DATA READ datagram for"
-               " slave %u (datagram state %u).\n",
-               slave->ring_position, datagram->state);
+               " slave %u: ", slave->ring_position);
+        ec_datagram_print_state(datagram);
         return;
     }
 
@@ -874,9 +874,9 @@ void ec_fsm_foe_state_sent_ack(
 
     if (datagram->state != EC_DATAGRAM_RECEIVED) {
         ec_foe_set_rx_error(fsm, FOE_RECEIVE_ERROR);
-        EC_ERR("Failed to send FoE ACK for slave %u"
-                " (datagram state %u).\n",
-                slave->ring_position, datagram->state);
+        EC_ERR("Failed to send FoE ACK for slave %u: ",
+                slave->ring_position);
+        ec_datagram_print_state(datagram);
         return;
     }
 
diff --git a/master/fsm_master.c b/master/fsm_master.c
index 47e33dd48a080abafdbf153e98697d26187c95f6..c17a3adb81ff9a01b7dc49c239fe141680fda1e3 100644
--- a/master/fsm_master.c
+++ b/master/fsm_master.c
@@ -607,9 +607,9 @@ void ec_fsm_master_state_read_state(
         return;
 
     if (datagram->state != EC_DATAGRAM_RECEIVED) {
-        EC_ERR("Failed to receive AL state datagram for slave %u"
-                " (datagram state %u)\n",
-                slave->ring_position, datagram->state);
+        EC_ERR("Failed to receive AL state datagram for slave %u: ",
+                slave->ring_position);
+        ec_datagram_print_state(datagram);
         ec_fsm_master_restart(fsm);
         return;
     }
diff --git a/master/fsm_sii.c b/master/fsm_sii.c
index 3ab8755385b74d538a9ff94389a6ea83bd13b48a..133dbafddcd0c86423a3bc108ad455b1930236a5 100644
--- a/master/fsm_sii.c
+++ b/master/fsm_sii.c
@@ -210,9 +210,9 @@ void ec_fsm_sii_state_read_check(
 
     if (datagram->state != EC_DATAGRAM_RECEIVED) {
         fsm->state = ec_fsm_sii_state_error;
-        EC_ERR("Failed to receive SII read datagram from slave %u"
-                " (datagram state %u).\n",
-               fsm->slave->ring_position, datagram->state);
+        EC_ERR("Failed to receive SII read datagram from slave %u: ",
+               fsm->slave->ring_position);
+        ec_datagram_print_state(datagram);
         return;
     }
 
@@ -259,9 +259,9 @@ void ec_fsm_sii_state_read_fetch(
 
     if (datagram->state != EC_DATAGRAM_RECEIVED) {
         fsm->state = ec_fsm_sii_state_error;
-        EC_ERR("Failed to receive SII check/fetch datagram from slave %u"
-                " (datagram state %u).\n",
-               fsm->slave->ring_position, datagram->state);
+        EC_ERR("Failed to receive SII check/fetch datagram from slave %u: ",
+               fsm->slave->ring_position);
+        ec_datagram_print_state(datagram);
         return;
     }
 
@@ -358,9 +358,9 @@ void ec_fsm_sii_state_write_check(
 
     if (datagram->state != EC_DATAGRAM_RECEIVED) {
         fsm->state = ec_fsm_sii_state_error;
-        EC_ERR("Failed to receive SII write datagram for slave %u"
-                " (datagram state %u).\n",
-               fsm->slave->ring_position, datagram->state);
+        EC_ERR("Failed to receive SII write datagram for slave %u: ",
+               fsm->slave->ring_position);
+        ec_datagram_print_state(datagram);
         return;
     }
 
@@ -400,9 +400,9 @@ void ec_fsm_sii_state_write_check2(
 
     if (datagram->state != EC_DATAGRAM_RECEIVED) {
         fsm->state = ec_fsm_sii_state_error;
-        EC_ERR("Failed to receive SII write check datagram from slave %u"
-                " (datagram state %u).\n",
-               fsm->slave->ring_position, datagram->state);
+        EC_ERR("Failed to receive SII write check datagram from slave %u: ",
+               fsm->slave->ring_position);
+        ec_datagram_print_state(datagram);
         return;
     }
 
diff --git a/master/fsm_slave_config.c b/master/fsm_slave_config.c
index 280a2d495aa4d331bf476dd8e975915b03c9140e..aa3f1ed7e5b95ad1d31bcc2b33b3b0685bd36eb7 100644
--- a/master/fsm_slave_config.c
+++ b/master/fsm_slave_config.c
@@ -419,9 +419,9 @@ void ec_fsm_slave_config_state_dc_read_offset(
 
     if (datagram->state != EC_DATAGRAM_RECEIVED) {
         fsm->state = ec_fsm_slave_config_state_error;
-        EC_ERR("Failed to receive DC times datagram for slave %u"
-                " (datagram state %u).\n",
-                slave->ring_position, datagram->state);
+        EC_ERR("Failed to receive DC times datagram for slave %u: ",
+                slave->ring_position);
+        ec_datagram_print_state(datagram);
         return;
     }
 
@@ -468,9 +468,9 @@ void ec_fsm_slave_config_state_dc_write_offset(
 
     if (datagram->state != EC_DATAGRAM_RECEIVED) {
         fsm->state = ec_fsm_slave_config_state_error;
-        EC_ERR("Failed to receive DC system time offset datagram for slave %u"
-                " (datagram state %u).\n",
-                slave->ring_position, datagram->state);
+        EC_ERR("Failed to receive DC system time offset datagram for"
+                " slave %u: ", slave->ring_position);
+        ec_datagram_print_state(datagram);
         return;
     }
 
@@ -636,8 +636,8 @@ void ec_fsm_slave_config_state_mbox_sync(
     if (datagram->state != EC_DATAGRAM_RECEIVED) {
         fsm->state = ec_fsm_slave_config_state_error;
         EC_ERR("Failed to receive sync manager configuration datagram for"
-               " slave %u (datagram state %u).\n",
-               slave->ring_position, datagram->state);
+               " slave %u: ", slave->ring_position);
+        ec_datagram_print_state(datagram);
         return;
     }
 
@@ -895,8 +895,8 @@ void ec_fsm_slave_config_state_watchdog_divider(
     if (datagram->state != EC_DATAGRAM_RECEIVED) {
         fsm->state = ec_fsm_slave_config_state_error;
         EC_ERR("Failed to receive watchdog divider configuration datagram for"
-               " slave %u (datagram state %u).\n",
-               slave->ring_position, datagram->state);
+               " slave %u: ", slave->ring_position);
+        ec_datagram_print_state(datagram);
         return;
     }
 
@@ -956,8 +956,8 @@ void ec_fsm_slave_config_state_watchdog(
     if (datagram->state != EC_DATAGRAM_RECEIVED) {
         fsm->state = ec_fsm_slave_config_state_error;
         EC_ERR("Failed to receive sync manager watchdog configuration "
-                "datagram for slave %u (datagram state %u).\n",
-                slave->ring_position, datagram->state);
+                "datagram for slave %u: ", slave->ring_position);
+        ec_datagram_print_state(datagram);
         return;
     }
 
@@ -1043,8 +1043,8 @@ void ec_fsm_slave_config_state_pdo_sync(
     if (datagram->state != EC_DATAGRAM_RECEIVED) {
         fsm->state = ec_fsm_slave_config_state_error;
         EC_ERR("Failed to receive process data sync manager configuration"
-               " datagram for slave %u (datagram state %u).\n",
-               slave->ring_position, datagram->state);
+               " datagram for slave %u: ", slave->ring_position);
+        ec_datagram_print_state(datagram);
         return;
     }
 
@@ -1130,9 +1130,9 @@ void ec_fsm_slave_config_state_fmmu(
 
     if (datagram->state != EC_DATAGRAM_RECEIVED) {
         fsm->state = ec_fsm_slave_config_state_error;
-        EC_ERR("Failed to receive FMMUs datagram for slave %u"
-                " (datagram state %u).\n",
-               slave->ring_position, datagram->state);
+        EC_ERR("Failed to receive FMMUs datagram for slave %u: ",
+               slave->ring_position);
+        ec_datagram_print_state(datagram);
         return;
     }
 
@@ -1214,9 +1214,9 @@ void ec_fsm_slave_config_state_dc_cycle(
 
     if (datagram->state != EC_DATAGRAM_RECEIVED) {
         fsm->state = ec_fsm_slave_config_state_error;
-        EC_ERR("Failed to receive DC cycle times datagram for slave %u"
-                " (datagram state %u).\n",
-                slave->ring_position, datagram->state);
+        EC_ERR("Failed to receive DC cycle times datagram for slave %u: ",
+                slave->ring_position);
+        ec_datagram_print_state(datagram);
         return;
     }
 
@@ -1292,9 +1292,9 @@ void ec_fsm_slave_config_state_dc_start(
 
     if (datagram->state != EC_DATAGRAM_RECEIVED) {
         fsm->state = ec_fsm_slave_config_state_error;
-        EC_ERR("Failed to receive DC start time datagram for slave %u"
-                " (datagram state %u).\n",
-                slave->ring_position, datagram->state);
+        EC_ERR("Failed to receive DC start time datagram for slave %u: ",
+                slave->ring_position);
+        ec_datagram_print_state(datagram);
         return;
     }
 
@@ -1334,9 +1334,9 @@ void ec_fsm_slave_config_state_dc_assign(
 
     if (datagram->state != EC_DATAGRAM_RECEIVED) {
         fsm->state = ec_fsm_slave_config_state_error;
-        EC_ERR("Failed to receive DC activation datagram for slave %u"
-                " (datagram state %u).\n",
-                slave->ring_position, datagram->state);
+        EC_ERR("Failed to receive DC activation datagram for slave %u: ",
+                slave->ring_position);
+        ec_datagram_print_state(datagram);
         return;
     }
 
diff --git a/master/fsm_slave_scan.c b/master/fsm_slave_scan.c
index fd2fe6c24308bc3cce7f6787daab8b729874f09a..065149a00c69a2976edb29d185ae56d9b83a441e 100644
--- a/master/fsm_slave_scan.c
+++ b/master/fsm_slave_scan.c
@@ -179,7 +179,9 @@ void ec_fsm_slave_scan_state_start(ec_fsm_slave_scan_t *fsm /**< slave state mac
    Slave scan state: ADDRESS.
 */
 
-void ec_fsm_slave_scan_state_address(ec_fsm_slave_scan_t *fsm /**< slave state machine */)
+void ec_fsm_slave_scan_state_address(
+        ec_fsm_slave_scan_t *fsm /**< slave state machine */
+        )
 {
     ec_datagram_t *datagram = fsm->datagram;
 
@@ -188,9 +190,9 @@ void ec_fsm_slave_scan_state_address(ec_fsm_slave_scan_t *fsm /**< slave state m
 
     if (datagram->state != EC_DATAGRAM_RECEIVED) {
         fsm->state = ec_fsm_slave_scan_state_error;
-        EC_ERR("Failed to receive station address datagram for slave %u"
-                " (datagram state %u)\n",
-                fsm->slave->ring_position, datagram->state);
+        EC_ERR("Failed to receive station address datagram for slave %u: ",
+                fsm->slave->ring_position);
+        ec_datagram_print_state(datagram);
         return;
     }
 
@@ -228,9 +230,9 @@ void ec_fsm_slave_scan_state_state(
 
     if (datagram->state != EC_DATAGRAM_RECEIVED) {
         fsm->state = ec_fsm_slave_scan_state_error;
-        EC_ERR("Failed to receive AL state datagram from slave %u"
-                " (datagram state %u).\n",
-               fsm->slave->ring_position, datagram->state);
+        EC_ERR("Failed to receive AL state datagram from slave %u: ",
+               fsm->slave->ring_position);
+        ec_datagram_print_state(datagram);
         return;
     }
 
@@ -276,9 +278,9 @@ void ec_fsm_slave_scan_state_base(
 
     if (datagram->state != EC_DATAGRAM_RECEIVED) {
         fsm->state = ec_fsm_slave_scan_state_error;
-        EC_ERR("Failed to receive base data datagram for slave %u"
-                " (datagram state %u).\n",
-               slave->ring_position, datagram->state);
+        EC_ERR("Failed to receive base data datagram for slave %u: ",
+               slave->ring_position);
+        ec_datagram_print_state(datagram);
         return;
     }
 
@@ -351,9 +353,9 @@ void ec_fsm_slave_scan_state_dc_cap(
 
     if (datagram->state != EC_DATAGRAM_RECEIVED) {
         fsm->state = ec_fsm_slave_scan_state_error;
-        EC_ERR("Failed to receive system time datagram for slave %u"
-                " (datagram state %u).\n",
-               slave->ring_position, datagram->state);
+        EC_ERR("Failed to receive system time datagram for slave %u: ",
+               slave->ring_position);
+        ec_datagram_print_state(datagram);
         return;
     }
 
@@ -403,9 +405,9 @@ void ec_fsm_slave_scan_state_dc_times(
 
     if (datagram->state != EC_DATAGRAM_RECEIVED) {
         fsm->state = ec_fsm_slave_scan_state_error;
-        EC_ERR("Failed to receive system time datagram for slave %u"
-                " (datagram state %u).\n",
-               slave->ring_position, datagram->state);
+        EC_ERR("Failed to receive system time datagram for slave %u: ",
+               slave->ring_position);
+        ec_datagram_print_state(datagram);
         return;
     }
 
@@ -463,9 +465,9 @@ void ec_fsm_slave_scan_state_datalink(ec_fsm_slave_scan_t *fsm /**< slave state
 
     if (datagram->state != EC_DATAGRAM_RECEIVED) {
         fsm->state = ec_fsm_slave_scan_state_error;
-        EC_ERR("Failed to receive DL status datagram from slave %u"
-                " (datagram state %u).\n",
-               slave->ring_position, datagram->state);
+        EC_ERR("Failed to receive DL status datagram from slave %u: ",
+               slave->ring_position);
+        ec_datagram_print_state(datagram);
         return;
     }
 
@@ -763,9 +765,9 @@ void ec_fsm_slave_scan_state_regalias(
 
     if (datagram->state != EC_DATAGRAM_RECEIVED) {
         fsm->state = ec_fsm_slave_scan_state_error;
-        EC_ERR("Failed to receive get reg alias datagram from slave %u"
-                " (datagram state %u).\n",
-               fsm->slave->ring_position, datagram->state);
+        EC_ERR("Failed to receive get reg alias datagram from slave %u: ",
+               fsm->slave->ring_position);
+        ec_datagram_print_state(datagram);
         return;
     }
 
@@ -860,8 +862,8 @@ void ec_fsm_slave_scan_state_sync(
     if (datagram->state != EC_DATAGRAM_RECEIVED) {
         fsm->state = ec_fsm_slave_scan_state_error;
         EC_ERR("Failed to receive sync manager configuration datagram"
-                " from slave %u (datagram state %u).\n",
-               slave->ring_position, datagram->state);
+                " from slave %u: ", slave->ring_position);
+        ec_datagram_print_state(datagram);
         return;
     }
 
diff --git a/master/voe_handler.c b/master/voe_handler.c
index c18298eb2a0dca4ef78bdfb1fa33506a5a2760a3..7017b890d517037bdec848d6ee21310557e6aea5 100644
--- a/master/voe_handler.c
+++ b/master/voe_handler.c
@@ -257,8 +257,8 @@ void ec_voe_handler_state_write_response(ec_voe_handler_t *voe)
         voe->state = ec_voe_handler_state_error;
         voe->request_state = EC_INT_REQUEST_FAILURE;
         EC_ERR("Failed to receive VoE write request datagram for"
-               " slave %u (datagram state %u).\n",
-               slave->ring_position, datagram->state);
+               " slave %u: ", slave->ring_position);
+        ec_datagram_print_state(datagram);
         return;
     }
 
@@ -332,9 +332,9 @@ void ec_voe_handler_state_read_check(ec_voe_handler_t *voe)
     if (datagram->state != EC_DATAGRAM_RECEIVED) {
         voe->state = ec_voe_handler_state_error;
         voe->request_state = EC_INT_REQUEST_FAILURE;
-        EC_ERR("Failed to receive VoE mailbox check datagram from slave %u"
-                " (datagram state %u).\n",
-               slave->ring_position, datagram->state);
+        EC_ERR("Failed to receive VoE mailbox check datagram from slave %u: ",
+               slave->ring_position);
+        ec_datagram_print_state(datagram);
         return;
     }
 
@@ -388,8 +388,8 @@ void ec_voe_handler_state_read_response(ec_voe_handler_t *voe)
         voe->state = ec_voe_handler_state_error;
         voe->request_state = EC_INT_REQUEST_FAILURE;
         EC_ERR("Failed to receive VoE read datagram for"
-               " slave %u (datagram state %u).\n",
-               slave->ring_position, datagram->state);
+               " slave %u: ", slave->ring_position);
+        ec_datagram_print_state(datagram);
         return;
     }
 
@@ -480,8 +480,8 @@ void ec_voe_handler_state_read_nosync_response(ec_voe_handler_t *voe)
         voe->state = ec_voe_handler_state_error;
         voe->request_state = EC_INT_REQUEST_FAILURE;
         EC_ERR("Failed to receive VoE read datagram for"
-               " slave %u (datagram state %u).\n",
-               slave->ring_position, datagram->state);
+               " slave %u: ", slave->ring_position);
+        ec_datagram_print_state(datagram);
         return;
     }