print parameters checking

Firmware/Configuration.h

@@ -15,6 +15,9 @@
 #define FW_REPOSITORY "Unknown"
 #define FW_VERSION_FULL FW_VERSION "-" STR(FW_COMMIT_NR)
 
+// G-code language level
+#define GCODE_LEVEL 1
+
 // Debug version has debugging enabled (the symbol DEBUG_BUILD is set).
 // The debug build may be a bit slower than the non-debug build, therefore the debug build should
 // not be shipped to a customer.

Firmware/Marlin_main.cpp

@@ -3654,7 +3654,7 @@ void process_commands()
 
 //-//
 /*
-    } else if(code_seen("qqq")) {
+    } else if(code_seen("rrr")) {
 MYSERIAL.println("=== checking ===");
 MYSERIAL.println(eeprom_read_byte((uint8_t*)EEPROM_CHECK_MODE),DEC);
 MYSERIAL.println(eeprom_read_byte((uint8_t*)EEPROM_NOZZLE_DIAMETER),DEC);
@@ -3676,13 +3676,47 @@ eeprom_update_word((uint16_t*)EEPROM_NOZZLE_DIAMETER_uM,0xFFFF);
                }
           else if(code_seen("set") && farm_mode)
                {
+               strchr_pointer++;                  // skip 1st char (~ 's')
                strchr_pointer++;                  // skip 2nd char (~ 'e')
-               strchr_pointer++;                  // skip 3rd char (~ 't')
                nDiameter=(uint16_t)(code_value()*1000.0+0.5); // [,um]
-               eeprom_update_byte((uint8_t*)EEPROM_NOZZLE_DIAMETER,(uint8_t)e_NOZZLE_DIAMETER_NULL); // for correct synchronization after farm-mode exiting
+               eeprom_update_byte((uint8_t*)EEPROM_NOZZLE_DIAMETER,(uint8_t)ClNozzleDiameter::_Diameter_Undef); // for correct synchronization after farm-mode exiting
                eeprom_update_word((uint16_t*)EEPROM_NOZZLE_DIAMETER_uM,nDiameter);
                }
           else SERIAL_PROTOCOLLN((float)eeprom_read_word((uint16_t*)EEPROM_NOZZLE_DIAMETER_uM)/1000.0);
+
+//-// !!! SupportMenu
+/*
+// musi byt PRED "PRUSA model"
+    } else if (code_seen("smodel")) { //! PRUSA smodel
+          size_t nOffset;
+// ! -> "l"
+          strchr_pointer+=5*sizeof(*strchr_pointer); // skip 1st - 5th char (~ 'smode')
+          nOffset=strspn(strchr_pointer+1," \t\n\r\v\f");
+          if(*(strchr_pointer+1+nOffset))
+               printer_smodel_check(strchr_pointer);
+          else SERIAL_PROTOCOLLN(PRINTER_NAME);
+    } else if (code_seen("model")) { //! PRUSA model
+          uint16_t nPrinterModel;
+          strchr_pointer+=4*sizeof(*strchr_pointer); // skip 1st - 4th char (~ 'mode')
+          nPrinterModel=(uint16_t)code_value_long();
+          if(nPrinterModel!=0)
+               printer_model_check(nPrinterModel);
+          else SERIAL_PROTOCOLLN(PRINTER_TYPE);
+    } else if (code_seen("version")) { //! PRUSA version
+          strchr_pointer+=7*sizeof(*strchr_pointer); // skip 1st - 7th char (~ 'version')
+          while(*strchr_pointer==' ')             // skip leading spaces
+               strchr_pointer++;
+          if(*strchr_pointer!=0)
+               fw_version_check(strchr_pointer);
+          else SERIAL_PROTOCOLLN(FW_VERSION);
+    } else if (code_seen("gcode")) { //! PRUSA gcode
+          uint16_t nGcodeLevel;
+          strchr_pointer+=4*sizeof(*strchr_pointer); // skip 1st - 4th char (~ 'gcod')
+          nGcodeLevel=(uint16_t)code_value_long();
+          if(nGcodeLevel!=0)
+               gcode_level_check(nGcodeLevel);
+          else SERIAL_PROTOCOLLN(GCODE_LEVEL);
+*/
 	}	
     //else if (code_seen('Cal')) {
 		//  lcd_calibration();
@@ -6847,6 +6881,63 @@ if((eSoundMode==e_SOUND_MODE_LOUD)||(eSoundMode==e_SOUND_MODE_ONCE))
 
 #endif //PINDA_THERMISTOR
 
