Merge pull request #7471 from thinkyhead/bf1_cleanups_aug9

Miscellaneous style tweaks

Marlin/Conditionals_post.h

   #endif
   #define WRITE_FAN_N(n, v) WRITE_FAN##n(v)
 
-
-  /**
-   * Heater & Fan Pausing
-   */
-  #if FAN_COUNT == 0
-    #undef PROBING_FANS_OFF
-  #endif
-  #define QUIET_PROBING (HAS_BED_PROBE && (ENABLED(PROBING_HEATERS_OFF) || ENABLED(PROBING_FANS_OFF) || DELAY_BEFORE_PROBING > 0))
-  #define HEATER_IDLE_HANDLER (ENABLED(ADVANCED_PAUSE_FEATURE) || ENABLED(PROBING_HEATERS_OFF))
-
   /**
    * Servos and probes
    */
   #endif
 
   #define PROBE_PIN_CONFIGURED (HAS_Z_MIN_PROBE_PIN || (HAS_Z_MIN && ENABLED(Z_MIN_PROBE_USES_Z_MIN_ENDSTOP_PIN)))
-
   #define HAS_BED_PROBE (PROBE_SELECTED && PROBE_PIN_CONFIGURED && DISABLED(PROBE_MANUALLY))
 
   #if ENABLED(Z_PROBE_ALLEN_KEY)
   #endif
 
   /**
+   * Heater & Fan Pausing
+   */
+  #if FAN_COUNT == 0
+    #undef PROBING_FANS_OFF
+  #endif
+  #define QUIET_PROBING (HAS_BED_PROBE && (ENABLED(PROBING_HEATERS_OFF) || ENABLED(PROBING_FANS_OFF) || DELAY_BEFORE_PROBING > 0))
+  #define HEATER_IDLE_HANDLER (ENABLED(ADVANCED_PAUSE_FEATURE) || ENABLED(PROBING_HEATERS_OFF))
+
+  /**
    * Delta radius/rod trimmers/angle trimmers
    */
   #if ENABLED(DELTA)

Marlin/Marlin_main.cpp

 
     const float nx = lx - (X_PROBE_OFFSET_FROM_EXTRUDER), ny = ly - (Y_PROBE_OFFSET_FROM_EXTRUDER);
 
-    if (printable) {
-      if (!position_is_reachable_by_probe_xy(lx, ly)) return NAN;
-    }
-    else if (!position_is_reachable_xy(nx, ny)) return NAN;
+    if (printable
+      ? !position_is_reachable_xy(nx, ny)
+      : !position_is_reachable_by_probe_xy(lx, ly)
+    ) return NAN;
+
 
     const float old_feedrate_mm_s = feedrate_mm_s;
 

