diff --git a/src/gcodecommands.h b/src/gcodecommands.h
--- a/src/gcodecommands.h
+++ b/src/gcodecommands.h
@@ -137,4 +137,7 @@
      * @return Command String to send to printer
      */
     static QString toCommand(MCommands gcode, const QString &value1 = QString(), const QString &value2 = QString());
+private:
+    static const QString commandRequiresArgument;
 };
+
diff --git a/src/gcodecommands.cpp b/src/gcodecommands.cpp
--- a/src/gcodecommands.cpp
+++ b/src/gcodecommands.cpp
@@ -28,6 +28,8 @@
 
 #include "gcodecommands.h"
 
+const QString GCode::commandRequiresArgument = QObject::tr("This command requires an argument");
+
 QString GCode::toString(GCommands gcode)
 {
     switch (gcode) {
@@ -88,25 +90,17 @@
 
 QString GCode::toCommand(GCommands gcode, const QString &value1)
 {
+    QString msg;
     switch (gcode) {
-    case G0: {
-        if (value1.isEmpty()) {
-            return QStringLiteral("G0");
-        }
-        return QStringLiteral("G0 %1").arg(value1.toUpper());
-    }
-    case G1: {
-        if (value1.isEmpty()) {
-            return QStringLiteral("G1");
-        }
-        return QStringLiteral("G1 %1").arg(value1.toUpper());
-    }
-    case G28: {
-        if (value1.isEmpty()) {
-            return QStringLiteral("G28");
-        }
-        return QStringLiteral("G28 %1").arg(value1.toUpper());
-    }
+    case G0:
+        msg = value1.isEmpty() ? QStringLiteral("G0") : QStringLiteral("G0 %1").arg(value1.toUpper());
+        return msg;
+    case G1:
+        msg = value1.isEmpty() ? QStringLiteral("G1") : QStringLiteral("G1 %1").arg(value1.toUpper());
+        return msg;
+    case G28:
+        msg = value1.isEmpty() ? QStringLiteral("G28") : QStringLiteral("G28 %1").arg(value1.toUpper());
+        return msg;
     case G32:
         return QStringLiteral("G32 S1");
     case G90:
@@ -503,81 +497,51 @@
 
 QString GCode::toCommand(MCommands gcode, const QString &value1, const QString &value2)
 {
+    QString msg;
     switch (gcode) {
-    case M84: {
-        if (!value1.isEmpty()) {
-            return QStringLiteral("M84 S%1").arg(value1);
-        }
-        return QStringLiteral("M84");
-    }
-    case M104: {
-        if (!value2.isEmpty() && !value1.isEmpty()) {
-            return QStringLiteral("M104 P%1 S%2").arg(value1).arg(value2);
-        }
-        if (!value1.isEmpty()) {
-            return QStringLiteral("M104 S%1").arg(value1);
-        }
-        return QObject::tr("ERROR! M104: It's obligatory to have an argument");
-    }
+    case M84:
+        msg = value1.isEmpty() ? QStringLiteral("M84") : QStringLiteral("M84 S%1").arg(value1);
+        return msg;
+    case M104:
+        msg = value2.isEmpty() ? QStringLiteral("M104 S%1").arg(value1) : QStringLiteral("M104 P%1 S%2").arg(value1).arg(value2);
+        msg = value1.isEmpty() ? GCode::commandRequiresArgument : msg ;
+        return msg;
     case M105:
         return QStringLiteral("M105");
-    case M106: {
-        if (!value2.isEmpty() && !value1.isEmpty()) {
-            return QStringLiteral("M106 P%1 S%2").arg(value1).arg(value2);
-        }
-        if (!value1.isEmpty()) {
-            return QStringLiteral("M106 S%1").arg(value1);
-        }
-        return QStringLiteral("M106");
-    }
+    case M106:
+        msg = value2.isEmpty() ? QStringLiteral("M106 S%1").arg(value1) : QStringLiteral("M106 P%1 S%2").arg(value1).arg(value2);
+        msg = value1.isEmpty() ? QStringLiteral("M106") : msg;
+        return msg;
     case M107:
         return QStringLiteral("M107");
-    case M109: {
-        if (!value1.isEmpty()) {
-            return QStringLiteral("M109 S%1").arg(value1);
-        }
-        return QObject::tr("ERROR! M109: It's obligatory to have an argument");
-    }
+    case M109:
+        msg = value1.isEmpty() ? GCode::commandRequiresArgument : QStringLiteral("M109 S%1").arg(value1);
+        return msg;
     case M112:
         return QStringLiteral("M112");
     case M114:
         return QStringLiteral("M114");
     case M115:
         return QStringLiteral("M115");
     case M116:
         return QStringLiteral("M116");
-    case M117: {
-        if (!value1.isEmpty()) {
-            return QStringLiteral("M117 %1").arg(value1);
-        }
-        return QObject::tr("ERROR! M117: It's obligatory to have an argument");
-    }
+    case M117:
+        msg = value1.isEmpty() ? GCode::commandRequiresArgument : QStringLiteral("M117 %1").arg(value1);
+        return msg;
     case M119:
         return QStringLiteral("M119");
-    case M140: {
-        if (!value1.isEmpty()) {
-            return QStringLiteral("M140 S%1").arg(value1);
-        }
-        return QObject::tr("ERROR! M140: It's obligatory to have an argument");
-    }
-    case M190: {
-        if (!value1.isEmpty()) {
-            return QStringLiteral("M190 S%1").arg(value1);
-        }
-        return QObject::tr("ERROR! M190: It's obligatory to have an argument");
-    }
-    case M220: {
-        if (!value1.isEmpty()) {
-            return QStringLiteral("M220 S%1").arg(value1);
-        }
-        return QObject::tr("ERROR! M220: It's obligatory to have an argument");
-    }
-    case M221: {
-        if (!value1.isEmpty()) {
-            return QStringLiteral("M221 S%1").arg(value1);
-        }
-        return QObject::tr("ERROR! M221: It's obligatory to have an argument");
-    }
+    case M140:
+        msg = value1.isEmpty() ? GCode::commandRequiresArgument : QStringLiteral("M140 S%1").arg(value1);
+        return msg;
+    case M190:
+        msg = value1.isEmpty() ? GCode::commandRequiresArgument : QStringLiteral("M190 S%1").arg(value1);
+        return msg;
+    case M220:
+        msg = value1.isEmpty() ? GCode::commandRequiresArgument : QStringLiteral("M220 S%1").arg(value1);
+        return msg;
+    case M221:
+        msg = value1.isEmpty() ? GCode::commandRequiresArgument : QStringLiteral("M221 S%1").arg(value1);
+        return msg;
     default:
         return QObject::tr("Not supported or implemented!");
     }
diff --git a/unittests/gcodetests.cpp b/unittests/gcodetests.cpp
--- a/unittests/gcodetests.cpp
+++ b/unittests/gcodetests.cpp
@@ -191,7 +191,7 @@
 
 void GCodeTests::command_M104()
 {
-    QVERIFY(GCode::toCommand(GCode::M104) == QStringLiteral("ERROR! M104: It's obligatory to have an argument"));
+    QVERIFY(GCode::toCommand(GCode::M104) == QStringLiteral("This command requires an argument"));
     QVERIFY(GCode::toCommand(GCode::M104, QStringLiteral("100")) == QStringLiteral("M104 S100"));
     QVERIFY(GCode::toCommand(GCode::M104, QStringLiteral("3"), QStringLiteral("100")) == QStringLiteral("M104 P3 S100"));
 }
@@ -215,7 +215,7 @@
 
 void GCodeTests::command_M109()
 {
-    QVERIFY(GCode::toCommand(GCode::M109) == QStringLiteral("ERROR! M109: It's obligatory to have an argument"));
+    QVERIFY(GCode::toCommand(GCode::M109) == QStringLiteral("This command requires an argument"));
     QVERIFY(GCode::toCommand(GCode::M109, QStringLiteral("100")) == QStringLiteral("M109 S100"));
 }
 
@@ -241,7 +241,7 @@
 
 void GCodeTests::command_M117()
 {
-    QVERIFY(GCode::toCommand(GCode::M117) == QStringLiteral("ERROR! M117: It's obligatory to have an argument"));
+    QVERIFY(GCode::toCommand(GCode::M117) == QStringLiteral("This command requires an argument"));
     QVERIFY(GCode::toCommand(GCode::M117, QStringLiteral("100")) == QStringLiteral("M117 100"));
 }
 
@@ -252,25 +252,25 @@
 
 void GCodeTests::command_M140()
 {
-    QVERIFY(GCode::toCommand(GCode::M140) == QStringLiteral("ERROR! M140: It's obligatory to have an argument"));
+    QVERIFY(GCode::toCommand(GCode::M140) == QStringLiteral("This command requires an argument"));
     QVERIFY(GCode::toCommand(GCode::M140, QStringLiteral("100")) == QStringLiteral("M140 S100"));
 }
 
 void GCodeTests::command_M190()
 {
-    QVERIFY(GCode::toCommand(GCode::M190) == QStringLiteral("ERROR! M190: It's obligatory to have an argument"));
+    QVERIFY(GCode::toCommand(GCode::M190) == QStringLiteral("This command requires an argument"));
     QVERIFY(GCode::toCommand(GCode::M190, QStringLiteral("100")) == QStringLiteral("M190 S100"));
 }
 
 void GCodeTests::command_M220()
 {
-    QVERIFY(GCode::toCommand(GCode::M220) == QStringLiteral("ERROR! M220: It's obligatory to have an argument"));
+    QVERIFY(GCode::toCommand(GCode::M220) == QStringLiteral("This command requires an argument"));
     QVERIFY(GCode::toCommand(GCode::M220, QStringLiteral("100")) == QStringLiteral("M220 S100"));
 }
 
 void GCodeTests::command_M221()
 {
-    QVERIFY(GCode::toCommand(GCode::M221) == QStringLiteral("ERROR! M221: It's obligatory to have an argument"));
+    QVERIFY(GCode::toCommand(GCode::M221) == QStringLiteral("This command requires an argument"));
     QVERIFY(GCode::toCommand(GCode::M221, QStringLiteral("100")) == QStringLiteral("M221 S100"));
 }