+    case 862: // M862: print checking
+          float nDummy;
+          uint8_t nCommand;
+          nCommand=(uint8_t)(modff(code_value_float(),&nDummy)*10.0+0.5);
+          switch((ClPrintChecking)nCommand)
+               {
+               case ClPrintChecking::_Nozzle:     // ~ .1
+                    uint16_t nDiameter;
+                    if(code_seen('P'))
+                         {
+                         nDiameter=(uint16_t)(code_value()*1000.0+0.5); // [,um]
+                         nozzle_diameter_check(nDiameter);
+                         }
+                    else if(code_seen('S')&&farm_mode)
+                         {
+                         nDiameter=(uint16_t)(code_value()*1000.0+0.5); // [,um]
+                         eeprom_update_byte((uint8_t*)EEPROM_NOZZLE_DIAMETER,(uint8_t)ClNozzleDiameter::_Diameter_Undef); // for correct synchronization after farm-mode exiting
+                         eeprom_update_word((uint16_t*)EEPROM_NOZZLE_DIAMETER_uM,nDiameter);
+                         }
+                    else if(code_seen('Q'))
+                         SERIAL_PROTOCOLLN((float)eeprom_read_word((uint16_t*)EEPROM_NOZZLE_DIAMETER_uM)/1000.0);
+                    break;
+               case ClPrintChecking::_Model:      // ~ .2
+                    if(code_seen('P'))
+                         {
+                         uint16_t nPrinterModel;
+                         nPrinterModel=(uint16_t)code_value_long();
+                         printer_model_check(nPrinterModel);
+                         }
+                    else if(code_seen('Q'))
+                         SERIAL_PROTOCOLLN(PRINTER_TYPE);
+                    break;
+               case ClPrintChecking::_Smodel:     // ~ .3
+                    if(code_seen('P'))
+                         printer_smodel_check(strchr_pointer);
+                    else if(code_seen('Q'))
+                         SERIAL_PROTOCOLLN(PRINTER_NAME);
+                    break;
+               case ClPrintChecking::_Version:    // ~ .4
+                    if(code_seen('P'))
+                         fw_version_check(++strchr_pointer);
+                    else if(code_seen('Q'))
+                         SERIAL_PROTOCOLLN(FW_VERSION);
+                    break;
+               case ClPrintChecking::_Gcode:      // ~ .5
+                    if(code_seen('P'))
+                         {
+                         uint16_t nGcodeLevel;
+                         nGcodeLevel=(uint16_t)code_value_long();
+                         gcode_level_check(nGcodeLevel);
+                         }
+                    else if(code_seen('Q'))
+                         SERIAL_PROTOCOLLN(GCODE_LEVEL);
+                    break;
+               }
+    break;
+
 #ifdef LIN_ADVANCE
     case 900: // M900: Set LIN_ADVANCE options.
         gcode_M900();

Firmware/eeprom.h

@@ -1,6 +1,7 @@
 #ifndef EEPROM_H
 #define EEPROM_H
 
+#define EEPROM_EMPTY_VALUE 0xFF
 // The total size of the EEPROM is
 // 4096 for the Atmega2560
 #define EEPROM_TOP 4096
@@ -166,6 +167,9 @@
 #define EEPROM_CHECK_MODE (EEPROM_MMU_STEALTH-1) // uint8
 #define EEPROM_NOZZLE_DIAMETER (EEPROM_CHECK_MODE-1) // uint8
 #define EEPROM_NOZZLE_DIAMETER_uM (EEPROM_NOZZLE_DIAMETER-2) // uint16
+#define EEPROM_CHECK_MODEL (EEPROM_NOZZLE_DIAMETER_uM-1) // uint8
+#define EEPROM_CHECK_VERSION (EEPROM_CHECK_MODEL-1) // uint8
+#define EEPROM_CHECK_GCODE (EEPROM_CHECK_VERSION-1) // uint8
 
 // !!!!!
 // !!!!! this is end of EEPROM section ... all updates MUST BE inserted before this mark !!!!!

Firmware/printers.h

@@ -3,14 +3,23 @@
 
 #define PRINTER_UNKNOWN 0
 
-#define PRINTER_MK1         100
-#define PRINTER_MK2         200
-#define PRINTER_MK2_SNMM    201
-#define PRINTER_MK25        250
-#define PRINTER_MK25_SNMM   251
-#define PRINTER_MK25S		252
-#define PRINTER_MK3         300
-#define PRINTER_MK3_SNMM    301
-#define PRINTER_MK3S		302
+#define PRINTER_MK1           100
+#define PRINTER_MK2           200
+#define PRINTER_MK2_SNMM      201
+#define PRINTER_MK25          250
+#define PRINTER_MK25_SNMM      251
+#define PRINTER_MK25S	     	252
+
+#define PRINTER_MK3              300
+#define PRINTER_MK3_NAME           "MK3"
+#define PRINTER_MK3_SNMM           301
+
+#define PRINTER_MK3_MMU2         20300
+#define PRINTER_MK3_MMU2_NAME     "MK3MMU2"
+
+#define PRINTER_MK3S     		302
+#define PRINTER_MK3S_NAME         "MK3S"
+#define PRINTER_MK3S_MMU2         20302
+#define PRINTER_MK3S_MMU2_NAME     "MK3SMMU2S"
 
 #endif //PRINTERS_H