Marlin/Sd2Card.cpp

   //------------------------------------------------------------------------------
   /** SPI receive a byte */
   static uint8_t spiRec() {
-    SPDR = 0XFF;
+    SPDR = 0xFF;
     while (!TEST(SPSR, SPIF)) { /* Intentionally left empty */ }
     return SPDR;
   }
   static inline __attribute__((always_inline))
   void spiRead(uint8_t* buf, uint16_t nbyte) {
     if (nbyte-- == 0) return;
-    SPDR = 0XFF;
+    SPDR = 0xFF;
     for (uint16_t i = 0; i < nbyte; i++) {
       while (!TEST(SPSR, SPIF)) { /* Intentionally left empty */ }
       buf[i] = SPDR;
-      SPDR = 0XFF;
+      SPDR = 0xFF;
     }
     while (!TEST(SPSR, SPIF)) { /* Intentionally left empty */ }
     buf[nbyte] = SPDR;
     uint8_t data = 0;
     // no interrupts during byte receive - about 8 us
     cli();
-    // output pin high - like sending 0XFF
+    // output pin high - like sending 0xFF
     WRITE(SPI_MOSI_PIN, HIGH);
 
     for (uint8_t i = 0; i < 8; i++) {
     for (uint8_t i = 0; i < 8; i++) {
       WRITE(SPI_SCK_PIN, LOW);
 
-      WRITE(SPI_MOSI_PIN, data & 0X80);
+      WRITE(SPI_MOSI_PIN, data & 0x80);
 
       data <<= 1;
 
   for (int8_t s = 24; s >= 0; s -= 8) spiSend(arg >> s);
 
   // send CRC
-  uint8_t crc = 0XFF;
-  if (cmd == CMD0) crc = 0X95;  // correct crc for CMD0 with arg 0
-  if (cmd == CMD8) crc = 0X87;  // correct crc for CMD8 with arg 0X1AA
+  uint8_t crc = 0xFF;
+  if (cmd == CMD0) crc = 0x95;  // correct crc for CMD0 with arg 0
+  if (cmd == CMD8) crc = 0x87;  // correct crc for CMD8 with arg 0x1AA
   spiSend(crc);
 
   // skip stuff byte for stop read
   if (cmd == CMD12) spiRec();
 
   // wait for response
-  for (uint8_t i = 0; ((status_ = spiRec()) & 0X80) && i != 0XFF; i++) { /* Intentionally left empty */ }
+  for (uint8_t i = 0; ((status_ = spiRec()) & 0x80) && i != 0xFF; i++) { /* Intentionally left empty */ }
   return status_;
 }
 //------------------------------------------------------------------------------
  */
 bool Sd2Card::erase(uint32_t firstBlock, uint32_t lastBlock) {
   csd_t csd;
-  if (!readCSD(&csd)) goto fail;
+  if (!readCSD(&csd)) goto FAIL;
   // check for single block erase
   if (!csd.v1.erase_blk_en) {
     // erase size mask
     if ((firstBlock & m) != 0 || ((lastBlock + 1) & m) != 0) {
       // error card can't erase specified area
       error(SD_CARD_ERROR_ERASE_SINGLE_BLOCK);
-      goto fail;
+      goto FAIL;
     }
   }
   if (type_ != SD_CARD_TYPE_SDHC) {
       || cardCommand(CMD33, lastBlock)
       || cardCommand(CMD38, 0)) {
     error(SD_CARD_ERROR_ERASE);
-    goto fail;
+    goto FAIL;
   }
   if (!waitNotBusy(SD_ERASE_TIMEOUT)) {
     error(SD_CARD_ERROR_ERASE_TIMEOUT);
-    goto fail;
+    goto FAIL;
   }
   chipSelectHigh();
   return true;
-fail:
+  FAIL:
   chipSelectHigh();
   return false;
 }
   #endif  // SOFTWARE_SPI
 
   // must supply min of 74 clock cycles with CS high.
-  for (uint8_t i = 0; i < 10; i++) spiSend(0XFF);
+  for (uint8_t i = 0; i < 10; i++) spiSend(0xFF);
 
   // command to go idle in SPI mode
   while ((status_ = cardCommand(CMD0, 0)) != R1_IDLE_STATE) {
     if (((uint16_t)millis() - t0) > SD_INIT_TIMEOUT) {
       error(SD_CARD_ERROR_CMD0);
-      goto fail;
+      goto FAIL;
     }
   }
   // check SD version
   else {
     // only need last byte of r7 response
     for (uint8_t i = 0; i < 4; i++) status_ = spiRec();
-    if (status_ != 0XAA) {
+    if (status_ != 0xAA) {
       error(SD_CARD_ERROR_CMD8);
-      goto fail;
+      goto FAIL;
     }
     type(SD_CARD_TYPE_SD2);
   }
   // initialize card and send host supports SDHC if SD2
-  arg = type() == SD_CARD_TYPE_SD2 ? 0X40000000 : 0;
+  arg = type() == SD_CARD_TYPE_SD2 ? 0x40000000 : 0;
 
   while ((status_ = cardAcmd(ACMD41, arg)) != R1_READY_STATE) {
     // check for timeout
     if (((uint16_t)millis() - t0) > SD_INIT_TIMEOUT) {
       error(SD_CARD_ERROR_ACMD41);
-      goto fail;
+      goto FAIL;
     }
   }
   // if SD2 read OCR register to check for SDHC card
   if (type() == SD_CARD_TYPE_SD2) {
     if (cardCommand(CMD58, 0)) {
       error(SD_CARD_ERROR_CMD58);
-      goto fail;
+      goto FAIL;
     }
-    if ((spiRec() & 0XC0) == 0XC0) type(SD_CARD_TYPE_SDHC);
+    if ((spiRec() & 0xC0) == 0xC0) type(SD_CARD_TYPE_SDHC);
     // discard rest of ocr - contains allowed voltage range
     for (uint8_t i = 0; i < 3; i++) spiRec();
   }
     return true;
   #endif  // SOFTWARE_SPI
 
-fail:
+  FAIL:
   chipSelectHigh();
   return false;
 }
 static uint16_t CRC_CCITT(const uint8_t* data, size_t n) {
   uint16_t crc = 0;
   for (size_t i = 0; i < n; i++) {
-    crc = pgm_read_word(&crctab[(crc >> 8 ^ data[i]) & 0XFF]) ^ (crc << 8);
+    crc = pgm_read_word(&crctab[(crc >> 8 ^ data[i]) & 0xFF]) ^ (crc << 8);
   }
   return crc;
 }
   while ((status_ = spiRec()) == 0XFF) {
     if (((uint16_t)millis() - t0) > SD_READ_TIMEOUT) {
       error(SD_CARD_ERROR_READ_TIMEOUT);
-      goto fail;
+      goto FAIL;
     }
   }
   if (status_ != DATA_START_BLOCK) {
     error(SD_CARD_ERROR_READ);
-    goto fail;
+    goto FAIL;
   }
   // transfer data
   spiRead(dst, count);
     recvCrc |= spiRec();
     if (calcCrc != recvCrc) {
       error(SD_CARD_ERROR_CRC);
-      goto fail;
+      goto FAIL;
     }
   }
 #else
   // Send an additional dummy byte, required by Toshiba Flash Air SD Card
   spiSend(0XFF);
   return true;
-fail:
+  FAIL:
   chipSelectHigh();
   // Send an additional dummy byte, required by Toshiba Flash Air SD Card
   spiSend(0XFF);
   uint8_t* dst = reinterpret_cast<uint8_t*>(buf);
   if (cardCommand(cmd, 0)) {
     error(SD_CARD_ERROR_READ_REG);
-    goto fail;
+    goto FAIL;
   }
   return readData(dst, 16);
-fail:
+  FAIL:
   chipSelectHigh();
   return false;
 }
   if (type() != SD_CARD_TYPE_SDHC) blockNumber <<= 9;
   if (cardCommand(CMD18, blockNumber)) {
     error(SD_CARD_ERROR_CMD18);
-    goto fail;
+    goto FAIL;
   }
   chipSelectHigh();
   return true;
-fail:
+  FAIL:
   chipSelectHigh();
   return false;
 }
   chipSelectLow();
   if (cardCommand(CMD12, 0)) {
     error(SD_CARD_ERROR_CMD12);
-    goto fail;
+    goto FAIL;
   }
   chipSelectHigh();
   return true;
-fail:
+  FAIL:
   chipSelectHigh();
   return false;
 }
 bool Sd2Card::waitNotBusy(uint16_t timeoutMillis) {
   uint16_t t0 = millis();
   while (spiRec() != 0XFF) {
-    if (((uint16_t)millis() - t0) >= timeoutMillis) goto fail;
+    if (((uint16_t)millis() - t0) >= timeoutMillis) goto FAIL;
   }
   return true;
-fail:
+  FAIL:
   return false;
 }
 //------------------------------------------------------------------------------
   if (type() != SD_CARD_TYPE_SDHC) blockNumber <<= 9;
   if (cardCommand(CMD24, blockNumber)) {
     error(SD_CARD_ERROR_CMD24);
-    goto fail;
+    goto FAIL;
   }
-  if (!writeData(DATA_START_BLOCK, src)) goto fail;
+  if (!writeData(DATA_START_BLOCK, src)) goto FAIL;
 
   // wait for flash programming to complete
   if (!waitNotBusy(SD_WRITE_TIMEOUT)) {
     error(SD_CARD_ERROR_WRITE_TIMEOUT);
-    goto fail;
+    goto FAIL;
   }
   // response is r2 so get and check two bytes for nonzero
   if (cardCommand(CMD13, 0) || spiRec()) {
     error(SD_CARD_ERROR_WRITE_PROGRAMMING);
-    goto fail;
+    goto FAIL;
   }
   chipSelectHigh();
   return true;
