My Marlin configs for Fabrikator Mini and CTC i3 Pro B
Vous ne pouvez pas sélectionner plus de 25 sujets Les noms de sujets doivent commencer par une lettre ou un nombre, peuvent contenir des tirets ('-') et peuvent comporter jusqu'à 35 caractères.

M100_Free_Mem_Chk.cpp 7.9KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252
  1. #define M100_FREE_MEMORY_DUMPER // Comment out to remove Dump sub-command
  2. #define M100_FREE_MEMORY_CORRUPTOR // Comment out to remove Corrupt sub-command
  3. // M100 Free Memory Watcher
  4. //
  5. // This code watches the free memory block between the bottom of the heap and the top of the stack.
  6. // This memory block is initialized and watched via the M100 command.
  7. //
  8. // M100 I Initializes the free memory block and prints vitals statistics about the area
  9. // M100 F Identifies how much of the free memory block remains free and unused. It also
  10. // detects and reports any corruption within the free memory block that may have
  11. // happened due to errant firmware.
  12. // M100 D Does a hex display of the free memory block along with a flag for any errant
  13. // data that does not match the expected value.
  14. // M100 C x Corrupts x locations within the free memory block. This is useful to check the
  15. // correctness of the M100 F and M100 D commands.
  16. //
  17. // Initial version by Roxy-3DPrintBoard
  18. //
  19. //
  20. #include "Marlin.h"
  21. #if ENABLED(M100_FREE_MEMORY_WATCHER)
  22. extern void* __brkval;
  23. extern size_t __heap_start, __heap_end, __flp;
  24. //
  25. // Declare all the functions we need from Marlin_Main.cpp to do the work!
  26. //
  27. float code_value();
  28. long code_value_long();
  29. bool code_seen(char);
  30. void serial_echopair_P(const char*, float);
  31. void serial_echopair_P(const char*, double);
  32. void serial_echopair_P(const char*, unsigned long);
  33. void serial_echopair_P(const char*, int);
  34. void serial_echopair_P(const char*, long);
  35. //
  36. // Utility functions used by M100 to get its work done.
  37. //
  38. unsigned char* top_of_stack();
  39. void prt_hex_nibble(unsigned int);
  40. void prt_hex_byte(unsigned int);
  41. void prt_hex_word(unsigned int);
  42. int how_many_E5s_are_here(unsigned char*);
  43. void gcode_M100() {
  44. static int m100_not_initialized = 1;
  45. unsigned char* sp, *ptr;
  46. int i, j, n;
  47. //
  48. // M100 D dumps the free memory block from __brkval to the stack pointer.
  49. // malloc() eats memory from the start of the block and the stack grows
  50. // up from the bottom of the block. Solid 0xE5's indicate nothing has
  51. // used that memory yet. There should not be anything but 0xE5's within
  52. // the block of 0xE5's. If there is, that would indicate memory corruption
  53. // probably caused by bad pointers. Any unexpected values will be flagged in
  54. // the right hand column to help spotting them.
  55. //
  56. #if ENABLED(M100_FREE_MEMORY_DUMPER) // Disable to remove Dump sub-command
  57. if (code_seen('D')) {
  58. ptr = (unsigned char*) __brkval;
  59. //
  60. // We want to start and end the dump on a nice 16 byte boundry even though
  61. // the values we are using are not 16 byte aligned.
  62. //
  63. SERIAL_ECHOPGM("\n__brkval : ");
  64. prt_hex_word((unsigned int) ptr);
  65. ptr = (unsigned char*)((unsigned long) ptr & 0xfff0);
  66. sp = top_of_stack();
  67. SERIAL_ECHOPGM("\nStack Pointer : ");
  68. prt_hex_word((unsigned int) sp);
  69. SERIAL_ECHOPGM("\n");
  70. sp = (unsigned char*)((unsigned long) sp | 0x000f);
  71. n = sp - ptr;
  72. //
  73. // This is the main loop of the Dump command.
  74. //
  75. while (ptr < sp) {
  76. prt_hex_word((unsigned int) ptr); // Print the address
  77. SERIAL_ECHOPGM(":");
  78. for (i = 0; i < 16; i++) { // and 16 data bytes
  79. prt_hex_byte(*(ptr + i));
  80. SERIAL_ECHOPGM(" ");
  81. delay(2);
  82. }
  83. SERIAL_ECHO("|"); // now show where non 0xE5's are
  84. for (i = 0; i < 16; i++) {
  85. delay(2);
  86. if (*(ptr + i) == 0xe5)
  87. SERIAL_ECHOPGM(" ");
  88. else
  89. SERIAL_ECHOPGM("?");
  90. }
  91. SERIAL_ECHO("\n");
  92. ptr += 16;
  93. delay(2);
  94. }
  95. SERIAL_ECHOLNPGM("Done.\n");
  96. return;
  97. }
  98. #endif
  99. //
  100. // M100 F requests the code to return the number of free bytes in the memory pool along with
  101. // other vital statistics that define the memory pool.
  102. //
  103. if (code_seen('F')) {
  104. int max_addr = (int) __brkval;
  105. int max_cnt = 0;
  106. int block_cnt = 0;
  107. ptr = (unsigned char*) __brkval;
  108. sp = top_of_stack();
  109. n = sp - ptr;
  110. // Scan through the range looking for the biggest block of 0xE5's we can find
  111. for (i = 0; i < n; i++) {
  112. if (*(ptr + i) == (unsigned char) 0xe5) {
  113. j = how_many_E5s_are_here((unsigned char*) ptr + i);
  114. if (j > 8) {
  115. SERIAL_ECHOPAIR("Found ", j);
  116. SERIAL_ECHOPGM(" bytes free at 0x");
  117. prt_hex_word((int) ptr + i);
  118. SERIAL_ECHOPGM("\n");
  119. i += j;
  120. block_cnt++;
  121. }
  122. if (j > max_cnt) { // We don't do anything with this information yet
  123. max_cnt = j; // but we do know where the biggest free memory block is.
  124. max_addr = (int) ptr + i;
  125. }
  126. }
  127. }
  128. if (block_cnt > 1)
  129. SERIAL_ECHOLNPGM("\nMemory Corruption detected in free memory area.\n");
  130. SERIAL_ECHO("\nDone.\n");
  131. return;
  132. }
  133. //
  134. // M100 C x Corrupts x locations in the free memory pool and reports the locations of the corruption.
  135. // This is useful to check the correctness of the M100 D and the M100 F commands.
  136. //
  137. #if ENABLED(M100_FREE_MEMORY_CORRUPTOR)
  138. if (code_seen('C')) {
  139. int x; // x gets the # of locations to corrupt within the memory pool
  140. x = code_value();
  141. SERIAL_ECHOLNPGM("Corrupting free memory block.\n");
  142. ptr = (unsigned char*) __brkval;
  143. SERIAL_ECHOPAIR("\n__brkval : ", (long) ptr);
  144. ptr += 8;
  145. sp = top_of_stack();
  146. SERIAL_ECHOPAIR("\nStack Pointer : ", (long) sp);
  147. SERIAL_ECHOLNPGM("\n");
  148. n = sp - ptr - 64; // -64 just to keep us from finding interrupt activity that
  149. // has altered the stack.
  150. j = n / (x + 1);
  151. for (i = 1; i <= x; i++) {
  152. *(ptr + (i * j)) = i;
  153. SERIAL_ECHO("\nCorrupting address: 0x");
  154. prt_hex_word((unsigned int)(ptr + (i * j)));
  155. }
  156. SERIAL_ECHOLNPGM("\n");
  157. return;
  158. }
  159. #endif
  160. //
  161. // M100 I Initializes the free memory pool so it can be watched and prints vital
  162. // statistics that define the free memory pool.
  163. //
  164. if (m100_not_initialized || code_seen('I')) { // If no sub-command is specified, the first time
  165. SERIAL_ECHOLNPGM("Initializing free memory block.\n"); // this happens, it will Initialize.
  166. ptr = (unsigned char*) __brkval; // Repeated M100 with no sub-command will not destroy the
  167. SERIAL_ECHOPAIR("\n__brkval : ", (long) ptr); // state of the initialized free memory pool.
  168. ptr += 8;
  169. sp = top_of_stack();
  170. SERIAL_ECHOPAIR("\nStack Pointer : ", (long) sp);
  171. SERIAL_ECHOLNPGM("\n");
  172. n = sp - ptr - 64; // -64 just to keep us from finding interrupt activity that
  173. // has altered the stack.
  174. SERIAL_ECHO(n);
  175. SERIAL_ECHOLNPGM(" bytes of memory initialized.\n");
  176. for (i = 0; i < n; i++)
  177. *(ptr + i) = (unsigned char) 0xe5;
  178. for (i = 0; i < n; i++) {
  179. if (*(ptr + i) != (unsigned char) 0xe5) {
  180. SERIAL_ECHOPAIR("? address : ", (unsigned long) ptr + i);
  181. SERIAL_ECHOPAIR("=", *(ptr + i));
  182. SERIAL_ECHOLNPGM("\n");
  183. }
  184. }
  185. m100_not_initialized = 0;
  186. SERIAL_ECHOLNPGM("Done.\n");
  187. return;
  188. }
  189. return;
  190. }
  191. // top_of_stack() returns the location of a variable on its stack frame. The value returned is above
  192. // the stack once the function returns to the caller.
  193. unsigned char* top_of_stack() {
  194. unsigned char x;
  195. return &x + 1; // x is pulled on return;
  196. }
  197. //
  198. // 3 support routines to print hex numbers. We can print a nibble, byte and word
  199. //
  200. void prt_hex_nibble(unsigned int n) {
  201. if (n <= 9)
  202. SERIAL_ECHO(n);
  203. else
  204. SERIAL_ECHO((char)('A' + n - 10));
  205. delay(2);
  206. }
  207. void prt_hex_byte(unsigned int b) {
  208. prt_hex_nibble((b & 0xf0) >> 4);
  209. prt_hex_nibble(b & 0x0f);
  210. }
  211. void prt_hex_word(unsigned int w) {
  212. prt_hex_byte((w & 0xff00) >> 8);
  213. prt_hex_byte(w & 0x0ff);
  214. }
  215. // how_many_E5s_are_here() is a utility function to easily find out how many 0xE5's are
  216. // at the specified location. Having this logic as a function simplifies the search code.
  217. //
  218. int how_many_E5s_are_here(unsigned char* p) {
  219. int n;
  220. for (n = 0; n < 32000; n++) {
  221. if (*(p + n) != (unsigned char) 0xe5)
  222. return n - 1;
  223. }
  224. return -1;
  225. }
  226. #endif