Firmware/ultralcd.cpp

@@ -5288,95 +5288,218 @@ while (0)
 //-//
 static void lcd_check_mode_set(void)
 {
-switch(eCheckMode)
+switch(oCheckMode)
      {
-     case e_CHECK_MODE_none:
-          eCheckMode=e_CHECK_MODE_warn;
+     case ClCheckMode::_None:
+          oCheckMode=ClCheckMode::_Warn;
           break;
-     case e_CHECK_MODE_warn:
-          eCheckMode=e_CHECK_MODE_strict;
+     case ClCheckMode::_Warn:
+          oCheckMode=ClCheckMode::_Strict;
           break;
-     case e_CHECK_MODE_strict:
-          eCheckMode=e_CHECK_MODE_none;
+     case ClCheckMode::_Strict:
+          oCheckMode=ClCheckMode::_None;
           break;
      default:
-          eCheckMode=e_CHECK_MODE_none;
+          oCheckMode=ClCheckMode::_None;
      }
-eeprom_update_byte((uint8_t*)EEPROM_CHECK_MODE,(uint8_t)eCheckMode);
+eeprom_update_byte((uint8_t*)EEPROM_CHECK_MODE,(uint8_t)oCheckMode);
 }
 
+#define SETTINGS_MODE \
+do\
+{\
+    switch(oCheckMode)\
+         {\
+         case ClCheckMode::_None:\
+              MENU_ITEM_FUNCTION_P(_i("Nozzle Ch. [none]"),lcd_check_mode_set);\
+              break;\
+         case ClCheckMode::_Warn:\
+              MENU_ITEM_FUNCTION_P(_i("Nozzle Ch. [warn]"),lcd_check_mode_set);\
+              break;\
+         case ClCheckMode::_Strict:\
+              MENU_ITEM_FUNCTION_P(_i("Nozzle Ch[strict]"),lcd_check_mode_set);\
+              break;\
+         default:\
+              MENU_ITEM_FUNCTION_P(_i("Nozzle Ch. [none]"),lcd_check_mode_set);\
+         }\
+}\
+while (0)
+
 static void lcd_nozzle_diameter_set(void)
 {
 uint16_t nDiameter;
 
-switch(eNozzleDiameter)
+switch(oNozzleDiameter)
      {
-     case e_NOZZLE_DIAMETER_250:
-          eNozzleDiameter=e_NOZZLE_DIAMETER_400;
+     case ClNozzleDiameter::_Diameter_250:
+          oNozzleDiameter=ClNozzleDiameter::_Diameter_400;
           nDiameter=400;
           break;
-     case e_NOZZLE_DIAMETER_400:
-          eNozzleDiameter=e_NOZZLE_DIAMETER_600;
+     case ClNozzleDiameter::_Diameter_400:
+          oNozzleDiameter=ClNozzleDiameter::_Diameter_600;
           nDiameter=600;
           break;
-     case e_NOZZLE_DIAMETER_600:
-          eNozzleDiameter=e_NOZZLE_DIAMETER_250;
+     case ClNozzleDiameter::_Diameter_600:
+          oNozzleDiameter=ClNozzleDiameter::_Diameter_250;
           nDiameter=250;
           break;
      default:
-          eNozzleDiameter=e_NOZZLE_DIAMETER_400;
+          oNozzleDiameter=ClNozzleDiameter::_Diameter_400;
           nDiameter=400;
      }
-eeprom_update_byte((uint8_t*)EEPROM_NOZZLE_DIAMETER,(uint8_t)eNozzleDiameter);
+eeprom_update_byte((uint8_t*)EEPROM_NOZZLE_DIAMETER,(uint8_t)oNozzleDiameter);
 eeprom_update_word((uint16_t*)EEPROM_NOZZLE_DIAMETER_uM,nDiameter);
 }
 