-fail:
+  FAIL:
   chipSelectHigh();
   return false;
 }
 bool Sd2Card::writeData(const uint8_t* src) {
   chipSelectLow();
   // wait for previous write to finish
-  if (!waitNotBusy(SD_WRITE_TIMEOUT)) goto fail;
-  if (!writeData(WRITE_MULTIPLE_TOKEN, src)) goto fail;
+  if (!waitNotBusy(SD_WRITE_TIMEOUT)) goto FAIL;
+  if (!writeData(WRITE_MULTIPLE_TOKEN, src)) goto FAIL;
   chipSelectHigh();
   return true;
-fail:
+  FAIL:
   error(SD_CARD_ERROR_WRITE_MULTIPLE);
   chipSelectHigh();
   return false;
   status_ = spiRec();
   if ((status_ & DATA_RES_MASK) != DATA_RES_ACCEPTED) {
     error(SD_CARD_ERROR_WRITE);
-    goto fail;
+    goto FAIL;
   }
   return true;
-fail:
+  FAIL:
   chipSelectHigh();
   return false;
 }
   // send pre-erase count
   if (cardAcmd(ACMD23, eraseCount)) {
     error(SD_CARD_ERROR_ACMD23);
-    goto fail;
+    goto FAIL;
   }
   // use address if not SDHC card
   if (type() != SD_CARD_TYPE_SDHC) blockNumber <<= 9;
   if (cardCommand(CMD25, blockNumber)) {
     error(SD_CARD_ERROR_CMD25);
-    goto fail;
+    goto FAIL;
   }
   chipSelectHigh();
   return true;
-fail:
+  FAIL:
   chipSelectHigh();
   return false;
 }
  */
 bool Sd2Card::writeStop() {
   chipSelectLow();
-  if (!waitNotBusy(SD_WRITE_TIMEOUT)) goto fail;
+  if (!waitNotBusy(SD_WRITE_TIMEOUT)) goto FAIL;
   spiSend(STOP_TRAN_TOKEN);
-  if (!waitNotBusy(SD_WRITE_TIMEOUT)) goto fail;
+  if (!waitNotBusy(SD_WRITE_TIMEOUT)) goto FAIL;
   chipSelectHigh();
   return true;
-fail:
+  FAIL:
   error(SD_CARD_ERROR_STOP_TRAN);
   chipSelectHigh();
   return false;

Marlin/Sd2Card.h

 /** card returned an error token instead of read data */
 uint8_t const SD_CARD_ERROR_READ = 0XF;
 /** read CID or CSD failed */
-uint8_t const SD_CARD_ERROR_READ_REG = 0X10;
+uint8_t const SD_CARD_ERROR_READ_REG = 0x10;
 /** timeout while waiting for start of read data */
-uint8_t const SD_CARD_ERROR_READ_TIMEOUT = 0X11;
+uint8_t const SD_CARD_ERROR_READ_TIMEOUT = 0x11;
 /** card did not accept STOP_TRAN_TOKEN */
-uint8_t const SD_CARD_ERROR_STOP_TRAN = 0X12;
+uint8_t const SD_CARD_ERROR_STOP_TRAN = 0x12;
 /** card returned an error token as a response to a write operation */
-uint8_t const SD_CARD_ERROR_WRITE = 0X13;
+uint8_t const SD_CARD_ERROR_WRITE = 0x13;
 /** attempt to write protected block zero */
-uint8_t const SD_CARD_ERROR_WRITE_BLOCK_ZERO = 0X14;  // REMOVE - not used
+uint8_t const SD_CARD_ERROR_WRITE_BLOCK_ZERO = 0x14;  // REMOVE - not used
 /** card did not go ready for a multiple block write */
-uint8_t const SD_CARD_ERROR_WRITE_MULTIPLE = 0X15;
+uint8_t const SD_CARD_ERROR_WRITE_MULTIPLE = 0x15;
 /** card returned an error to a CMD13 status check after a write */
-uint8_t const SD_CARD_ERROR_WRITE_PROGRAMMING = 0X16;
+uint8_t const SD_CARD_ERROR_WRITE_PROGRAMMING = 0x16;
 /** timeout occurred during write programming */
-uint8_t const SD_CARD_ERROR_WRITE_TIMEOUT = 0X17;
+uint8_t const SD_CARD_ERROR_WRITE_TIMEOUT = 0x17;
 /** incorrect rate selected */
-uint8_t const SD_CARD_ERROR_SCK_RATE = 0X18;
+uint8_t const SD_CARD_ERROR_SCK_RATE = 0x18;
 /** init() not called */
-uint8_t const SD_CARD_ERROR_INIT_NOT_CALLED = 0X19;
+uint8_t const SD_CARD_ERROR_INIT_NOT_CALLED = 0x19;
 /** crc check error */
-uint8_t const SD_CARD_ERROR_CRC = 0X20;
+uint8_t const SD_CARD_ERROR_CRC = 0x20;
 //------------------------------------------------------------------------------
 // card types
 /** Standard capacity V1 SD card */

Marlin/SdBaseFile.h

 
 // use the gnu style oflag in open()
 /** open() oflag for reading */
-uint8_t const O_READ = 0X01;
+uint8_t const O_READ = 0x01;
 /** open() oflag - same as O_IN */
 uint8_t const O_RDONLY = O_READ;
 /** open() oflag for write */
-uint8_t const O_WRITE = 0X02;
+uint8_t const O_WRITE = 0x02;
 /** open() oflag - same as O_WRITE */
 uint8_t const O_WRONLY = O_WRITE;
 /** open() oflag for reading and writing */
 /** open() oflag mask for access modes */
 uint8_t const O_ACCMODE = (O_READ | O_WRITE);
 /** The file offset shall be set to the end of the file prior to each write. */
-uint8_t const O_APPEND = 0X04;
+uint8_t const O_APPEND = 0x04;
 /** synchronous writes - call sync() after each write */
-uint8_t const O_SYNC = 0X08;
+uint8_t const O_SYNC = 0x08;
 /** truncate the file to zero length */
-uint8_t const O_TRUNC = 0X10;
+uint8_t const O_TRUNC = 0x10;
 /** set the initial position at the end of the file */
-uint8_t const O_AT_END = 0X20;
+uint8_t const O_AT_END = 0x20;
 /** create the file if nonexistent */
-uint8_t const O_CREAT = 0X40;
+uint8_t const O_CREAT = 0x40;
 /** If O_CREAT and O_EXCL are set, open() shall fail if the file exists */
-uint8_t const O_EXCL = 0X80;
+uint8_t const O_EXCL = 0x80;
 
 // SdBaseFile class static and const definitions
 // flags for ls()
  * \return Extracted day [1,31]
  */
 static inline uint8_t FAT_DAY(uint16_t fatDate) {
-  return fatDate & 0X1F;
+  return fatDate & 0x1F;
 }
 /** time field for FAT directory entry
  * \param[in] hour [0,23]
  * \return Extracted minute [0,59]
  */
 static inline uint8_t FAT_MINUTE(uint16_t fatTime) {
-  return (fatTime >> 5) & 0X3F;
+  return (fatTime >> 5) & 0x3F;
 }
 /** second part of FAT directory time field
  * Note second/2 is stored in packed time.
  * \return Extracted second [0,58]
  */
 static inline uint8_t FAT_SECOND(uint16_t fatTime) {
-  return 2 * (fatTime & 0X1F);
+  return 2 * (fatTime & 0x1F);
 }
 /** Default date for file timestamps is 1 Jan 2000 */
 uint16_t const FAT_DEFAULT_DATE = ((2000 - 1980) << 9) | (1 << 5) | 1;
   // data time callback function
   static void (*dateTime_)(uint16_t* date, uint16_t* time);
   // bits defined in flags_
-  // should be 0X0F
+  // should be 0x0F
   static uint8_t const F_OFLAG = (O_ACCMODE | O_APPEND | O_SYNC);
   // sync of directory entry required
-  static uint8_t const F_FILE_DIR_DIRTY = 0X80;
+  static uint8_t const F_FILE_DIR_DIRTY = 0x80;
 
   // private data
   uint8_t   flags_;         // See above for definition of flags_ bits

Marlin/SdFatStructs.h

  */
 //------------------------------------------------------------------------------
 /** Value for byte 510 of boot block or MBR */
-uint8_t const BOOTSIG0 = 0X55;
+uint8_t const BOOTSIG0 = 0x55;
 /** Value for byte 511 of boot block or MBR */
-uint8_t const BOOTSIG1 = 0XAA;
+uint8_t const BOOTSIG1 = 0xAA;
 /** Value for bootSignature field int FAT/FAT32 boot sector */
-uint8_t const EXTENDED_BOOT_SIG = 0X29;
+uint8_t const EXTENDED_BOOT_SIG = 0x29;
 //------------------------------------------------------------------------------
 /**
  * \struct partitionTable
 struct partitionTable {
           /**
            * Boot Indicator . Indicates whether the volume is the active
-           * partition.  Legal values include: 0X00. Do not use for booting.
-           * 0X80 Active partition.
+           * partition.  Legal values include: 0x00. Do not use for booting.
+           * 0x80 Active partition.
            */
   uint8_t  boot;
           /**
   uint16_t usuallyZero;
            /** Partition tables. */
   part_t   part[4];
-           /** First MBR signature byte. Must be 0X55 */
+           /** First MBR signature byte. Must be 0x55 */
   uint8_t  mbrSig0;
-           /** Second MBR signature byte. Must be 0XAA */
+           /** Second MBR signature byte. Must be 0xAA */
   uint8_t  mbrSig1;
 } PACKED;
 /** Type name for masterBootRecord */
   uint8_t  driveNumber;
            /** used by Windows NT - should be zero for FAT */
   uint8_t  reserved1;
