From 7c84ba64a1cb494f483483fe2e70f71a55163e57 Mon Sep 17 00:00:00 2001 From: Scott Lahteine Date: Fri, 2 Oct 2015 23:21:19 -0700 Subject: [PATCH] Keep "astyled" elements in M100_*.cpp --- Marlin/M100_Free_Mem_Chk.cpp | 395 ++++++++++++++++------------------- 1 file changed, 185 insertions(+), 210 deletions(-) diff --git a/Marlin/M100_Free_Mem_Chk.cpp b/Marlin/M100_Free_Mem_Chk.cpp index 21f2b43caf..9ec1bd538d 100644 --- a/Marlin/M100_Free_Mem_Chk.cpp +++ b/Marlin/M100_Free_Mem_Chk.cpp @@ -1,5 +1,5 @@ -#define M100_FREE_MEMORY_DUMPER // Comment out to remove Dump sub-command -#define M100_FREE_MEMORY_CORRUPTOR // Comment out to remove Corrupt sub-command +#define M100_FREE_MEMORY_DUMPER // Comment out to remove Dump sub-command +#define M100_FREE_MEMORY_CORRUPTOR // Comment out to remove Corrupt sub-command // M100 Free Memory Watcher @@ -7,14 +7,14 @@ // This code watches the free memory block between the bottom of the heap and the top of the stack. // This memory block is initialized and watched via the M100 command. // -// M100 I Initializes the free memory block and prints vitals statistics about the area -// M100 F Identifies how much of the free memory block remains free and unused. It also -// detects and reports any corruption within the free memory block that may have -// happened due to errant firmware. -// M100 D Does a hex display of the free memory block along with a flag for any errant -// data that does not match the expected value. -// M100 C x Corrupts x locations within the free memory block. This is useful to check the -// correctness of the M100 F and M100 D commands. +// M100 I Initializes the free memory block and prints vitals statistics about the area +// M100 F Identifies how much of the free memory block remains free and unused. It also +// detects and reports any corruption within the free memory block that may have +// happened due to errant firmware. +// M100 D Does a hex display of the free memory block along with a flag for any errant +// data that does not match the expected value. +// M100 C x Corrupts x locations within the free memory block. This is useful to check the +// correctness of the M100 F and M100 D commands. // // Initial version by Roxy-3DPrintBoard // @@ -24,7 +24,7 @@ #include "Marlin.h" #if ENABLED(M100_FREE_MEMORY_WATCHER) -extern void *__brkval; +extern void* __brkval; extern size_t __heap_start, __heap_end, __flp; @@ -34,12 +34,12 @@ extern size_t __heap_start, __heap_end, __flp; float code_value(); long code_value_long(); -bool code_seen(char ); -void serial_echopair_P(const char *, float ); -void serial_echopair_P(const char *, double ); -void serial_echopair_P(const char *, unsigned long ); -void serial_echopair_P(const char *, int ); -void serial_echopair_P(const char *, long ); +bool code_seen(char); +void serial_echopair_P(const char*, float); +void serial_echopair_P(const char*, double); +void serial_echopair_P(const char*, unsigned long); +void serial_echopair_P(const char*, int); +void serial_echopair_P(const char*, long); @@ -48,188 +48,168 @@ void serial_echopair_P(const char *, long ); // Utility functions used by M100 to get its work done. // -unsigned char *top_of_stack(); -void prt_hex_nibble( unsigned int ); -void prt_hex_byte(unsigned int ); -void prt_hex_word(unsigned int ); -int how_many_E5s_are_here( unsigned char *); +unsigned char* top_of_stack(); +void prt_hex_nibble(unsigned int); +void prt_hex_byte(unsigned int); +void prt_hex_word(unsigned int); +int how_many_E5s_are_here(unsigned char*); -void gcode_M100() -{ -static int m100_not_initialized=1; -unsigned char *sp, *ptr; -int i, j, n; - -// -// M100 D dumps the free memory block from __brkval to the stack pointer. -// malloc() eats memory from the start of the block and the stack grows -// up from the bottom of the block. Solid 0xE5's indicate nothing has -// used that memory yet. There should not be anything but 0xE5's within -// the block of 0xE5's. If there is, that would indicate memory corruption -// probably caused by bad pointers. Any unexpected values will be flagged in -// the right hand column to help spotting them. -// - +void gcode_M100() { + static int m100_not_initialized = 1; + unsigned char* sp, *ptr; + int i, j, n; + // + // M100 D dumps the free memory block from __brkval to the stack pointer. + // malloc() eats memory from the start of the block and the stack grows + // up from the bottom of the block. Solid 0xE5's indicate nothing has + // used that memory yet. There should not be anything but 0xE5's within + // the block of 0xE5's. If there is, that would indicate memory corruption + // probably caused by bad pointers. Any unexpected values will be flagged in + // the right hand column to help spotting them. + // #if ENABLED(M100_FREE_MEMORY_DUMPER) // Disable to remove Dump sub-command - if ( code_seen('D') ) { - ptr = (unsigned char *) __brkval; - -// -// We want to start and end the dump on a nice 16 byte boundry even though -// the values we are using are not 16 byte aligned. -// - SERIAL_ECHOPGM("\n__brkval : "); - prt_hex_word( (unsigned int) ptr ); - ptr = (unsigned char *) ((unsigned long) ptr & 0xfff0); - - sp = top_of_stack(); - SERIAL_ECHOPGM("\nStack Pointer : "); - prt_hex_word( (unsigned int) sp ); - SERIAL_ECHOPGM("\n"); - - sp = (unsigned char *) ((unsigned long) sp | 0x000f); - n = sp - ptr; -// -// This is the main loop of the Dump command. -// - while ( ptr < sp ) { - prt_hex_word( (unsigned int) ptr); // Print the address - SERIAL_ECHOPGM(":"); - for(i=0; i<16; i++) { // and 16 data bytes - prt_hex_byte( *(ptr+i)); - SERIAL_ECHOPGM(" "); - delay(2); - } - - SERIAL_ECHO("|"); // now show where non 0xE5's are - for(i=0; i<16; i++) { - delay(2); - if ( *(ptr+i)==0xe5) - SERIAL_ECHOPGM(" "); - else - SERIAL_ECHOPGM("?"); - } - SERIAL_ECHO("\n"); - - ptr += 16; - delay(2); - } - SERIAL_ECHOLNPGM("Done.\n"); - return; - } + if (code_seen('D')) { + ptr = (unsigned char*) __brkval; + // + // We want to start and end the dump on a nice 16 byte boundry even though + // the values we are using are not 16 byte aligned. + // + SERIAL_ECHOPGM("\n__brkval : "); + prt_hex_word((unsigned int) ptr); + ptr = (unsigned char*)((unsigned long) ptr & 0xfff0); + sp = top_of_stack(); + SERIAL_ECHOPGM("\nStack Pointer : "); + prt_hex_word((unsigned int) sp); + SERIAL_ECHOPGM("\n"); + sp = (unsigned char*)((unsigned long) sp | 0x000f); + n = sp - ptr; + // + // This is the main loop of the Dump command. + // + while (ptr < sp) { + prt_hex_word((unsigned int) ptr); // Print the address + SERIAL_ECHOPGM(":"); + for (i = 0; i < 16; i++) { // and 16 data bytes + prt_hex_byte(*(ptr + i)); + SERIAL_ECHOPGM(" "); + delay(2); + } + SERIAL_ECHO("|"); // now show where non 0xE5's are + for (i = 0; i < 16; i++) { + delay(2); + if (*(ptr + i) == 0xe5) + SERIAL_ECHOPGM(" "); + else + SERIAL_ECHOPGM("?"); + } + SERIAL_ECHO("\n"); + ptr += 16; + delay(2); + } + SERIAL_ECHOLNPGM("Done.\n"); + return; + } #endif - -// -// M100 F requests the code to return the number of free bytes in the memory pool along with -// other vital statistics that define the memory pool. -// - if ( code_seen('F') ) { - int max_addr = (int) __brkval; - int max_cnt = 0; - int block_cnt = 0; - ptr = (unsigned char *) __brkval; - sp = top_of_stack(); - n = sp - ptr; - -// Scan through the range looking for the biggest block of 0xE5's we can find - - for(i=0; i8) { - SERIAL_ECHOPAIR("Found ", j ); - SERIAL_ECHOPGM(" bytes free at 0x"); - prt_hex_word( (int) ptr+i ); - SERIAL_ECHOPGM("\n"); - i += j; - block_cnt++; - } - if ( j>max_cnt) { // We don't do anything with this information yet - max_cnt = j; // but we do know where the biggest free memory block is. - max_addr = (int) ptr+i; - } - } - } - if (block_cnt>1) - SERIAL_ECHOLNPGM("\nMemory Corruption detected in free memory area.\n"); - - SERIAL_ECHO("\nDone.\n"); - return; - } -// -// M100 C x Corrupts x locations in the free memory pool and reports the locations of the corruption. -// This is useful to check the correctness of the M100 D and the M100 F commands. -// + // + // M100 F requests the code to return the number of free bytes in the memory pool along with + // other vital statistics that define the memory pool. + // + if (code_seen('F')) { + int max_addr = (int) __brkval; + int max_cnt = 0; + int block_cnt = 0; + ptr = (unsigned char*) __brkval; + sp = top_of_stack(); + n = sp - ptr; + // Scan through the range looking for the biggest block of 0xE5's we can find + for (i = 0; i < n; i++) { + if (*(ptr + i) == (unsigned char) 0xe5) { + j = how_many_E5s_are_here((unsigned char*) ptr + i); + if (j > 8) { + SERIAL_ECHOPAIR("Found ", j); + SERIAL_ECHOPGM(" bytes free at 0x"); + prt_hex_word((int) ptr + i); + SERIAL_ECHOPGM("\n"); + i += j; + block_cnt++; + } + if (j > max_cnt) { // We don't do anything with this information yet + max_cnt = j; // but we do know where the biggest free memory block is. + max_addr = (int) ptr + i; + } + } + } + if (block_cnt > 1) + SERIAL_ECHOLNPGM("\nMemory Corruption detected in free memory area.\n"); + SERIAL_ECHO("\nDone.\n"); + return; + } + // + // M100 C x Corrupts x locations in the free memory pool and reports the locations of the corruption. + // This is useful to check the correctness of the M100 D and the M100 F commands. + // #if ENABLED(M100_FREE_MEMORY_CORRUPTOR) - if ( code_seen('C') ) { - int x; // x gets the # of locations to corrupt within the memory pool - x = code_value(); - SERIAL_ECHOLNPGM("Corrupting free memory block.\n"); - ptr = (unsigned char *) __brkval; - SERIAL_ECHOPAIR("\n__brkval : ",(long) ptr ); - ptr += 8; - - sp = top_of_stack(); - SERIAL_ECHOPAIR("\nStack Pointer : ",(long) sp ); - SERIAL_ECHOLNPGM("\n"); - - n = sp - ptr - 64; // -64 just to keep us from finding interrupt activity that - // has altered the stack. - j = n / (x+1); - for(i=1; i<=x; i++) { - *(ptr+(i*j)) = i; - SERIAL_ECHO("\nCorrupting address: 0x"); - prt_hex_word( (unsigned int) (ptr+(i*j)) ); - } - SERIAL_ECHOLNPGM("\n"); - return; - } + if (code_seen('C')) { + int x; // x gets the # of locations to corrupt within the memory pool + x = code_value(); + SERIAL_ECHOLNPGM("Corrupting free memory block.\n"); + ptr = (unsigned char*) __brkval; + SERIAL_ECHOPAIR("\n__brkval : ", (long) ptr); + ptr += 8; + sp = top_of_stack(); + SERIAL_ECHOPAIR("\nStack Pointer : ", (long) sp); + SERIAL_ECHOLNPGM("\n"); + n = sp - ptr - 64; // -64 just to keep us from finding interrupt activity that + // has altered the stack. + j = n / (x + 1); + for (i = 1; i <= x; i++) { + *(ptr + (i * j)) = i; + SERIAL_ECHO("\nCorrupting address: 0x"); + prt_hex_word((unsigned int)(ptr + (i * j))); + } + SERIAL_ECHOLNPGM("\n"); + return; + } #endif - -// -// M100 I Initializes the free memory pool so it can be watched and prints vital -// statistics that define the free memory pool. -// - if (m100_not_initialized || code_seen('I') ) { // If no sub-command is specified, the first time - SERIAL_ECHOLNPGM("Initializing free memory block.\n"); // this happens, it will Initialize. - ptr = (unsigned char *) __brkval; // Repeated M100 with no sub-command will not destroy the - SERIAL_ECHOPAIR("\n__brkval : ",(long) ptr ); // state of the initialized free memory pool. - ptr += 8; - - sp = top_of_stack(); - SERIAL_ECHOPAIR("\nStack Pointer : ",(long) sp ); - SERIAL_ECHOLNPGM("\n"); - - n = sp - ptr - 64; // -64 just to keep us from finding interrupt activity that - // has altered the stack. - - SERIAL_ECHO( n ); - SERIAL_ECHOLNPGM(" bytes of memory initialized.\n"); - - for(i=0; i> 4 ); - prt_hex_nibble( b & 0x0f ); +void prt_hex_byte(unsigned int b) { + prt_hex_nibble((b & 0xf0) >> 4); + prt_hex_nibble(b & 0x0f); } -void prt_hex_word(unsigned int w) -{ - prt_hex_byte( ( w & 0xff00 ) >> 8 ); - prt_hex_byte( w & 0x0ff ); +void prt_hex_word(unsigned int w) { + prt_hex_byte((w & 0xff00) >> 8); + prt_hex_byte(w & 0x0ff); } // how_many_E5s_are_here() is a utility function to easily find out how many 0xE5's are // at the specified location. Having this logic as a function simplifies the search code. // -int how_many_E5s_are_here( unsigned char *p) -{ -int n; - - for(n=0; n<32000; n++) { - if ( *(p+n) != (unsigned char) 0xe5) - return n-1; - } - return -1; +int how_many_E5s_are_here(unsigned char* p) { + int n; + for (n = 0; n < 32000; n++) { + if (*(p + n) != (unsigned char) 0xe5) + return n - 1; + } + return -1; } #endif