-#define SETTINGS_MODE \
+#define SETTINGS_NOZZLE \
 do\
 {\
-    switch(eCheckMode)\
+    switch(oNozzleDiameter)\
          {\
-         case e_CHECK_MODE_none:\
-              MENU_ITEM_FUNCTION_P(_i("Action     [none]"),lcd_check_mode_set);\
+         case ClNozzleDiameter::_Diameter_250:\
+              MENU_ITEM_FUNCTION_P(_i("Nozzle d.  [0.25]"),lcd_nozzle_diameter_set);\
               break;\
-         case e_CHECK_MODE_warn:\
-              MENU_ITEM_FUNCTION_P(_i("Action     [warn]"),lcd_check_mode_set);\
+         case ClNozzleDiameter::_Diameter_400:\
+              MENU_ITEM_FUNCTION_P(_i("Nozzle d.  [0.40]"),lcd_nozzle_diameter_set);\
               break;\
-         case e_CHECK_MODE_strict:\
-              MENU_ITEM_FUNCTION_P(_i("Action   [strict]"),lcd_check_mode_set);\
+         case ClNozzleDiameter::_Diameter_600:\
+              MENU_ITEM_FUNCTION_P(_i("Nozzle d.  [0.60]"),lcd_nozzle_diameter_set);\
               break;\
          default:\
-              MENU_ITEM_FUNCTION_P(_i("Action     [none]"),lcd_check_mode_set);\
+              MENU_ITEM_FUNCTION_P(_i("Nozzle d.  [0.40]"),lcd_nozzle_diameter_set);\
          }\
 }\
 while (0)
 
-#define SETTINGS_NOZZLE \
+static void lcd_check_model_set(void)
+{
+switch(oCheckModel)
+     {
+     case ClCheckModel::_None:
+          oCheckModel=ClCheckModel::_Warn;
+          break;
+     case ClCheckModel::_Warn:
+          oCheckModel=ClCheckModel::_Strict;
+          break;
+     case ClCheckModel::_Strict:
+          oCheckModel=ClCheckModel::_None;
+          break;
+     default:
+          oCheckModel=ClCheckModel::_None;
+     }
+eeprom_update_byte((uint8_t*)EEPROM_CHECK_MODEL,(uint8_t)oCheckModel);
+}
+
+#define SETTINGS_MODEL \
 do\
 {\
-    switch(eNozzleDiameter)\
+    switch(oCheckModel)\
          {\
-         case e_NOZZLE_DIAMETER_250:\
-              MENU_ITEM_FUNCTION_P(_i("Nozzle     [0.25]"),lcd_nozzle_diameter_set);\
+         case ClCheckModel::_None:\
+              MENU_ITEM_FUNCTION_P(_i("Model Ch.  [none]"),lcd_check_model_set);\
               break;\
-         case e_NOZZLE_DIAMETER_400:\
-              MENU_ITEM_FUNCTION_P(_i("Nozzle     [0.40]"),lcd_nozzle_diameter_set);\
+         case ClCheckModel::_Warn:\
+              MENU_ITEM_FUNCTION_P(_i("Model Ch.  [warn]"),lcd_check_model_set);\
               break;\
-         case e_NOZZLE_DIAMETER_600:\
-              MENU_ITEM_FUNCTION_P(_i("Nozzle     [0.60]"),lcd_nozzle_diameter_set);\
+         case ClCheckModel::_Strict:\
+              MENU_ITEM_FUNCTION_P(_i("Model Ch.[strict]"),lcd_check_model_set);\
               break;\
          default:\
-              MENU_ITEM_FUNCTION_P(_i("Nozzle     [0.40]"),lcd_nozzle_diameter_set);\
+              MENU_ITEM_FUNCTION_P(_i("Model Ch.  [none]"),lcd_check_model_set);\
          }\
 }\
 while (0)
 