-           /** 0X29 if next three fields are valid */
+           /** 0x29 if next three fields are valid */
   uint8_t  bootSignature;
            /**
             * A random serial number created when formatting a disk,
   char     fileSystemType[8];
            /** X86 boot code */
   uint8_t  bootCode[448];
-           /** must be 0X55 */
+           /** must be 0x55 */
   uint8_t  bootSectorSig0;
-           /** must be 0XAA */
+           /** must be 0xAA */
   uint8_t  bootSectorSig1;
 } PACKED;
 /** Type name for FAT Boot Sector */
   uint8_t  driveNumber;
            /** used by Windows NT - should be zero for FAT */
   uint8_t  reserved1;
-           /** 0X29 if next three fields are valid */
+           /** 0x29 if next three fields are valid */
   uint8_t  bootSignature;
            /**
             * A random serial number created when formatting a disk,
   char     fileSystemType[8];
            /** X86 boot code */
   uint8_t  bootCode[420];
-           /** must be 0X55 */
+           /** must be 0x55 */
   uint8_t  bootSectorSig0;
-           /** must be 0XAA */
+           /** must be 0xAA */
   uint8_t  bootSectorSig1;
 } PACKED;
 /** Type name for FAT32 Boot Sector */
  *
  */
 struct fat32_fsinfo {
-           /** must be 0X52, 0X52, 0X61, 0X41 */
+           /** must be 0x52, 0x52, 0x61, 0x41 */
   uint32_t  leadSignature;
            /** must be zero */
   uint8_t  reserved1[480];
-           /** must be 0X72, 0X72, 0X41, 0X61 */
+           /** must be 0x72, 0x72, 0x41, 0x61 */
   uint32_t  structSignature;
           /**
            * Contains the last known free cluster count on the volume.
   uint32_t nextFree;
            /** must be zero */
   uint8_t  reserved2[12];
-           /** must be 0X00, 0X00, 0X55, 0XAA */
+           /** must be 0x00, 0x00, 0x55, 0xAA */
   uint8_t  tailSignature[4];
 } PACKED;
 /** Type name for FAT32 FSINFO Sector */
 //------------------------------------------------------------------------------
 // End Of Chain values for FAT entries
 /** FAT12 end of chain value used by Microsoft. */
