util.cpp 17 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500
  1. #include "Configuration.h"
  2. #include "ultralcd.h"
  3. #include "menu.h"
  4. #include "sound.h"
  5. #include "language.h"
  6. #include "util.h"
  7. #include <avr/pgmspace.h>
  8. // Allocate the version string in the program memory. Otherwise the string lands either on the stack or in the global RAM.
  9. static const char FW_VERSION_STR[] PROGMEM = FW_VERSION;
  10. static const uint16_t FW_VERSION_NR[4] PROGMEM = { FW_MAJOR, FW_MINOR, FW_REVISION, FW_COMMIT_NR };
  11. const char* FW_VERSION_STR_P()
  12. {
  13. return FW_VERSION_STR;
  14. }
  15. const char FW_PRUSA3D_MAGIC_STR[] PROGMEM = FW_PRUSA3D_MAGIC;
  16. const char* FW_PRUSA3D_MAGIC_STR_P()
  17. {
  18. return FW_PRUSA3D_MAGIC_STR;
  19. }
  20. const char STR_REVISION_DEV [] PROGMEM = "dev";
  21. const char STR_REVISION_ALPHA[] PROGMEM = "alpha";
  22. const char STR_REVISION_BETA [] PROGMEM = "beta";
  23. const char STR_REVISION_RC [] PROGMEM = "rc";
  24. inline bool is_whitespace_or_nl(char c)
  25. {
  26. return c == ' ' || c == '\t' || c == '\n' || c == '\r';
  27. }
  28. inline bool is_whitespace_or_nl_or_eol(char c)
  29. {
  30. return c == 0 || c == ' ' || c == '\t' || c == '\n' || c == '\r';
  31. }
  32. inline bool is_digit(char c)
  33. {
  34. return c >= '0' && c <= '9';
  35. }
  36. // Parse a major.minor.revision version number.
  37. // Return true if valid.
  38. inline bool parse_version(const char *str, uint16_t version[4])
  39. {
  40. #if 0
  41. SERIAL_ECHOPGM("Parsing version string ");
  42. SERIAL_ECHO(str);
  43. SERIAL_ECHOLNPGM("");
  44. #endif
  45. const char *major = str;
  46. const char *p = str;
  47. while (is_digit(*p)) ++ p;
  48. if (*p != '.')
  49. return false;
  50. const char *minor = ++ p;
  51. while (is_digit(*p)) ++ p;
  52. if (*p != '.')
  53. return false;
  54. const char *rev = ++ p;
  55. while (is_digit(*p)) ++ p;
  56. if (! is_whitespace_or_nl_or_eol(*p) && *p != '-')
  57. return false;
  58. char *endptr = NULL;
  59. version[0] = strtol(major, &endptr, 10);
  60. if (endptr != minor - 1)
  61. return false;
  62. version[1] = strtol(minor, &endptr, 10);
  63. if (endptr != rev - 1)
  64. return false;
  65. version[2] = strtol(rev, &endptr, 10);
  66. if (endptr != p)
  67. return false;
  68. version[3] = FIRMWARE_REVISION_RELEASED;
  69. if (*p ++ == '-') {
  70. const char *q = p;
  71. while (! is_whitespace_or_nl_or_eol(*q))
  72. ++ q;
  73. uint8_t n = q - p;
  74. if (n == strlen_P(STR_REVISION_DEV) && strncmp_P(p, STR_REVISION_DEV, n) == 0)
  75. version[3] = FIRMWARE_REVISION_DEV;
  76. else if (n == strlen_P(STR_REVISION_ALPHA) && strncmp_P(p, STR_REVISION_ALPHA, n) == 0)
  77. version[3] = FIRMWARE_REVISION_ALPHA;
  78. else if (n == strlen_P(STR_REVISION_BETA) && strncmp_P(p, STR_REVISION_BETA, n) == 0)
  79. version[3] = FIRMWARE_REVISION_BETA;
  80. else if ((n == 2 || n == 3) && (p[0] == 'r' || p[0] == 'R') && (p[1] == 'c' || p[1] == 'C')) {
  81. if (n == 2)
  82. version[3] = FIRMWARE_REVISION_RC;
  83. else {
  84. if (is_digit(p[2]))
  85. version[3] = FIRMWARE_REVISION_RC + p[2] - '1';
  86. else
  87. return false;
  88. }
  89. } else
  90. return false;
  91. }
  92. #if 0
  93. SERIAL_ECHOPGM("Version parsed, major: ");
  94. SERIAL_ECHO(version[0]);
  95. SERIAL_ECHOPGM(", minor: ");
  96. SERIAL_ECHO(version[1]);
  97. SERIAL_ECHOPGM(", revision: ");
  98. SERIAL_ECHO(version[2]);
  99. SERIAL_ECHOPGM(", flavor: ");
  100. SERIAL_ECHO(version[3]);
  101. SERIAL_ECHOLNPGM("");
  102. #endif
  103. return true;
  104. }
  105. inline bool strncmp_PP(const char *p1, const char *p2, uint8_t n)
  106. {
  107. for (; n > 0; -- n, ++ p1, ++ p2) {
  108. if (pgm_read_byte(p1) >= 65 && pgm_read_byte(p1) <= 92) //p1 is upper case (p2 is always lowercase)
  109. {
  110. if ((pgm_read_byte(p1)+32) < pgm_read_byte(p2))
  111. return -1;
  112. if ((pgm_read_byte(p1)+32) > pgm_read_byte(p2))
  113. return 1;
  114. }
  115. else if (pgm_read_byte(p1) == 0) {
  116. return 0;
  117. }
  118. else { //p1 is lowercase
  119. if (pgm_read_byte(p1) < pgm_read_byte(p2))
  120. return -1;
  121. if (pgm_read_byte(p1) > pgm_read_byte(p2))
  122. return 1;
  123. }
  124. }
  125. return 0;
  126. }
  127. // 1 - yes, 0 - false, -1 - error;
  128. inline int8_t is_provided_version_newer(const char *version_string)
  129. {
  130. uint16_t ver_gcode[4];
  131. if (! parse_version(version_string, ver_gcode))
  132. return -1;
  133. for (uint8_t i = 0; i < 4; ++ i)
  134. {
  135. uint16_t v = (uint16_t)pgm_read_word(&FW_VERSION_NR[i]);
  136. if (ver_gcode[i] > v)
  137. return 1;
  138. else if (ver_gcode[i] < v)
  139. return 0;
  140. }
  141. return 0;
  142. }
  143. bool force_selftest_if_fw_version()
  144. {
  145. //if fw version used before flashing new firmware (fw version currently stored in eeprom) is lower then 3.1.2-RC2, function returns true to force selftest
  146. uint16_t ver_eeprom[4];
  147. uint16_t ver_with_calibration[4] = {3, 1, 2, 4}; //hardcoded 3.1.2-RC2 version
  148. bool force_selftest = false;
  149. ver_eeprom[0] = eeprom_read_word((uint16_t*)EEPROM_FIRMWARE_VERSION_MAJOR);
  150. ver_eeprom[1] = eeprom_read_word((uint16_t*)EEPROM_FIRMWARE_VERSION_MINOR);
  151. ver_eeprom[2] = eeprom_read_word((uint16_t*)EEPROM_FIRMWARE_VERSION_REVISION);
  152. ver_eeprom[3] = eeprom_read_word((uint16_t*)EEPROM_FIRMWARE_VERSION_FLAVOR);
  153. for (uint8_t i = 0; i < 4; ++i) {
  154. if (ver_with_calibration[i] > ver_eeprom[i]) {
  155. force_selftest = true;
  156. break;
  157. }
  158. else if (ver_with_calibration[i] < ver_eeprom[i])
  159. break;
  160. }
  161. //force selftest also in case that version used before flashing new firmware was 3.2.0-RC1
  162. if ((ver_eeprom[0] == 3) && (ver_eeprom[1] == 2) && (ver_eeprom[2] == 0) && (ver_eeprom[3] == 3)) force_selftest = true;
  163. return force_selftest;
  164. }
  165. bool show_upgrade_dialog_if_version_newer(const char *version_string)
  166. {
  167. int8_t upgrade = is_provided_version_newer(version_string);
  168. if (upgrade < 0)
  169. return false;
  170. if (upgrade) {
  171. lcd_display_message_fullscreen_P(_i("New firmware version available:"));////MSG_NEW_FIRMWARE_AVAILABLE c=20 r=2
  172. lcd_puts_at_P(0, 2, PSTR(""));
  173. for (const char *c = version_string; ! is_whitespace_or_nl_or_eol(*c); ++ c)
  174. lcd_putc(*c);
  175. lcd_puts_at_P(0, 3, _i("Please upgrade."));////MSG_NEW_FIRMWARE_PLEASE_UPGRADE c=20
  176. Sound_MakeCustom(50,1000,false);
  177. delay_keep_alive(500);
  178. Sound_MakeCustom(50,1000,false);
  179. lcd_wait_for_click_delay(30);
  180. lcd_update_enable(true);
  181. lcd_clear();
  182. lcd_update(0);
  183. }
  184. // Succeeded.
  185. return true;
  186. }
  187. void update_current_firmware_version_to_eeprom()
  188. {
  189. for (int8_t i = 0; i < FW_PRUSA3D_MAGIC_LEN; ++ i){
  190. eeprom_update_byte((uint8_t*)(EEPROM_FIRMWARE_PRUSA_MAGIC+i), pgm_read_byte(FW_PRUSA3D_MAGIC_STR+i));
  191. }
  192. eeprom_update_word((uint16_t*)EEPROM_FIRMWARE_VERSION_MAJOR, (uint16_t)pgm_read_word(&FW_VERSION_NR[0]));
  193. eeprom_update_word((uint16_t*)EEPROM_FIRMWARE_VERSION_MINOR, (uint16_t)pgm_read_word(&FW_VERSION_NR[1]));
  194. eeprom_update_word((uint16_t*)EEPROM_FIRMWARE_VERSION_REVISION, (uint16_t)pgm_read_word(&FW_VERSION_NR[2]));
  195. // See FirmwareRevisionFlavorType for the definition of firmware flavors.
  196. eeprom_update_word((uint16_t*)EEPROM_FIRMWARE_VERSION_FLAVOR, (uint16_t)pgm_read_word(&FW_VERSION_NR[3]));
  197. }
  198. //-//
  199. #define MSG_PRINT_CHECKING_FAILED_TIMEOUT 30
  200. ClNozzleDiameter oNozzleDiameter=ClNozzleDiameter::_Diameter_400;
  201. ClCheckMode oCheckMode=ClCheckMode::_None;
  202. ClCheckModel oCheckModel=ClCheckModel::_None;
  203. ClCheckVersion oCheckVersion=ClCheckVersion::_None;
  204. ClCheckGcode oCheckGcode=ClCheckGcode::_None;
  205. void fCheckModeInit()
  206. {
  207. oCheckMode=(ClCheckMode)eeprom_read_byte((uint8_t*)EEPROM_CHECK_MODE);
  208. if(oCheckMode==ClCheckMode::_Undef)
  209. {
  210. oCheckMode=ClCheckMode::_Warn;
  211. eeprom_update_byte((uint8_t*)EEPROM_CHECK_MODE,(uint8_t)oCheckMode);
  212. }
  213. if(farm_mode)
  214. {
  215. oCheckMode=ClCheckMode::_Strict;
  216. if(eeprom_read_word((uint16_t*)EEPROM_NOZZLE_DIAMETER_uM)==EEPROM_EMPTY_VALUE16)
  217. eeprom_update_word((uint16_t*)EEPROM_NOZZLE_DIAMETER_uM,EEPROM_NOZZLE_DIAMETER_uM_DEFAULT);
  218. }
  219. oNozzleDiameter=(ClNozzleDiameter)eeprom_read_byte((uint8_t*)EEPROM_NOZZLE_DIAMETER);
  220. if((oNozzleDiameter==ClNozzleDiameter::_Diameter_Undef)&& !farm_mode)
  221. {
  222. oNozzleDiameter=ClNozzleDiameter::_Diameter_400;
  223. eeprom_update_byte((uint8_t*)EEPROM_NOZZLE_DIAMETER,(uint8_t)oNozzleDiameter);
  224. eeprom_update_word((uint16_t*)EEPROM_NOZZLE_DIAMETER_uM,EEPROM_NOZZLE_DIAMETER_uM_DEFAULT);
  225. }
  226. oCheckModel=(ClCheckModel)eeprom_read_byte((uint8_t*)EEPROM_CHECK_MODEL);
  227. if(oCheckModel==ClCheckModel::_Undef)
  228. {
  229. oCheckModel=ClCheckModel::_Warn;
  230. eeprom_update_byte((uint8_t*)EEPROM_CHECK_MODEL,(uint8_t)oCheckModel);
  231. }
  232. oCheckVersion=(ClCheckVersion)eeprom_read_byte((uint8_t*)EEPROM_CHECK_VERSION);
  233. if(oCheckVersion==ClCheckVersion::_Undef)
  234. {
  235. oCheckVersion=ClCheckVersion::_Warn;
  236. eeprom_update_byte((uint8_t*)EEPROM_CHECK_VERSION,(uint8_t)oCheckVersion);
  237. }
  238. oCheckGcode=(ClCheckGcode)eeprom_read_byte((uint8_t*)EEPROM_CHECK_GCODE);
  239. if(oCheckGcode==ClCheckGcode::_Undef)
  240. {
  241. oCheckGcode=ClCheckGcode::_Warn;
  242. eeprom_update_byte((uint8_t*)EEPROM_CHECK_GCODE,(uint8_t)oCheckGcode);
  243. }
  244. }
  245. void nozzle_diameter_check(uint16_t nDiameter)
  246. {
  247. uint16_t nDiameter_um;
  248. if(oCheckMode==ClCheckMode::_None)
  249. return;
  250. nDiameter_um=eeprom_read_word((uint16_t*)EEPROM_NOZZLE_DIAMETER_uM);
  251. if(nDiameter==nDiameter_um)
  252. return;
  253. //SERIAL_ECHO_START;
  254. //SERIAL_ECHOLNPGM("Printer nozzle diameter differs from the G-code ...");
  255. //SERIAL_ECHOPGM("actual : ");
  256. //SERIAL_ECHOLN((float)(nDiameter_um/1000.0));
  257. //SERIAL_ECHOPGM("expected: ");
  258. //SERIAL_ECHOLN((float)(nDiameter/1000.0));
  259. switch(oCheckMode)
  260. {
  261. case ClCheckMode::_Warn:
  262. // lcd_show_fullscreen_message_and_wait_P(_i("Printer nozzle diameter differs from the G-code. Continue?"));
  263. lcd_display_message_fullscreen_P(_i("Printer nozzle diameter differs from the G-code. Continue?"));////MSG_NOZZLE_DIFFERS_CONTINUE c=20 r=5
  264. lcd_wait_for_click_delay(MSG_PRINT_CHECKING_FAILED_TIMEOUT);
  265. //???custom_message_type=CUSTOM_MSG_TYPE_STATUS; // display / status-line recovery
  266. lcd_update_enable(true); // display / status-line recovery
  267. break;
  268. case ClCheckMode::_Strict:
  269. lcd_show_fullscreen_message_and_wait_P(_i("Printer nozzle diameter differs from the G-code. Please check the value in settings. Print cancelled."));////MSG_NOZZLE_DIFFERS_CANCELLED c=20 r=9
  270. lcd_print_stop();
  271. break;
  272. case ClCheckMode::_None:
  273. case ClCheckMode::_Undef:
  274. break;
  275. }
  276. if(!farm_mode)
  277. {
  278. bSettings=false; // flag ('fake parameter') for 'lcd_hw_setup_menu()' function
  279. menu_submenu(lcd_hw_setup_menu);
  280. }
  281. }
  282. void printer_model_check(uint16_t nPrinterModel)
  283. {
  284. if(oCheckModel==ClCheckModel::_None)
  285. return;
  286. if(nPrinterModel==nPrinterType)
  287. return;
  288. //SERIAL_ECHO_START;
  289. //SERIAL_ECHOLNPGM("Printer model differs from the G-code ...");
  290. //SERIAL_ECHOPGM("actual : ");
  291. //SERIAL_ECHOLN(nPrinterType);
  292. //SERIAL_ECHOPGM("expected: ");
  293. //SERIAL_ECHOLN(nPrinterModel);
  294. switch(oCheckModel)
  295. {
  296. case ClCheckModel::_Warn:
  297. // lcd_show_fullscreen_message_and_wait_P(_i("Printer model differs from the G-code. Continue?"));
  298. lcd_display_message_fullscreen_P(_T(MSG_GCODE_DIFF_PRINTER_CONTINUE));
  299. lcd_wait_for_click_delay(MSG_PRINT_CHECKING_FAILED_TIMEOUT);
  300. //???custom_message_type=CUSTOM_MSG_TYPE_STATUS; // display / status-line recovery
  301. lcd_update_enable(true); // display / status-line recovery
  302. break;
  303. case ClCheckModel::_Strict:
  304. lcd_show_fullscreen_message_and_wait_P(_T(MSG_GCODE_DIFF_PRINTER_CANCELLED));
  305. lcd_print_stop();
  306. break;
  307. case ClCheckModel::_None:
  308. case ClCheckModel::_Undef:
  309. break;
  310. }
  311. }
  312. uint8_t mCompareValue(uint16_t nX,uint16_t nY)
  313. {
  314. if(nX>nY)
  315. return((uint8_t)ClCompareValue::_Greater);
  316. if(nX<nY)
  317. return((uint8_t)ClCompareValue::_Less);
  318. return((uint8_t)ClCompareValue::_Equal);
  319. }
  320. void fw_version_check(const char *pVersion)
  321. {
  322. uint16_t aVersion[4];
  323. uint8_t nCompareValueResult;
  324. if(oCheckVersion==ClCheckVersion::_None)
  325. return;
  326. parse_version(pVersion,aVersion);
  327. nCompareValueResult=mCompareValue(aVersion[0],eeprom_read_word((uint16_t*)EEPROM_FIRMWARE_VERSION_MAJOR))<<6;
  328. nCompareValueResult+=mCompareValue(aVersion[1],eeprom_read_word((uint16_t*)EEPROM_FIRMWARE_VERSION_MINOR))<<4;
  329. nCompareValueResult+=mCompareValue(aVersion[2],eeprom_read_word((uint16_t*)EEPROM_FIRMWARE_VERSION_REVISION))<<2;
  330. nCompareValueResult+=mCompareValue(aVersion[3],eeprom_read_word((uint16_t*)EEPROM_FIRMWARE_VERSION_FLAVOR));
  331. if(nCompareValueResult==COMPARE_VALUE_EQUAL)
  332. return;
  333. if((nCompareValueResult<COMPARE_VALUE_EQUAL)&&oCheckVersion==ClCheckVersion::_Warn)
  334. return;
  335. //SERIAL_ECHO_START;
  336. //SERIAL_ECHOLNPGM("Printer FW version differs from the G-code ...");
  337. //SERIAL_ECHOPGM("actual : ");
  338. //SERIAL_ECHOLN(FW_VERSION);
  339. //SERIAL_ECHOPGM("expected: ");
  340. //SERIAL_ECHOLN(pVersion);
  341. switch(oCheckVersion)
  342. {
  343. case ClCheckVersion::_Warn:
  344. // lcd_show_fullscreen_message_and_wait_P(_i("Printer FW version differs from the G-code. Continue?"));
  345. lcd_display_message_fullscreen_P(_i("G-code sliced for a newer firmware. Continue?"));////MSG_GCODE_NEWER_FIRMWARE_CONTINUE c=20 r=5
  346. lcd_wait_for_click_delay(MSG_PRINT_CHECKING_FAILED_TIMEOUT);
  347. //???custom_message_type=CUSTOM_MSG_TYPE_STATUS; // display / status-line recovery
  348. lcd_update_enable(true); // display / status-line recovery
  349. break;
  350. case ClCheckVersion::_Strict:
  351. lcd_show_fullscreen_message_and_wait_P(_i("G-code sliced for a newer firmware. Please update the firmware. Print cancelled."));////MSG_GCODE_NEWER_FIRMWARE_CANCELLED c=20 r=8
  352. lcd_print_stop();
  353. break;
  354. case ClCheckVersion::_None:
  355. case ClCheckVersion::_Undef:
  356. break;
  357. }
  358. }
  359. void gcode_level_check(uint16_t nGcodeLevel)
  360. {
  361. if(oCheckGcode==ClCheckGcode::_None)
  362. return;
  363. if(nGcodeLevel==(uint16_t)GCODE_LEVEL)
  364. return;
  365. if((nGcodeLevel<(uint16_t)GCODE_LEVEL)&&(oCheckGcode==ClCheckGcode::_Warn))
  366. return;
  367. //SERIAL_ECHO_START;
  368. //SERIAL_ECHOLNPGM("Printer G-code level differs from the G-code ...");
  369. //SERIAL_ECHOPGM("actual : ");
  370. //SERIAL_ECHOLN(GCODE_LEVEL);
  371. //SERIAL_ECHOPGM("expected: ");
  372. //SERIAL_ECHOLN(nGcodeLevel);
  373. switch(oCheckGcode)
  374. {
  375. case ClCheckGcode::_Warn:
  376. // lcd_show_fullscreen_message_and_wait_P(_i("Printer G-code level differs from the G-code. Continue?"));
  377. lcd_display_message_fullscreen_P(_i("G-code sliced for a different level. Continue?"));////MSG_GCODE_DIFF_CONTINUE c=20 r=4
  378. lcd_wait_for_click_delay(MSG_PRINT_CHECKING_FAILED_TIMEOUT);
  379. //???custom_message_type=CUSTOM_MSG_TYPE_STATUS; // display / status-line recovery
  380. lcd_update_enable(true); // display / status-line recovery
  381. break;
  382. case ClCheckGcode::_Strict:
  383. lcd_show_fullscreen_message_and_wait_P(_i("G-code sliced for a different level. Please re-slice the model again. Print cancelled."));////MSG_GCODE_DIFF_CANCELLED c=20 r=7
  384. lcd_print_stop();
  385. break;
  386. case ClCheckGcode::_None:
  387. case ClCheckGcode::_Undef:
  388. break;
  389. }
  390. }
  391. //-// -> cmdqueue ???
  392. #define PRINTER_NAME_LENGTH ((sizeof(PRINTER_MMU_NAME)>sizeof(PRINTER_NAME))?(sizeof(PRINTER_MMU_NAME)-1):(sizeof(PRINTER_NAME)-1))
  393. #define GCODE_DELIMITER '"'
  394. #define ELLIPSIS "..."
  395. char* code_string(char* pStr,size_t* nLength)
  396. {
  397. char* pStrBegin;
  398. char* pStrEnd;
  399. pStrBegin=strchr(pStr,GCODE_DELIMITER);
  400. if(!pStrBegin)
  401. return(NULL);
  402. pStrBegin++;
  403. pStrEnd=strchr(pStrBegin,GCODE_DELIMITER);
  404. if(!pStrEnd)
  405. return(NULL);
  406. *nLength=pStrEnd-pStrBegin;
  407. pStrBegin[*nLength] = '\0';
  408. return pStrBegin;
  409. }
  410. void printer_smodel_check(char* pStrPos)
  411. {
  412. char* pResult;
  413. size_t nLength,nPrinterNameLength;
  414. nPrinterNameLength = strlen_P(sPrinterName);
  415. pResult = code_string(pStrPos,&nLength);
  416. if(pResult != NULL && nLength == nPrinterNameLength) {
  417. // Only compare them if the lengths match
  418. if (strcmp_P(pResult, sPrinterName) == 0) return;
  419. }
  420. switch(oCheckModel)
  421. {
  422. case ClCheckModel::_Warn:
  423. // lcd_show_fullscreen_message_and_wait_P(_i("Printer model differs from the G-code. Continue?"));
  424. lcd_display_message_fullscreen_P(_T(MSG_GCODE_DIFF_PRINTER_CONTINUE));
  425. lcd_wait_for_click_delay(MSG_PRINT_CHECKING_FAILED_TIMEOUT);
  426. //???custom_message_type=CUSTOM_MSG_TYPE_STATUS; // display / status-line recovery
  427. lcd_update_enable(true); // display / status-line recovery
  428. break;
  429. case ClCheckModel::_Strict:
  430. lcd_show_fullscreen_message_and_wait_P(_T(MSG_GCODE_DIFF_PRINTER_CANCELLED));
  431. lcd_print_stop();
  432. break;
  433. case ClCheckModel::_None:
  434. case ClCheckModel::_Undef:
  435. break;
  436. }
  437. }
  438. void fSetMmuMode(bool bMMu)
  439. {
  440. if(bMMu)
  441. {
  442. nPrinterType=pgm_read_word(&_nPrinterMmuType);
  443. sPrinterName=_sPrinterMmuName;
  444. }
  445. else {
  446. nPrinterType=pgm_read_word(&_nPrinterType);
  447. sPrinterName=_sPrinterName;
  448. }
  449. }
  450. void ip4_to_str(char* dest, uint8_t* IP)
  451. {
  452. sprintf_P(dest, PSTR("%u.%u.%u.%u"), IP[0], IP[1], IP[2], IP[3]);
  453. }