-static void lcd_checking_menu()
+static void lcd_check_version_set(void)
+{
+switch(oCheckVersion)
+     {
+     case ClCheckVersion::_None:
+          oCheckVersion=ClCheckVersion::_Warn;
+          break;
+     case ClCheckVersion::_Warn:
+          oCheckVersion=ClCheckVersion::_Strict;
+          break;
+     case ClCheckVersion::_Strict:
+          oCheckVersion=ClCheckVersion::_None;
+          break;
+     default:
+          oCheckVersion=ClCheckVersion::_None;
+     }
+eeprom_update_byte((uint8_t*)EEPROM_CHECK_VERSION,(uint8_t)oCheckVersion);
+}
+
+#define SETTINGS_VERSION \
+do\
+{\
+    switch(oCheckVersion)\
+         {\
+         case ClCheckVersion::_None:\
+              MENU_ITEM_FUNCTION_P(_i("FW Ch.     [none]"),lcd_check_version_set);\
+              break;\
+         case ClCheckVersion::_Warn:\
+              MENU_ITEM_FUNCTION_P(_i("FW Ch.     [warn]"),lcd_check_version_set);\
+              break;\
+         case ClCheckVersion::_Strict:\
+              MENU_ITEM_FUNCTION_P(_i("FW Ch.   [strict]"),lcd_check_version_set);\
+              break;\
+         default:\
+              MENU_ITEM_FUNCTION_P(_i("FW Ch.     [none]"),lcd_check_version_set);\
+         }\
+}\
+while (0)
+
+static void lcd_check_gcode_set(void)
+{
+switch(oCheckGcode)
+     {
+     case ClCheckGcode::_None:
+          oCheckGcode=ClCheckGcode::_Warn;
+          break;
+     case ClCheckGcode::_Warn:
+          oCheckGcode=ClCheckGcode::_Strict;
+          break;
+     case ClCheckGcode::_Strict:
+          oCheckGcode=ClCheckGcode::_None;
+          break;
+     default:
+          oCheckGcode=ClCheckGcode::_None;
+     }
+eeprom_update_byte((uint8_t*)EEPROM_CHECK_GCODE,(uint8_t)oCheckGcode);
+}
+
+#define SETTINGS_GCODE \
+do\
+{\
+    switch(oCheckGcode)\
+         {\
+         case ClCheckGcode::_None:\
+              MENU_ITEM_FUNCTION_P(_i("Gcode Ch.  [none]"),lcd_check_gcode_set);\
+              break;\
+         case ClCheckGcode::_Warn:\
+              MENU_ITEM_FUNCTION_P(_i("Gcode Ch.  [warn]"),lcd_check_gcode_set);\
+              break;\
+         case ClCheckGcode::_Strict:\
+              MENU_ITEM_FUNCTION_P(_i("Gcode Ch.[strict]"),lcd_check_gcode_set);\
+              break;\
+         default:\
+              MENU_ITEM_FUNCTION_P(_i("Gcode Ch.  [none]"),lcd_check_gcode_set);\
+         }\
+}\
+while (0)
+
+//static void lcd_checking_menu()
+void lcd_checking_menu()
 {
 MENU_BEGIN();
 MENU_ITEM_BACK_P(_T(MSG_SETTINGS));
-SETTINGS_MODE;
 SETTINGS_NOZZLE;
+MENU_ITEM_TEXT_P(STR_SEPARATOR);
+MENU_ITEM_TEXT_P(_i("Checks:"));
+SETTINGS_MODE;
+SETTINGS_MODEL;
+SETTINGS_VERSION;
+SETTINGS_GCODE;
 MENU_END();
 }
 
@@ -6489,7 +6612,8 @@ static void lcd_main_menu()
   if (mmu_enabled) {
 	  MENU_ITEM_SUBMENU_P(_i("Fail stats MMU"), lcd_menu_fails_stats_mmu);
   }
-  MENU_ITEM_SUBMENU_P(_i("Support"), lcd_support_menu);////MSG_SUPPORT
+//-//
+//  MENU_ITEM_SUBMENU_P(_i("Support"), lcd_support_menu);////MSG_SUPPORT
 #ifdef LCD_TEST
     MENU_ITEM_SUBMENU_P(_i("W25x20CL init"), lcd_test_menu);////MSG_SUPPORT
 #endif //LCD_TEST

Firmware/util.cpp

@@ -330,43 +330,244 @@ void update_current_firmware_version_to_eeprom()
 
 
 //-//