-uint16_t const FAT12EOC = 0XFFF;
+uint16_t const FAT12EOC = 0xFFF;
 /** Minimum value for FAT12 EOC.  Use to test for EOC. */
-uint16_t const FAT12EOC_MIN = 0XFF8;
+uint16_t const FAT12EOC_MIN = 0xFF8;
 /** FAT16 end of chain value used by Microsoft. */
-uint16_t const FAT16EOC = 0XFFFF;
+uint16_t const FAT16EOC = 0xFFFF;
 /** Minimum value for FAT16 EOC.  Use to test for EOC. */
-uint16_t const FAT16EOC_MIN = 0XFFF8;
+uint16_t const FAT16EOC_MIN = 0xFFF8;
 /** FAT32 end of chain value used by Microsoft. */
-uint32_t const FAT32EOC = 0X0FFFFFFF;
+uint32_t const FAT32EOC = 0x0FFFFFFF;
 /** Minimum value for FAT32 EOC.  Use to test for EOC. */
-uint32_t const FAT32EOC_MIN = 0X0FFFFFF8;
+uint32_t const FAT32EOC_MIN = 0x0FFFFFF8;
 /** Mask a for FAT32 entry. Entries are 28 bits. */
-uint32_t const FAT32MASK = 0X0FFFFFFF;
+uint32_t const FAT32MASK = 0x0FFFFFFF;
 //------------------------------------------------------------------------------
 /**
  * \struct directoryEntry
 typedef struct directoryEntry dir_t;
 /** Type name for directoryVFATEntry */
 typedef struct directoryVFATEntry vfat_t;
-/** escape for name[0] = 0XE5 */
-uint8_t const DIR_NAME_0XE5 = 0X05;
+/** escape for name[0] = 0xE5 */
+uint8_t const DIR_NAME_0xE5 = 0x05;
 /** name[0] value for entry that is free after being "deleted" */
-uint8_t const DIR_NAME_DELETED = 0XE5;
+uint8_t const DIR_NAME_DELETED = 0xE5;
 /** name[0] value for entry that is free and no allocated entries follow */
-uint8_t const DIR_NAME_FREE = 0X00;
+uint8_t const DIR_NAME_FREE = 0x00;
 /** file is read-only */
-uint8_t const DIR_ATT_READ_ONLY = 0X01;
+uint8_t const DIR_ATT_READ_ONLY = 0x01;
 /** File should hidden in directory listings */
-uint8_t const DIR_ATT_HIDDEN = 0X02;
+uint8_t const DIR_ATT_HIDDEN = 0x02;
 /** Entry is for a system file */
-uint8_t const DIR_ATT_SYSTEM = 0X04;
+uint8_t const DIR_ATT_SYSTEM = 0x04;
 /** Directory entry contains the volume label */
-uint8_t const DIR_ATT_VOLUME_ID = 0X08;
+uint8_t const DIR_ATT_VOLUME_ID = 0x08;
 /** Entry is for a directory */
-uint8_t const DIR_ATT_DIRECTORY = 0X10;
+uint8_t const DIR_ATT_DIRECTORY = 0x10;
 /** Old DOS archive bit for backup support */
-uint8_t const DIR_ATT_ARCHIVE = 0X20;
+uint8_t const DIR_ATT_ARCHIVE = 0x20;
 /** Test value for long name entry.  Test is
   (d->attributes & DIR_ATT_LONG_NAME_MASK) == DIR_ATT_LONG_NAME. */
-uint8_t const DIR_ATT_LONG_NAME = 0X0F;
+uint8_t const DIR_ATT_LONG_NAME = 0x0F;
 /** Test mask for long name entry */
-uint8_t const DIR_ATT_LONG_NAME_MASK = 0X3F;
+uint8_t const DIR_ATT_LONG_NAME_MASK = 0x3F;
 /** defined attribute bits */
-uint8_t const DIR_ATT_DEFINED_BITS = 0X3F;
+uint8_t const DIR_ATT_DEFINED_BITS = 0x3F;
 /** Directory entry is part of a long name
  * \param[in] dir Pointer to a directory entry.
  *

Marlin/SdInfo.h

 //------------------------------------------------------------------------------
 // SD card commands
 /** GO_IDLE_STATE - init card in spi mode if CS low */
-uint8_t const CMD0 = 0X00;
+uint8_t const CMD0 = 0x00;
 /** SEND_IF_COND - verify SD Memory Card interface operating condition.*/
-uint8_t const CMD8 = 0X08;
+uint8_t const CMD8 = 0x08;
 /** SEND_CSD - read the Card Specific Data (CSD register) */
-uint8_t const CMD9 = 0X09;
+uint8_t const CMD9 = 0x09;
 /** SEND_CID - read the card identification information (CID register) */
-uint8_t const CMD10 = 0X0A;
+uint8_t const CMD10 = 0x0A;
 /** STOP_TRANSMISSION - end multiple block read sequence */
-uint8_t const CMD12 = 0X0C;
+uint8_t const CMD12 = 0x0C;
 /** SEND_STATUS - read the card status register */
-uint8_t const CMD13 = 0X0D;
+uint8_t const CMD13 = 0x0D;
 /** READ_SINGLE_BLOCK - read a single data block from the card */
-uint8_t const CMD17 = 0X11;
+uint8_t const CMD17 = 0x11;
 /** READ_MULTIPLE_BLOCK - read a multiple data blocks from the card */
-uint8_t const CMD18 = 0X12;
+uint8_t const CMD18 = 0x12;
 /** WRITE_BLOCK - write a single data block to the card */
-uint8_t const CMD24 = 0X18;
+uint8_t const CMD24 = 0x18;
 /** WRITE_MULTIPLE_BLOCK - write blocks of data until a STOP_TRANSMISSION */
-uint8_t const CMD25 = 0X19;
+uint8_t const CMD25 = 0x19;
 /** ERASE_WR_BLK_START - sets the address of the first block to be erased */
-uint8_t const CMD32 = 0X20;
+uint8_t const CMD32 = 0x20;
 /** ERASE_WR_BLK_END - sets the address of the last block of the continuous
     range to be erased*/
