util.cpp 12 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372
  1. #include "Configuration.h"
  2. #include "ultralcd.h"
  3. #include "sound.h"
  4. #include "language.h"
  5. #include "util.h"
  6. // Allocate the version string in the program memory. Otherwise the string lands either on the stack or in the global RAM.
  7. const char FW_VERSION_STR[] PROGMEM = FW_VERSION;
  8. const char* FW_VERSION_STR_P()
  9. {
  10. return FW_VERSION_STR;
  11. }
  12. const char FW_PRUSA3D_MAGIC_STR[] PROGMEM = FW_PRUSA3D_MAGIC;
  13. const char* FW_PRUSA3D_MAGIC_STR_P()
  14. {
  15. return FW_PRUSA3D_MAGIC_STR;
  16. }
  17. const char STR_REVISION_DEV [] PROGMEM = "dev";
  18. const char STR_REVISION_ALPHA[] PROGMEM = "alpha";
  19. const char STR_REVISION_BETA [] PROGMEM = "beta";
  20. const char STR_REVISION_RC [] PROGMEM = "rc";
  21. inline bool is_whitespace_or_nl(char c)
  22. {
  23. return c == ' ' || c == '\t' || c == '\n' || c == 'r';
  24. }
  25. inline bool is_whitespace_or_nl_or_eol(char c)
  26. {
  27. return c == 0 || c == ' ' || c == '\t' || c == '\n' || c == '\r';
  28. }
  29. inline bool is_digit(char c)
  30. {
  31. return c >= '0' && c <= '9';
  32. }
  33. // Parse a major.minor.revision version number.
  34. // Return true if valid.
  35. inline bool parse_version(const char *str, uint16_t version[4])
  36. {
  37. #if 0
  38. SERIAL_ECHOPGM("Parsing version string ");
  39. SERIAL_ECHO(str);
  40. SERIAL_ECHOLNPGM("");
  41. #endif
  42. const char *major = str;
  43. const char *p = str;
  44. while (is_digit(*p)) ++ p;
  45. if (*p != '.')
  46. return false;
  47. const char *minor = ++ p;
  48. while (is_digit(*p)) ++ p;
  49. if (*p != '.')
  50. return false;
  51. const char *rev = ++ p;
  52. while (is_digit(*p)) ++ p;
  53. if (! is_whitespace_or_nl_or_eol(*p) && *p != '-')
  54. return false;
  55. char *endptr = NULL;
  56. version[0] = strtol(major, &endptr, 10);
  57. if (endptr != minor - 1)
  58. return false;
  59. version[1] = strtol(minor, &endptr, 10);
  60. if (endptr != rev - 1)
  61. return false;
  62. version[2] = strtol(rev, &endptr, 10);
  63. if (endptr != p)
  64. return false;
  65. version[3] = FIRMWARE_REVISION_RELEASED;
  66. if (*p ++ == '-') {
  67. const char *q = p;
  68. while (! is_whitespace_or_nl_or_eol(*q))
  69. ++ q;
  70. uint8_t n = q - p;
  71. if (n == strlen_P(STR_REVISION_DEV) && strncmp_P(p, STR_REVISION_DEV, n) == 0)
  72. version[3] = FIRMWARE_REVISION_DEV;
  73. else if (n == strlen_P(STR_REVISION_ALPHA) && strncmp_P(p, STR_REVISION_ALPHA, n) == 0)
  74. version[3] = FIRMWARE_REVISION_ALPHA;
  75. else if (n == strlen_P(STR_REVISION_BETA) && strncmp_P(p, STR_REVISION_BETA, n) == 0)
  76. version[3] = FIRMWARE_REVISION_BETA;
  77. else if ((n == 2 || n == 3) && (p[0] == 'r' || p[0] == 'R') && (p[1] == 'c' || p[1] == 'C')) {
  78. if (n == 2)
  79. version[3] = FIRMWARE_REVISION_RC;
  80. else {
  81. if (is_digit(p[2]))
  82. version[3] = FIRMWARE_REVISION_RC + p[2] - '1';
  83. else
  84. return false;
  85. }
  86. } else
  87. return false;
  88. }
  89. #if 0
  90. SERIAL_ECHOPGM("Version parsed, major: ");
  91. SERIAL_ECHO(version[0]);
  92. SERIAL_ECHOPGM(", minor: ");
  93. SERIAL_ECHO(version[1]);
  94. SERIAL_ECHOPGM(", revision: ");
  95. SERIAL_ECHO(version[2]);
  96. SERIAL_ECHOPGM(", flavor: ");
  97. SERIAL_ECHO(version[3]);
  98. SERIAL_ECHOLNPGM("");
  99. #endif
  100. return true;
  101. }
  102. inline bool strncmp_PP(const char *p1, const char *p2, uint8_t n)
  103. {
  104. for (; n > 0; -- n, ++ p1, ++ p2) {
  105. if (pgm_read_byte(p1) >= 65 && pgm_read_byte(p1) <= 92) //p1 is upper case (p2 is always lowercase)
  106. {
  107. if ((pgm_read_byte(p1)+32) < pgm_read_byte(p2))
  108. return -1;
  109. if ((pgm_read_byte(p1)+32) > pgm_read_byte(p2))
  110. return 1;
  111. }
  112. else if (pgm_read_byte(p1) == 0) {
  113. return 0;
  114. }
  115. else { //p1 is lowercase
  116. if (pgm_read_byte(p1) < pgm_read_byte(p2))
  117. return -1;
  118. if (pgm_read_byte(p1) > pgm_read_byte(p2))
  119. return 1;
  120. }
  121. }
  122. return 0;
  123. }
  124. // Parse a major.minor.revision version number.
  125. // Return true if valid.
  126. inline bool parse_version_P(const char *str, uint16_t version[4])
  127. {
  128. #if 0
  129. SERIAL_ECHOPGM("Parsing version string ");
  130. SERIAL_ECHORPGM(str);
  131. SERIAL_ECHOLNPGM("");
  132. #endif
  133. const char *major = str;
  134. const char *p = str;
  135. while (is_digit(char(pgm_read_byte(p)))) ++ p;
  136. if (pgm_read_byte(p) != '.')
  137. return false;
  138. const char *minor = ++ p;
  139. while (is_digit(char(pgm_read_byte(p)))) ++ p;
  140. if (pgm_read_byte(p) != '.')
  141. return false;
  142. const char *rev = ++ p;
  143. while (is_digit(char(pgm_read_byte(p)))) ++ p;
  144. if (! is_whitespace_or_nl_or_eol(char(pgm_read_byte(p))) && pgm_read_byte(p) != '-')
  145. return false;
  146. char buf[5];
  147. uint8_t n = minor - major - 1;
  148. if (n > 4)
  149. return false;
  150. memcpy_P(buf, major, n); buf[n] = 0;
  151. char *endptr = NULL;
  152. version[0] = strtol(buf, &endptr, 10);
  153. if (*endptr != 0)
  154. return false;
  155. n = rev - minor - 1;
  156. if (n > 4)
  157. return false;
  158. memcpy_P(buf, minor, n); buf[n] = 0;
  159. version[1] = strtol(buf, &endptr, 10);
  160. if (*endptr != 0)
  161. return false;
  162. n = p - rev;
  163. if (n > 4)
  164. return false;
  165. memcpy_P(buf, rev, n);
  166. buf[n] = 0;
  167. version[2] = strtol(buf, &endptr, 10);
  168. if (*endptr != 0)
  169. return false;
  170. version[3] = FIRMWARE_REVISION_RELEASED;
  171. if (pgm_read_byte(p ++) == '-') {
  172. const char *q = p;
  173. while (! is_whitespace_or_nl_or_eol(char(pgm_read_byte(q))))
  174. ++ q;
  175. n = q - p;
  176. if (n == strlen_P(STR_REVISION_DEV) && strncmp_PP(p, STR_REVISION_DEV, n) == 0)
  177. version[3] = FIRMWARE_REVISION_DEV;
  178. else if (n == strlen_P(STR_REVISION_ALPHA) && strncmp_PP(p, STR_REVISION_ALPHA, n) == 0)
  179. version[3] = FIRMWARE_REVISION_ALPHA;
  180. else if (n == strlen_P(STR_REVISION_BETA) && strncmp_PP(p, STR_REVISION_BETA, n) == 0)
  181. version[3] = FIRMWARE_REVISION_BETA;
  182. else if ((n == 2 || n == 3) && strncmp_PP(p, STR_REVISION_RC, 2) == 0) {
  183. if (n == 2)
  184. version[3] = FIRMWARE_REVISION_RC;
  185. else {
  186. p += 2;
  187. if (is_digit(pgm_read_byte(p)))
  188. version[3] = FIRMWARE_REVISION_RC + pgm_read_byte(p) - '1';
  189. else
  190. return false;
  191. }
  192. } else
  193. return false;
  194. }
  195. #if 0
  196. SERIAL_ECHOPGM("Version parsed, major: ");
  197. SERIAL_ECHO(version[0]);
  198. SERIAL_ECHOPGM(", minor: ");
  199. SERIAL_ECHO(version[1]);
  200. SERIAL_ECHOPGM(", revision: ");
  201. SERIAL_ECHO(version[2]);
  202. SERIAL_ECHOPGM(", flavor: ");
  203. SERIAL_ECHO(version[3]);
  204. SERIAL_ECHOLNPGM("");
  205. #endif
  206. return true;
  207. }
  208. // 1 - yes, 0 - false, -1 - error;
  209. inline int8_t is_provided_version_newer(const char *version_string)
  210. {
  211. uint16_t ver_gcode[4], ver_current[4];
  212. if (! parse_version(version_string, ver_gcode))
  213. return -1;
  214. if (! parse_version_P(FW_VERSION_STR, ver_current))
  215. return 0; // this shall not happen
  216. for (uint8_t i = 0; i < 3; ++ i)
  217. if (ver_gcode[i] > ver_current[i])
  218. return 1;
  219. return 0;
  220. }
  221. bool force_selftest_if_fw_version()
  222. {
  223. //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
  224. uint16_t ver_eeprom[4];
  225. uint16_t ver_with_calibration[4] = {3, 1, 2, 4}; //hardcoded 3.1.2-RC2 version
  226. bool force_selftest = false;
  227. ver_eeprom[0] = eeprom_read_word((uint16_t*)EEPROM_FIRMWARE_VERSION_MAJOR);
  228. ver_eeprom[1] = eeprom_read_word((uint16_t*)EEPROM_FIRMWARE_VERSION_MINOR);
  229. ver_eeprom[2] = eeprom_read_word((uint16_t*)EEPROM_FIRMWARE_VERSION_REVISION);
  230. ver_eeprom[3] = eeprom_read_word((uint16_t*)EEPROM_FIRMWARE_VERSION_FLAVOR);
  231. for (uint8_t i = 0; i < 4; ++i) {
  232. if (ver_with_calibration[i] > ver_eeprom[i]) {
  233. force_selftest = true;
  234. break;
  235. }
  236. else if (ver_with_calibration[i] < ver_eeprom[i])
  237. break;
  238. }
  239. //force selftest also in case that version used before flashing new firmware was 3.2.0-RC1
  240. if ((ver_eeprom[0] == 3) && (ver_eeprom[1] == 2) && (ver_eeprom[2] == 0) && (ver_eeprom[3] == 3)) force_selftest = true;
  241. return force_selftest;
  242. }
  243. bool show_upgrade_dialog_if_version_newer(const char *version_string)
  244. {
  245. uint16_t ver_gcode[4], ver_current[4];
  246. if (! parse_version(version_string, ver_gcode)) {
  247. // SERIAL_PROTOCOLLNPGM("parse_version failed");
  248. return false;
  249. }
  250. if (! parse_version_P(FW_VERSION_STR, ver_current)) {
  251. // SERIAL_PROTOCOLLNPGM("parse_version_P failed");
  252. return false; // this shall not happen
  253. }
  254. // SERIAL_PROTOCOLLNPGM("versions parsed");
  255. bool upgrade = false;
  256. for (uint8_t i = 0; i < 4; ++ i) {
  257. if (ver_gcode[i] > ver_current[i]) {
  258. upgrade = true;
  259. break;
  260. } else if (ver_gcode[i] < ver_current[i])
  261. break;
  262. }
  263. if (upgrade) {
  264. lcd_display_message_fullscreen_P(_i("New firmware version available:"));////MSG_NEW_FIRMWARE_AVAILABLE c=20 r=2
  265. lcd_puts_at_P(0, 2, PSTR(""));
  266. for (const char *c = version_string; ! is_whitespace_or_nl_or_eol(*c); ++ c)
  267. lcd_putc(*c);
  268. lcd_puts_at_P(0, 3, _i("Please upgrade."));////MSG_NEW_FIRMWARE_PLEASE_UPGRADE c=20
  269. if((eSoundMode==e_SOUND_MODE_LOUD)||(eSoundMode==e_SOUND_MODE_ONCE))
  270. _tone(BEEPER, 1000);
  271. delay_keep_alive(50);
  272. _noTone(BEEPER);
  273. delay_keep_alive(500);
  274. if((eSoundMode==e_SOUND_MODE_LOUD)||(eSoundMode==e_SOUND_MODE_ONCE))
  275. _tone(BEEPER, 1000);
  276. delay_keep_alive(50);
  277. _noTone(BEEPER);
  278. lcd_wait_for_click_delay(30);
  279. lcd_update_enable(true);
  280. lcd_clear();
  281. lcd_update(0);
  282. }
  283. // Succeeded.
  284. return true;
  285. }
  286. void update_current_firmware_version_to_eeprom()
  287. {
  288. for (int8_t i = 0; i < FW_PRUSA3D_MAGIC_LEN; ++ i)
  289. eeprom_update_byte((uint8_t*)(EEPROM_FIRMWARE_PRUSA_MAGIC+i), pgm_read_byte(FW_PRUSA3D_MAGIC_STR+i));
  290. uint16_t ver_current[4];
  291. if (parse_version_P(FW_VERSION_STR, ver_current)) {
  292. eeprom_update_word((uint16_t*)EEPROM_FIRMWARE_VERSION_MAJOR, ver_current[0]);
  293. eeprom_update_word((uint16_t*)EEPROM_FIRMWARE_VERSION_MINOR, ver_current[1]);
  294. eeprom_update_word((uint16_t*)EEPROM_FIRMWARE_VERSION_REVISION, ver_current[2]);
  295. // See FirmwareRevisionFlavorType for the definition of firmware flavors.
  296. eeprom_update_word((uint16_t*)EEPROM_FIRMWARE_VERSION_FLAVOR, ver_current[3]);
  297. }
  298. }
  299. //-//
  300. eNOZZLE_DIAMETER eNozzleDiameter=e_NOZZLE_DIAMETER_400;
  301. eCHECK_MODE eCheckMode=e_CHECK_MODE_none;
  302. void fCheckModeInit()
  303. {
  304. eCheckMode=(eCHECK_MODE)eeprom_read_byte((uint8_t*)EEPROM_CHECK_MODE);
  305. if(eCheckMode==e_CHECK_MODE_NULL)
  306. {
  307. eCheckMode=e_CHECK_MODE_warn;
  308. eeprom_update_byte((uint8_t*)EEPROM_CHECK_MODE,(uint8_t)eCheckMode);
  309. }
  310. if(farm_mode)
  311. eCheckMode=e_CHECK_MODE_strict;
  312. eNozzleDiameter=(eNOZZLE_DIAMETER)eeprom_read_byte((uint8_t*)EEPROM_NOZZLE_DIAMETER);
  313. if((eNozzleDiameter==e_NOZZLE_DIAMETER_NULL)&& !farm_mode)
  314. {
  315. eNozzleDiameter=e_NOZZLE_DIAMETER_400;
  316. eeprom_update_byte((uint8_t*)EEPROM_NOZZLE_DIAMETER,(uint8_t)eNozzleDiameter);
  317. eeprom_update_word((uint16_t*)EEPROM_NOZZLE_DIAMETER_uM,400);
  318. }
  319. }
  320. void nozzle_diameter_check(uint16_t nDiameter)
  321. {
  322. uint16_t nDiameter_um;
  323. nDiameter_um=eeprom_read_word((uint16_t*)EEPROM_NOZZLE_DIAMETER_uM);
  324. if(nDiameter==nDiameter_um)
  325. return;
  326. switch(eCheckMode)
  327. {
  328. case e_CHECK_MODE_warn:
  329. lcd_show_fullscreen_message_and_wait_P(_i("Nozzle diameter doesn't match! Press the knob to continue."));
  330. break;
  331. case e_CHECK_MODE_strict:
  332. lcd_show_fullscreen_message_and_wait_P(_i("Nozzle diameter doesn't match! Print is aborted, press the knob."));
  333. lcd_print_stop();
  334. break;
  335. }
  336. }