-eNOZZLE_DIAMETER eNozzleDiameter=e_NOZZLE_DIAMETER_400;
-eCHECK_MODE eCheckMode=e_CHECK_MODE_none;
+void lcd_checking_menu(void);
+
+ClNozzleDiameter oNozzleDiameter=ClNozzleDiameter::_Diameter_400;
+ClCheckMode oCheckMode=ClCheckMode::_None;
+ClCheckModel oCheckModel=ClCheckModel::_None;
+ClCheckVersion oCheckVersion=ClCheckVersion::_None;
+ClCheckGcode oCheckGcode=ClCheckGcode::_None;
 
 void fCheckModeInit()
 {
-eCheckMode=(eCHECK_MODE)eeprom_read_byte((uint8_t*)EEPROM_CHECK_MODE);
-if(eCheckMode==e_CHECK_MODE_NULL)
+oCheckMode=(ClCheckMode)eeprom_read_byte((uint8_t*)EEPROM_CHECK_MODE);
+if(oCheckMode==ClCheckMode::_Undef)
      {
-     eCheckMode=e_CHECK_MODE_warn;
-     eeprom_update_byte((uint8_t*)EEPROM_CHECK_MODE,(uint8_t)eCheckMode);
+     oCheckMode=ClCheckMode::_Warn;
+     eeprom_update_byte((uint8_t*)EEPROM_CHECK_MODE,(uint8_t)oCheckMode);
      }
 if(farm_mode)
-     eCheckMode=e_CHECK_MODE_strict;
-eNozzleDiameter=(eNOZZLE_DIAMETER)eeprom_read_byte((uint8_t*)EEPROM_NOZZLE_DIAMETER);
-if((eNozzleDiameter==e_NOZZLE_DIAMETER_NULL)&& !farm_mode)
+     oCheckMode=ClCheckMode::_Strict;
+oNozzleDiameter=(ClNozzleDiameter)eeprom_read_byte((uint8_t*)EEPROM_NOZZLE_DIAMETER);
+if((oNozzleDiameter==ClNozzleDiameter::_Diameter_Undef)&& !farm_mode)
      {
-     eNozzleDiameter=e_NOZZLE_DIAMETER_400;
-     eeprom_update_byte((uint8_t*)EEPROM_NOZZLE_DIAMETER,(uint8_t)eNozzleDiameter);
+     oNozzleDiameter=ClNozzleDiameter::_Diameter_400;
+     eeprom_update_byte((uint8_t*)EEPROM_NOZZLE_DIAMETER,(uint8_t)oNozzleDiameter);
      eeprom_update_word((uint16_t*)EEPROM_NOZZLE_DIAMETER_uM,400);
      }
+oCheckModel=(ClCheckModel)eeprom_read_byte((uint8_t*)EEPROM_CHECK_MODEL);
+if(oCheckModel==ClCheckModel::_Undef)
+     {
+     oCheckModel=ClCheckModel::_Warn;
+//     eeprom_update_byte((uint8_t*)EEPROM_CHECK_MODEL,(uint8_t)oCheckModel);
+     }
+oCheckVersion=(ClCheckVersion)eeprom_read_byte((uint8_t*)EEPROM_CHECK_VERSION);
+if(oCheckVersion==ClCheckVersion::_Undef)
+     {
+     oCheckVersion=ClCheckVersion::_Warn;
+//     eeprom_update_byte((uint8_t*)EEPROM_CHECK_VERSION,(uint8_t)oCheckVersion);
+     }
+oCheckGcode=(ClCheckGcode)eeprom_read_byte((uint8_t*)EEPROM_CHECK_GCODE);
+if(oCheckGcode==ClCheckGcode::_Undef)
+     {
+     oCheckGcode=ClCheckGcode::_Warn;
+//     eeprom_update_byte((uint8_t*)EEPROM_CHECK_GCODE,(uint8_t)oCheckGcode);
+     }
 }
 
 void nozzle_diameter_check(uint16_t nDiameter)
 {
 uint16_t nDiameter_um;
 
+if(oCheckMode==ClCheckMode::_None)
+     return;
 nDiameter_um=eeprom_read_word((uint16_t*)EEPROM_NOZZLE_DIAMETER_uM);
 if(nDiameter==nDiameter_um)
      return;
-switch(eCheckMode)
+SERIAL_ECHO_START;
+SERIAL_ECHOLNPGM("Nozzle diameter doesn't match ...");
+SERIAL_ECHOPGM("actual  : ");
+SERIAL_ECHOLN((float)(nDiameter_um/1000.0));
+SERIAL_ECHOPGM("expected: ");
+SERIAL_ECHOLN((float)(nDiameter/1000.0));
+switch(oCheckMode)
      {
-     case e_CHECK_MODE_warn:
+     case ClCheckMode::_Warn:
           lcd_show_fullscreen_message_and_wait_P(_i("Nozzle diameter doesn't match! Press the knob to continue."));
           break;
-     case e_CHECK_MODE_strict:
+     case ClCheckMode::_Strict:
           lcd_show_fullscreen_message_and_wait_P(_i("Nozzle diameter doesn't match! Print is aborted, press the knob."));
           lcd_print_stop();
           break;
      }
+menu_submenu(lcd_checking_menu);
+}
+
+void printer_model_check(uint16_t nPrinterModel)
+{
+if(oCheckModel==ClCheckModel::_None)
+     return;
+if(nPrinterModel==(uint16_t)PRINTER_TYPE)
+     return;
+SERIAL_ECHO_START;
+SERIAL_ECHOLNPGM("Printer model doesn't match ...");
+SERIAL_ECHOPGM("actual  : ");
+SERIAL_ECHOLN(PRINTER_TYPE);
+SERIAL_ECHOPGM("expected: ");
+SERIAL_ECHOLN(nPrinterModel);
+switch(oCheckModel)
+     {
+     case ClCheckModel::_Warn:
+          lcd_show_fullscreen_message_and_wait_P(_i("Printer model doesn't match! Press the knob to continue."));
+          break;
+     case ClCheckModel::_Strict:
+          lcd_show_fullscreen_message_and_wait_P(_i("Printer model doesn't match! Print is aborted, press the knob."));
+          lcd_print_stop();
+          break;
+     }
+}
+
+int8_t mCmp(uint16_t nX,uint16_t nY)
+{
+if(nX>nY)
+     return(1);
+if(nX<nY)
+     return(-1);
+return(0);
+}
+
+void fw_version_check(const char *pVersion)
+{
+uint16_t aVersion[4];
+bool bMatch;
+parse_version(pVersion,aVersion);
+
+if(oCheckVersion==ClCheckVersion::_None)
+     return;
+bMatch=(aVersion[0]==eeprom_read_word((uint16_t*)EEPROM_FIRMWARE_VERSION_MAJOR));
+bMatch=bMatch&&(aVersion[1]==eeprom_read_word((uint16_t*)EEPROM_FIRMWARE_VERSION_MINOR));
+bMatch=bMatch&&(aVersion[2]==eeprom_read_word((uint16_t*)EEPROM_FIRMWARE_VERSION_REVISION));
+bMatch=bMatch&&(aVersion[3]==eeprom_read_word((uint16_t*)EEPROM_FIRMWARE_VERSION_FLAVOR));
+if(bMatch)
+     return;
+
+bMatch=(aVersion[0]>eeprom_read_word((uint16_t*)EEPROM_FIRMWARE_VERSION_MAJOR));
+bMatch=!bMatch||(aVersion[1]>eeprom_read_word((uint16_t*)EEPROM_FIRMWARE_VERSION_MINOR));
+bMatch=!bMatch||(aVersion[2]>eeprom_read_word((uint16_t*)EEPROM_FIRMWARE_VERSION_REVISION));
+bMatch=!bMatch||(aVersion[3]>eeprom_read_word((uint16_t*)EEPROM_FIRMWARE_VERSION_FLAVOR));
+if(!bMatch&&oCheckVersion==ClCheckVersion::_Warn)
+     return;
+/*
+if((aVersion[0]<eeprom_read_word((uint16_t*)EEPROM_FIRMWARE_VERSION_MAJOR))&&(oCheckVersion==ClCheckVersion::_Warn))
+     return;
+else if((aVersion[1]<eeprom_read_word((uint16_t*)EEPROM_FIRMWARE_VERSION_MINOR))&&(oCheckVersion==ClCheckVersion::_Warn))
+     return;
+else if((aVersion[2]<eeprom_read_word((uint16_t*)EEPROM_FIRMWARE_VERSION_REVISION))&&(oCheckVersion==ClCheckVersion::_Warn))
+     return;
+else if((aVersion[3]<eeprom_read_word((uint16_t*)EEPROM_FIRMWARE_VERSION_FLAVOR))&&(oCheckVersion==ClCheckVersion::_Warn))
+     return;
+*/
+
+SERIAL_ECHO_START;
+SERIAL_ECHOLNPGM("FW version doesn't match ...");
+SERIAL_ECHOPGM("actual  : ");
+SERIAL_ECHOLN(FW_VERSION);
+SERIAL_ECHOPGM("expected: ");
+SERIAL_ECHOLN(pVersion);
+switch(oCheckVersion)
+     {
+     case ClCheckVersion::_Warn:
+          lcd_show_fullscreen_message_and_wait_P(_i("FW version doesn't match! Press the knob to continue."));
+          break;
+     case ClCheckVersion::_Strict:
+          lcd_show_fullscreen_message_and_wait_P(_i("FW version doesn't match! Print is aborted, press the knob."));
+          lcd_print_stop();
+          break;
+     }
+}
+
+void gcode_level_check(uint16_t nGcodeLevel)
+{
+if(oCheckGcode==ClCheckGcode::_None)
+     return;
+if(nGcodeLevel==(uint16_t)GCODE_LEVEL)
+     return;
+if((nGcodeLevel<(uint16_t)GCODE_LEVEL)&&(oCheckGcode==ClCheckGcode::_Warn))
+     return;
+if(oCheckGcode==ClCheckGcode::_None)
+     return;
+SERIAL_ECHO_START;
+SERIAL_ECHOLNPGM("G-code level doesn't match ...");
+SERIAL_ECHOPGM("actual  : ");
+SERIAL_ECHOLN(GCODE_LEVEL);
+SERIAL_ECHOPGM("expected: ");
+SERIAL_ECHOLN(nGcodeLevel);
+switch(oCheckGcode)
+     {
+     case ClCheckGcode::_Warn:
+          lcd_show_fullscreen_message_and_wait_P(_i("G-code level doesn't match! Press the knob to continue."));
+          break;
+     case ClCheckGcode::_Strict:
+          lcd_show_fullscreen_message_and_wait_P(_i("G-code level doesn't match! Print is aborted, press the knob."));
+          lcd_print_stop();
+          break;
+     }
+}
+
+//-// -> cmdqueue ???
+#define PRINTER_NAME_LENGTH (sizeof(PRINTER_NAME)-1)
+#define GCODE_DELIMITER '"'
+#define ELLIPSIS "..."
+
+char* code_string(char* pStr,size_t* nLength)
+{
+char* pStrBegin;
+char* pStrEnd;
+
+pStrBegin=strchr(pStr,GCODE_DELIMITER);
+if(!pStrBegin)
+     return(NULL);
+pStrBegin++;
+pStrEnd=strchr(pStrBegin,GCODE_DELIMITER);
+if(!pStrEnd)
+     return(NULL);
+*nLength=pStrEnd-pStrBegin;
+return(pStrBegin);
+}
+
+void printer_smodel_check(char* pStrPos)
+{
+char* pResult;
+size_t nLength;
+bool bCheckOK;
+char sPrinterName[PRINTER_NAME_LENGTH+sizeof(ELLIPSIS)-1+1]="";
+
+pResult=code_string(pStrPos,&nLength);
+if(pResult!=NULL)
+     {
+     strlcpy(sPrinterName,pResult,min(PRINTER_NAME_LENGTH,nLength)+1);
+     if(nLength>PRINTER_NAME_LENGTH)
+          strcat(sPrinterName,ELLIPSIS);
+     bCheckOK=(nLength==PRINTER_NAME_LENGTH);
+     if(bCheckOK&&(!strncasecmp(pResult,PRINTER_NAME,nLength))) // i.e. string compare execute only if lengths are same
+          return;
+     }
+SERIAL_ECHO_START;
+SERIAL_ECHOLNPGM("Printer model doesn't match ...");
+SERIAL_ECHOPGM("actual  : \"");
+SERIAL_ECHO(PRINTER_NAME);
+SERIAL_ECHOLNPGM("\"");
+SERIAL_ECHOPGM("expected: \"");
+SERIAL_ECHO(sPrinterName);
+SERIAL_ECHOLNPGM("\"");
+switch(oCheckModel)
+     {
+     case ClCheckModel::_Warn:
+          lcd_show_fullscreen_message_and_wait_P(_i("Printer model doesn't match! Press the knob to continue."));
+          break;
+     case ClCheckModel::_Strict:
+          lcd_show_fullscreen_message_and_wait_P(_i("Printer model doesn't match! Print is aborted, press the knob."));
+          lcd_print_stop();
+          break;
+     }
 }