-uint8_t const CMD33 = 0X21;
+uint8_t const CMD33 = 0x21;
 /** ERASE - erase all previously selected blocks */
-uint8_t const CMD38 = 0X26;
+uint8_t const CMD38 = 0x26;
 /** APP_CMD - escape for application specific command */
-uint8_t const CMD55 = 0X37;
+uint8_t const CMD55 = 0x37;
 /** READ_OCR - read the OCR register of a card */
-uint8_t const CMD58 = 0X3A;
+uint8_t const CMD58 = 0x3A;
 /** SET_WR_BLK_ERASE_COUNT - Set the number of write blocks to be
      pre-erased before writing */
-uint8_t const ACMD23 = 0X17;
+uint8_t const ACMD23 = 0x17;
 /** SD_SEND_OP_COMD - Sends host capacity support information and
     activates the card's initialization process */
-uint8_t const ACMD41 = 0X29;
+uint8_t const ACMD41 = 0x29;
 //------------------------------------------------------------------------------
 /** status for card in the ready state */
-uint8_t const R1_READY_STATE = 0X00;
+uint8_t const R1_READY_STATE = 0x00;
 /** status for card in the idle state */
-uint8_t const R1_IDLE_STATE = 0X01;
+uint8_t const R1_IDLE_STATE = 0x01;
 /** status bit for illegal command */
-uint8_t const R1_ILLEGAL_COMMAND = 0X04;
+uint8_t const R1_ILLEGAL_COMMAND = 0x04;
 /** start data token for read or write single block*/
-uint8_t const DATA_START_BLOCK = 0XFE;
+uint8_t const DATA_START_BLOCK = 0xFE;
 /** stop token for write multiple blocks*/
-uint8_t const STOP_TRAN_TOKEN = 0XFD;
+uint8_t const STOP_TRAN_TOKEN = 0xFD;
 /** start data token for write multiple blocks*/
-uint8_t const WRITE_MULTIPLE_TOKEN = 0XFC;
+uint8_t const WRITE_MULTIPLE_TOKEN = 0xFC;
 /** mask for data response tokens after a write block operation */
-uint8_t const DATA_RES_MASK = 0X1F;
+uint8_t const DATA_RES_MASK = 0x1F;
 /** write data accepted token */