Firmware/util.h

@@ -35,27 +35,66 @@ inline void eeprom_update_int8(unsigned char* addr, int8_t v) {
 
 
 //-//
-#define e_CHECK_MODE_NULL 0xFF
-#define e_NOZZLE_DIAMETER_NULL 0xFF
+enum class ClPrintChecking:uint_least8_t
+{
+    _Nozzle=1,
+    _Model=2,
+    _Smodel=3,
+    _Version=4,
+    _Gcode=5
+};
 
-typedef enum
+enum class ClNozzleDiameter:uint_least8_t
 {
-    e_NOZZLE_DIAMETER_250,
-    e_NOZZLE_DIAMETER_400,
-    e_NOZZLE_DIAMETER_600
-} eNOZZLE_DIAMETER;
+    _Diameter_250=25,
+    _Diameter_400=40,
+    _Diameter_600=60,
+    _Diameter_Undef=EEPROM_EMPTY_VALUE
+};
 
-typedef enum
+enum class ClCheckMode:uint_least8_t
 {
-    e_CHECK_MODE_none,
-    e_CHECK_MODE_warn,
-    e_CHECK_MODE_strict
-} eCHECK_MODE;
+    _None,
+    _Warn,
+    _Strict,
+    _Undef=EEPROM_EMPTY_VALUE
+};
+
+enum class ClCheckModel:uint_least8_t
+{
+    _None,
+    _Warn,
+    _Strict,
+    _Undef=EEPROM_EMPTY_VALUE
+};
+
+enum class ClCheckVersion:uint_least8_t
+{
+    _None,
+    _Warn,
+    _Strict,
+    _Undef=EEPROM_EMPTY_VALUE
+};
+
+enum class ClCheckGcode:uint_least8_t
+{
+    _None,
+    _Warn,
+    _Strict,
+    _Undef=EEPROM_EMPTY_VALUE
+};
 
-extern eNOZZLE_DIAMETER eNozzleDiameter;
-extern eCHECK_MODE eCheckMode;
+extern ClNozzleDiameter oNozzleDiameter;
+extern ClCheckMode oCheckMode;
+extern ClCheckModel oCheckModel;
+extern ClCheckVersion oCheckVersion;
+extern ClCheckGcode oCheckGcode;
 
 void fCheckModeInit();
 void nozzle_diameter_check(uint16_t nDiameter);
+void printer_model_check(uint16_t nPrinterModel);
+void printer_smodel_check(char* pStrPos);
+void fw_version_check(const char *pVersion);
+void gcode_level_check(uint16_t nGcodeLevel);
 
 #endif /* UTIL_H */

Firmware/variants/1_75mm_MK3-EINSy10a-E3Dv6full.h

@@ -8,6 +8,8 @@
 
 // Printer revision
 #define PRINTER_TYPE PRINTER_MK3
+#define PRINTER_NAME PRINTER_MK3_NAME
+#define PRINTER_MMU_NAME PRINTER_MK3_MMU2_NAME
 #define FILAMENT_SIZE "1_75mm_MK3"
 #define NOZZLE_TYPE "E3Dv6full"