-uint8_t const DATA_RES_ACCEPTED = 0X05;
+uint8_t const DATA_RES_ACCEPTED = 0x05;
 //------------------------------------------------------------------------------
 /** Card IDentification (CID) register */
 typedef struct CID {
   unsigned char reserved1 : 6;
   unsigned char csd_ver : 2;
   // byte 1
-  /** fixed to 0X0E */
+  /** fixed to 0x0E */
   unsigned char taac;
   // byte 2
   /** fixed to 0 */

Marlin/SdVolume.cpp

   // search the FAT for free clusters
   for (uint32_t n = 0;; n++, endCluster++) {
     // can't find space checked all clusters
-    if (n >= clusterCount_) goto fail;
+    if (n >= clusterCount_) goto FAIL;
 
     // past end - start from beginning of FAT
     if (endCluster > fatEnd) {
       bgnCluster = endCluster = 2;
     }
     uint32_t f;
-    if (!fatGet(endCluster, &f)) goto fail;
+    if (!fatGet(endCluster, &f)) goto FAIL;
 
     if (f != 0) {
       // cluster in use try next cluster as bgnCluster
     }
   }
   // mark end of chain
-  if (!fatPutEOC(endCluster)) goto fail;
+  if (!fatPutEOC(endCluster)) goto FAIL;
 
   // link clusters
   while (endCluster > bgnCluster) {
-    if (!fatPut(endCluster - 1, endCluster)) goto fail;
+    if (!fatPut(endCluster - 1, endCluster)) goto FAIL;
     endCluster--;
   }
   if (*curCluster != 0) {
     // connect chains
-    if (!fatPut(*curCluster, bgnCluster)) goto fail;
+    if (!fatPut(*curCluster, bgnCluster)) goto FAIL;
   }
   // return first cluster number to caller
   *curCluster = bgnCluster;
   if (setStart) allocSearchStart_ = bgnCluster + 1;
 
   return true;
-fail:
+  FAIL:
   return false;
 }
 //------------------------------------------------------------------------------
 bool SdVolume::cacheFlush() {
   if (cacheDirty_) {
     if (!sdCard_->writeBlock(cacheBlockNumber_, cacheBuffer_.data)) {
-      goto fail;
+      goto FAIL;
     }
     // mirror FAT tables
     if (cacheMirrorBlock_) {
       if (!sdCard_->writeBlock(cacheMirrorBlock_, cacheBuffer_.data)) {
-        goto fail;
+        goto FAIL;
       }
       cacheMirrorBlock_ = 0;
     }
     cacheDirty_ = 0;
   }
   return true;
-fail:
+  FAIL:
   return false;
 }
 //------------------------------------------------------------------------------
 bool SdVolume::cacheRawBlock(uint32_t blockNumber, bool dirty) {
   if (cacheBlockNumber_ != blockNumber) {
-    if (!cacheFlush()) goto fail;
-    if (!sdCard_->readBlock(blockNumber, cacheBuffer_.data)) goto fail;
+    if (!cacheFlush()) goto FAIL;
+    if (!sdCard_->readBlock(blockNumber, cacheBuffer_.data)) goto FAIL;
     cacheBlockNumber_ = blockNumber;
   }
   if (dirty) cacheDirty_ = true;
   return true;
-fail:
+  FAIL:
   return false;
 }
 //------------------------------------------------------------------------------
 bool SdVolume::chainSize(uint32_t cluster, uint32_t* size) {
   uint32_t s = 0;
   do {
-    if (!fatGet(cluster, &cluster)) goto fail;
+    if (!fatGet(cluster, &cluster)) goto FAIL;
     s += 512UL << clusterSizeShift_;
   } while (!isEOC(cluster));
   *size = s;
   return true;
-fail:
+  FAIL:
   return false;
 }
 //------------------------------------------------------------------------------
 // Fetch a FAT entry
 bool SdVolume::fatGet(uint32_t cluster, uint32_t* value) {
   uint32_t lba;
-  if (cluster > (clusterCount_ + 1)) goto fail;
+  if (cluster > (clusterCount_ + 1)) goto FAIL;
   if (FAT12_SUPPORT && fatType_ == 12) {
     uint16_t index = cluster;
     index += index >> 1;
     lba = fatStartBlock_ + (index >> 9);
-    if (!cacheRawBlock(lba, CACHE_FOR_READ)) goto fail;
-    index &= 0X1FF;
+    if (!cacheRawBlock(lba, CACHE_FOR_READ)) goto FAIL;
+    index &= 0x1FF;
     uint16_t tmp = cacheBuffer_.data[index];
     index++;
     if (index == 512) {
-      if (!cacheRawBlock(lba + 1, CACHE_FOR_READ)) goto fail;
+      if (!cacheRawBlock(lba + 1, CACHE_FOR_READ)) goto FAIL;
       index = 0;
     }
     tmp |= cacheBuffer_.data[index] << 8;
-    *value = cluster & 1 ? tmp >> 4 : tmp & 0XFFF;
+    *value = cluster & 1 ? tmp >> 4 : tmp & 0xFFF;
     return true;
   }
   if (fatType_ == 16) {
     lba = fatStartBlock_ + (cluster >> 7);
   }
   else {
-    goto fail;
+    goto FAIL;
   }
   if (lba != cacheBlockNumber_) {
-    if (!cacheRawBlock(lba, CACHE_FOR_READ)) goto fail;
+    if (!cacheRawBlock(lba, CACHE_FOR_READ)) goto FAIL;
   }
   if (fatType_ == 16) {
-    *value = cacheBuffer_.fat16[cluster & 0XFF];
+    *value = cacheBuffer_.fat16[cluster & 0xFF];
   }
   else {
-    *value = cacheBuffer_.fat32[cluster & 0X7F] & FAT32MASK;
+    *value = cacheBuffer_.fat32[cluster & 0x7F] & FAT32MASK;
   }
   return true;
-fail:
+  FAIL:
   return false;
 }
 //------------------------------------------------------------------------------
 bool SdVolume::fatPut(uint32_t cluster, uint32_t value) {
   uint32_t lba;
   // error if reserved cluster
-  if (cluster < 2) goto fail;
+  if (cluster < 2) goto FAIL;
 
   // error if not in FAT
-  if (cluster > (clusterCount_ + 1)) goto fail;
+  if (cluster > (clusterCount_ + 1)) goto FAIL;
 
   if (FAT12_SUPPORT && fatType_ == 12) {
     uint16_t index = cluster;
     index += index >> 1;
     lba = fatStartBlock_ + (index >> 9);
-    if (!cacheRawBlock(lba, CACHE_FOR_WRITE)) goto fail;
+    if (!cacheRawBlock(lba, CACHE_FOR_WRITE)) goto FAIL;
     // mirror second FAT
     if (fatCount_ > 1) cacheMirrorBlock_ = lba + blocksPerFat_;
-    index &= 0X1FF;
+    index &= 0x1FF;
     uint8_t tmp = value;
     if (cluster & 1) {
       tmp = (cacheBuffer_.data[index] & 0XF) | tmp << 4;
     if (index == 512) {
       lba++;
       index = 0;
-      if (!cacheRawBlock(lba, CACHE_FOR_WRITE)) goto fail;
+      if (!cacheRawBlock(lba, CACHE_FOR_WRITE)) goto FAIL;
       // mirror second FAT
       if (fatCount_ > 1) cacheMirrorBlock_ = lba + blocksPerFat_;
     }
     tmp = value >> 4;
     if (!(cluster & 1)) {
-      tmp = ((cacheBuffer_.data[index] & 0XF0)) | tmp >> 4;
+      tmp = ((cacheBuffer_.data[index] & 0xF0)) | tmp >> 4;
     }
     cacheBuffer_.data[index] = tmp;
     return true;
     lba = fatStartBlock_ + (cluster >> 7);
   }
   else {
-    goto fail;
+    goto FAIL;
   }
-  if (!cacheRawBlock(lba, CACHE_FOR_WRITE)) goto fail;
+  if (!cacheRawBlock(lba, CACHE_FOR_WRITE)) goto FAIL;
   // store entry
   if (fatType_ == 16) {
-    cacheBuffer_.fat16[cluster & 0XFF] = value;
+    cacheBuffer_.fat16[cluster & 0xFF] = value;
   }
   else {
-    cacheBuffer_.fat32[cluster & 0X7F] = value;
+    cacheBuffer_.fat32[cluster & 0x7F] = value;
   }
   // mirror second FAT
   if (fatCount_ > 1) cacheMirrorBlock_ = lba + blocksPerFat_;
   return true;
-fail:
+  FAIL:
   return false;
 }
 //------------------------------------------------------------------------------
   allocSearchStart_ = 2;
 
   do {
-    if (!fatGet(cluster, &next)) goto fail;
+    if (!fatGet(cluster, &next)) goto FAIL;
 
     // free cluster
-    if (!fatPut(cluster, 0)) goto fail;
+    if (!fatPut(cluster, 0)) goto FAIL;
 
     cluster = next;
   } while (!isEOC(cluster));
 
   return true;
-fail:
+  FAIL:
   return false;
 }
 //------------------------------------------------------------------------------
   allocSearchStart_ = 2;
   cacheDirty_ = 0;  // cacheFlush() will write block if true
   cacheMirrorBlock_ = 0;
-  cacheBlockNumber_ = 0XFFFFFFFF;
+  cacheBlockNumber_ = 0xFFFFFFFF;
 
   // if part == 0 assume super floppy with FAT boot sector in block zero
   // if part > 0 assume mbr volume with partition table
   if (part) {
-    if (part > 4)goto fail;
-    if (!cacheRawBlock(volumeStartBlock, CACHE_FOR_READ)) goto fail;
+    if (part > 4)goto FAIL;
+    if (!cacheRawBlock(volumeStartBlock, CACHE_FOR_READ)) goto FAIL;
     part_t* p = &cacheBuffer_.mbr.part[part - 1];
-    if ((p->boot & 0X7F) != 0  ||
+    if ((p->boot & 0x7F) != 0  ||
         p->totalSectors < 100 ||
         p->firstSector == 0) {
       // not a valid partition
-      goto fail;
+      goto FAIL;
     }
     volumeStartBlock = p->firstSector;
   }
-  if (!cacheRawBlock(volumeStartBlock, CACHE_FOR_READ)) goto fail;
+  if (!cacheRawBlock(volumeStartBlock, CACHE_FOR_READ)) goto FAIL;
   fbs = &cacheBuffer_.fbs32;
   if (fbs->bytesPerSector != 512 ||
       fbs->fatCount == 0 ||
       fbs->reservedSectorCount == 0 ||
       fbs->sectorsPerCluster == 0) {
     // not valid FAT volume
-    goto fail;
+    goto FAIL;
   }
   fatCount_ = fbs->fatCount;
   blocksPerCluster_ = fbs->sectorsPerCluster;
   clusterSizeShift_ = 0;
   while (blocksPerCluster_ != _BV(clusterSizeShift_)) {
     // error if not power of 2
-    if (clusterSizeShift_++ > 7) goto fail;
+    if (clusterSizeShift_++ > 7) goto FAIL;
   }
   blocksPerFat_ = fbs->sectorsPerFat16 ?
                   fbs->sectorsPerFat16 : fbs->sectorsPerFat32;
   // FAT type is determined by cluster count
   if (clusterCount_ < 4085) {
     fatType_ = 12;
-    if (!FAT12_SUPPORT) goto fail;
+    if (!FAT12_SUPPORT) goto FAIL;
   }
   else if (clusterCount_ < 65525) {
     fatType_ = 16;
     fatType_ = 32;
   }
   return true;
-fail:
+  FAIL:
   return false;
 }
 #endif

Marlin/SdVolume.h

    */
   cache_t* cacheClear() {
     if (!cacheFlush()) return 0;
-    cacheBlockNumber_ = 0XFFFFFFFF;
+    cacheBlockNumber_ = 0xFFFFFFFF;
     return &cacheBuffer_;
   }
   /** Initialize a FAT volume.  Try partition one first then try super

Marlin/example_configurations/Creality/CR-10/Configuration.h

 // User-specified version info of this build to display in [Pronterface, etc] terminal window during
 // startup. Implementation of an idea by Prof Braino to inform user that any changes made to this
 // build by the user have been successfully uploaded into firmware.
-#define STRING_CONFIG_H_AUTHOR "(none, default config)" // Who made the changes.
+#define STRING_CONFIG_H_AUTHOR "(Creality CR-10)" // Who made the changes.
 #define SHOW_BOOTSCREEN
 #define STRING_SPLASH_LINE1 SHORT_BUILD_VERSION // will be shown during bootup in line 1
 //#define STRING_SPLASH_LINE2 WEBSITE_URL         // will be shown during bootup in line 2

Marlin/pca9632.cpp

 #define PCA9632_PWM3        0x05
 #define PCA9632_GRPPWM      0x06
 #define PCA9632_GRPFREQ     0x07
-#define PCA9632_LEDOUT      0X08
+#define PCA9632_LEDOUT      0x08
 #define PCA9632_SUBADR1     0x09
 #define PCA9632_SUBADR2     0x0A
 #define PCA9632_SUBADR3     0x0B

Marlin/pins_MELZI_CREALITY.h

  * Melzi (Creality) pin assignments
  */
 
-#define BOARD_NAME "Melzi Creality"
+#define BOARD_NAME "Melzi (Creality)"
 
 #ifdef __AVR_ATmega1284P__
   #define LARGE_FLASH true

Marlin/pins_MELZI_MAKR3D.h

  * Melzi with ATmega1284 (MaKr3d version) pin assignments
  */
 
-#define BOARD_NAME "Melzi ATmega1284"
+#define BOARD_NAME "Melzi (ATmega1284)"
 
 #ifdef __AVR_ATmega1284P__
   #define LARGE_FLASH true

Marlin/softspi.h

 static inline __attribute__((always_inline))
 void fastBitWriteSafe(volatile uint8_t* address, uint8_t bit, bool level) {
   uint8_t oldSREG;
-  if (address > (uint8_t*)0X5F) {
+  if (address > (uint8_t*)0x5F) {
     oldSREG = SREG;
     cli();
   }
   } else {
     *address &= ~(1 << bit);
   }
-  if (address > (uint8_t*)0X5F) {
+  if (address > (uint8_t*)0x5F) {
     SREG = oldSREG;
   }
 }
 static inline __attribute__((always_inline))
 void fastDigitalToggle(uint8_t pin) {
   badPinCheck(pin);
-    if (pinMap[pin].pin > (uint8_t*)0X5F) {
+    if (pinMap[pin].pin > (uint8_t*)0x5F) {
       // must write bit to high address port
       *pinMap[pin].pin = 1 << pinMap[pin].bit;
     } else {

Marlin/ultralcd.cpp

 
   screenFunc_t _manual_move_func_ptr;
 
-  void lcd_move_menu_10mm() { move_menu_scale = 10.0; lcd_goto_screen(_manual_move_func_ptr); }
-  void lcd_move_menu_1mm()  { move_menu_scale =  1.0; lcd_goto_screen(_manual_move_func_ptr); }
-  void lcd_move_menu_01mm() { move_menu_scale =  0.1; lcd_goto_screen(_manual_move_func_ptr); }
+  void _goto_manual_move(const float scale) {
+    defer_return_to_status = true;
+    move_menu_scale = scale;
+    lcd_goto_screen(_manual_move_func_ptr);
+  }
+  void lcd_move_menu_10mm() { _goto_manual_move(10.0); }
+  void lcd_move_menu_1mm()  { _goto_manual_move( 1.0); }
+  void lcd_move_menu_01mm() { _goto_manual_move( 0.1); }
 
-  void _lcd_move_distance_menu(AxisEnum axis, screenFunc_t func) {
+  void _lcd_move_distance_menu(const AxisEnum axis, const screenFunc_t func) {
     _manual_move_func_ptr = func;
     START_MENU();
     if (LCD_HEIGHT >= 4) {