Standardize some hexadecimals

Marlin/src/HAL/HAL_DUE/HAL_spi_Due.cpp

       REG_PMC_PCER0 = (1UL << ID_PIOA) | (1UL << ID_SPI0);
 
       // Disable PIO on A26 and A27
-      REG_PIOA_PDR = 0x0c000000;
+      REG_PIOA_PDR = 0x0C000000;
       OUT_WRITE(SDSS, 1);
 
       // Reset SPI0 (from sam lib)

Marlin/src/HAL/HAL_DUE/u8g_com_HAL_DUE_st7920_sw_spi.cpp

 
     if ( rs == 0 )
       /* command */
-      spiSend_sw_DUE(0x0f8);
+      spiSend_sw_DUE(0x0F8);
     else
        /* data */
-      spiSend_sw_DUE(0x0fa);
+      spiSend_sw_DUE(0x0FA);
 
     for (i = 0; i < 4; i++)   // give the controller some time to process the data
       u8g_10MicroDelay();     // 2 is bad, 3 is OK, 4 is safe
   }
 
-  spiSend_sw_DUE(val & 0x0f0);
+  spiSend_sw_DUE(val & 0x0F0);
   spiSend_sw_DUE(val << 4);
 }
 

Marlin/src/HAL/HAL_DUE/usb/pll.h

 
 #define PLL_UPLL_HZ     480000000
 
-#define PLL_COUNT           0x3fU
+#define PLL_COUNT           0x3FU
 
 enum pll_source {
 	PLL_SRC_MAINCK_4M_RC        = OSC_MAINCK_4M_RC,     //!< Internal 4MHz RC oscillator.

Marlin/src/HAL/HAL_DUE/usb/spc_protocol.h

 #define  SCSI_INQ_DT_CD_DVD      0x05   //!< CD/DVD device
 #define  SCSI_INQ_DT_OPTICAL     0x07   //!< Optical Memory
 #define  SCSI_INQ_DT_MC          0x08   //!< Medium Changer
-#define  SCSI_INQ_DT_ARRAY       0x0c   //!< Storage Array Controller
-#define  SCSI_INQ_DT_ENCLOSURE   0x0d   //!< Enclosure Services
-#define  SCSI_INQ_DT_RBC         0x0e   //!< Simplified Direct Access
-#define  SCSI_INQ_DT_OCRW        0x0f   //!< Optical card reader/writer
+#define  SCSI_INQ_DT_ARRAY       0x0C   //!< Storage Array Controller
+#define  SCSI_INQ_DT_ENCLOSURE   0x0D   //!< Enclosure Services
+#define  SCSI_INQ_DT_RBC         0x0E   //!< Simplified Direct Access
+#define  SCSI_INQ_DT_OCRW        0x0F   //!< Optical card reader/writer
 #define  SCSI_INQ_DT_BCC         0x10   //!< Bridge Controller Commands
 #define  SCSI_INQ_DT_OSD         0x11   //!< Object-based Storage
-#define  SCSI_INQ_DT_NONE        0x1f   //!< No Peripheral
+#define  SCSI_INQ_DT_NONE        0x1F   //!< No Peripheral
 	uint8_t flags1; //!< Flags (byte 1)
 #define  SCSI_INQ_RMB            0x80   //!< Removable Medium
 	uint8_t version; //!< Version
 	SCSI_SK_DATA_PROTECT = 0x7,
 	SCSI_SK_BLANK_CHECK = 0x8,
 	SCSI_SK_VENDOR_SPECIFIC = 0x9,
-	SCSI_SK_COPY_ABORTED = 0xa,
-	SCSI_SK_ABORTED_COMMAND = 0xb,
-	SCSI_SK_VOLUME_OVERFLOW = 0xd,
-	SCSI_SK_MISCOMPARE = 0xe,
+	SCSI_SK_COPY_ABORTED = 0xA,
+	SCSI_SK_ABORTED_COMMAND = 0xB,
+	SCSI_SK_VOLUME_OVERFLOW = 0xD,
+	SCSI_SK_MISCOMPARE = 0xE,
 };
 
 /* Additional Sense Code / Additional Sense Code Qualifier pairs */
 enum scsi_asc_ascq {
 	SCSI_ASC_NO_ADDITIONAL_SENSE_INFO = 0x0000,
 	SCSI_ASC_LU_NOT_READY_REBUILD_IN_PROGRESS = 0x0405,
-	SCSI_ASC_WRITE_ERROR = 0x0c00,
+	SCSI_ASC_WRITE_ERROR = 0x0C00,
 	SCSI_ASC_UNRECOVERED_READ_ERROR = 0x1100,
 	SCSI_ASC_INVALID_COMMAND_OPERATION_CODE = 0x2000,
 	SCSI_ASC_INVALID_FIELD_IN_CDB = 0x2400,
 enum scsi_spc_mode {
 	SCSI_MS_MODE_VENDOR_SPEC = 0x00,
 	SCSI_MS_MODE_INFEXP = 0x1C,    // Informational exceptions control page
-	SCSI_MS_MODE_ALL = 0x3f,
+	SCSI_MS_MODE_ALL = 0x3F,
 };
 
 /**
 
 static inline uint8_t scsi_mode_sense_get_page_code(const uint8_t * cdb)
 {
-	return cdb[2] & 0x3f;
+	return cdb[2] & 0x3F;
 }
 
 static inline uint8_t scsi_mode_sense_get_pc(const uint8_t * cdb)

Marlin/src/HAL/HAL_DUE/usb/udc.c

 		if (!udd_is_high_speed()) {
 			break;
 		}
-		if (udd_g_ctrlreq.req.wIndex & 0xff) {
+		if (udd_g_ctrlreq.req.wIndex & 0xFF) {
 			break;
 		}
 		// Unconfigure the device, terminating all ongoing requests
 	uint8_t str_length = 0;
 
 	// Link payload pointer to the string corresponding at request
-	switch (udd_g_ctrlreq.req.wValue & 0xff) {
+	switch (udd_g_ctrlreq.req.wValue & 0xFF) {
 	case 0:
 		udd_set_setup_payload((uint8_t *) &udc_string_desc_languageid,
 				sizeof(udc_string_desc_languageid));
 {
 	uint8_t conf_num;
 
-	conf_num = udd_g_ctrlreq.req.wValue & 0xff;
+	conf_num = udd_g_ctrlreq.req.wValue & 0xFF;
 
 	// Check descriptor ID
 	switch ((uint8_t) (udd_g_ctrlreq.req.wValue >> 8)) {

Marlin/src/HAL/HAL_DUE/usb/usb_protocol.h

 /**
  * \brief Mask selecting the index part of an endpoint address
  */
-#define  USB_EP_ADDR_MASK     0x0f
+#define  USB_EP_ADDR_MASK     0x0F
 
 //! \brief USB address identifier
 typedef uint8_t usb_add_t;

Marlin/src/HAL/HAL_DUE/usb/usb_task.c

   uint8_t str_lgt = 0;
 
   // Link payload pointer to the string corresponding at request
-  switch (udd_g_ctrlreq.req.wValue & 0xff) {
+  switch (udd_g_ctrlreq.req.wValue & 0xFF) {
   case UDI_CDC_IAD_STRING_ID:
     str_lgt = sizeof(udi_cdc_name) - 1;
     str = udi_cdc_name;

Marlin/src/HAL/HAL_LPC1768/HAL.cpp

     data = lowpass_filter[adc_channel].update(data);
   #endif
 
-  return ((data >> 2) & 0x3ff);    // return 10bit value as Marlin expects
+  return ((data >> 2) & 0x3FF);    // return 10bit value as Marlin expects
 }
 
 #define SBIT_CNTEN     0

Marlin/src/HAL/HAL_LPC1768/HAL_spi.cpp

   }
 
   uint8_t spiRec() {
-    uint8_t b = spiTransfer(0xff);
+    uint8_t b = spiTransfer(0xFF);
     return b;
   }
 
   void spiRead(uint8_t*buf, uint16_t nbyte) {
     if (nbyte == 0) return;
     for (int i = 0; i < nbyte; i++) {
-      buf[i] = spiTransfer(0xff);
+      buf[i] = spiTransfer(0xFF);
     }
   }
 

Marlin/src/HAL/HAL_LPC1768/LPC1768_PWM.cpp

   }
 }
 
-bool LPC1768_PWM_attach_pin(pin_t pin, uint32_t min /* = 1 */, uint32_t max /* = (LPC_PWM1_MR0 - 1) */, uint8_t servo_index /* = 0xff */) {
+bool LPC1768_PWM_attach_pin(pin_t pin, uint32_t min /* = 1 */, uint32_t max /* = (LPC_PWM1_MR0 - 1) */, uint8_t servo_index /* = 0xFF */) {
 
   pin = GET_PIN_MAP_PIN(GET_PIN_MAP_INDEX(pin & 0xFF));  // Sometimes the upper byte is garbled
 

Marlin/src/HAL/HAL_LPC1768/u8g_com_HAL_LPC1768_ssd_hw_i2c.cpp

 
   #include <U8glib.h>
 
-  #define I2C_SLA         (0x3c*2)
+  #define I2C_SLA         (0x3C*2)
   //#define I2C_CMD_MODE  0x080
   #define I2C_CMD_MODE    0x000
   #define I2C_DATA_MODE   0x040

Marlin/src/HAL/HAL_LPC1768/u8g_com_HAL_LPC1768_ssd_sw_i2c.cpp under construction

 //void digitalWrite(int16_t pin, uint8_t pin_status);
 
 
-  #define I2C_SLA         (0x3c*2)
+  #define I2C_SLA         (0x3C*2)
   //#define I2C_CMD_MODE  0x080
   #define I2C_CMD_MODE    0x000
   #define I2C_DATA_MODE   0x040

Marlin/src/HAL/HAL_LPC1768/u8g_com_HAL_LPC1768_st7920_hw_spi.cpp

 
       if ( rs == 0 )
         /* command */
-        spiSend(0x0f8);
+        spiSend(0x0F8);
       else
          /* data */
-        spiSend(0x0fa);
+        spiSend(0x0FA);
 
       for( i = 0; i < 4; i++ )   // give the controller some time to process the data
         u8g_10MicroDelay();      // 2 is bad, 3 is OK, 4 is safe
     }
 
-    spiSend(val & 0x0f0);
+    spiSend(val & 0x0F0);
     spiSend(val << 4);
   }
 

Marlin/src/HAL/HAL_LPC1768/u8g_com_HAL_LPC1768_st7920_sw_spi.cpp

 
       if ( rs == 0 )
         /* command */
-        swSpiTransfer(0x0f8, SPI_speed, SCK_pin_ST7920_HAL, -1, MOSI_pin_ST7920_HAL_HAL);
+        swSpiTransfer(0x0F8, SPI_speed, SCK_pin_ST7920_HAL, -1, MOSI_pin_ST7920_HAL_HAL);
       else
          /* data */
-         swSpiTransfer(0x0fa, SPI_speed, SCK_pin_ST7920_HAL, -1, MOSI_pin_ST7920_HAL_HAL);
+         swSpiTransfer(0x0FA, SPI_speed, SCK_pin_ST7920_HAL, -1, MOSI_pin_ST7920_HAL_HAL);
 
       for( i = 0; i < 4; i++ )   // give the controller some time to process the data
         u8g_10MicroDelay();      // 2 is bad, 3 is OK, 4 is safe
     }
 
-    swSpiTransfer(val & 0x0f0, SPI_speed, SCK_pin_ST7920_HAL, -1, MOSI_pin_ST7920_HAL_HAL);
+    swSpiTransfer(val & 0x0F0, SPI_speed, SCK_pin_ST7920_HAL, -1, MOSI_pin_ST7920_HAL_HAL);
     swSpiTransfer(val << 4, SPI_speed, SCK_pin_ST7920_HAL, -1, MOSI_pin_ST7920_HAL_HAL);
   }
 

Marlin/src/HAL/HAL_STM32F7/TMC2660.cpp

 //definitions for the chopper config register
 #define CHOPPER_MODE_STANDARD 0x0ul
 #define CHOPPER_MODE_T_OFF_FAST_DECAY 0x4000ul
-#define T_OFF_PATTERN 0xful
+#define T_OFF_PATTERN 0xFul
 #define RANDOM_TOFF_TIME 0x2000ul
 #define BLANK_TIMING_PATTERN 0x18000ul
 #define BLANK_TIMING_SHIFT 15
 #define CURRENT_DOWN_STEP_SPEED_PATTERN 0x6000ul
 #define SE_MAX_PATTERN 0xF00ul
 #define SE_CURRENT_STEP_WIDTH_PATTERN 0x60ul
-#define SE_MIN_PATTERN 0xful
+#define SE_MIN_PATTERN 0xFul
 
 //definitions for stall guard2 current register
 #define STALL_GUARD_FILTER_ENABLED 0x10000ul

Marlin/src/backtrace/unwarm.cpp

 // Detect if function names are available
 static int __attribute__ ((noinline)) has_function_names(void) {
   uint32_t flag_word = ((uint32_t*)(((uint32_t)(&has_function_names)) & (-4))) [-1];
-  return ((flag_word & 0xff000000) == 0xff000000) ? 1 : 0;
+  return ((flag_word & 0xFF000000) == 0xFF000000) ? 1 : 0;
 }
 
 /**

Marlin/src/backtrace/unwarm.h

  *  Macros
  **************************************************************************/
 
-#define M_IsOriginValid(v) (((v) & 0x7f) ? true : false)
+#define M_IsOriginValid(v) (((v) & 0x7F) ? true : false)
 #define M_Origin2Str(v)    ((v) ? "VALID" : "INVALID")
 
 #if defined(UNW_DEBUG)

Marlin/src/backtrace/unwarm_thumb.cpp

 static int32_t signExtend11(uint16_t value) {
 
   if(value & 0x400) {
-    value |= 0xfffff800;
+    value |= 0xFFFFF800;
   }
 
   return value;
     /*
      * Detect 32bit thumb instructions
      */
-    if ((instr & 0xe000) == 0xe000 && (instr & 0x1800) != 0) {
+    if ((instr & 0xE000) == 0xE000 && (instr & 0x1800) != 0) {
       uint16_t instr2;
 
       /* Check next address */
        * Load/Store multiple: Only interpret
        *  PUSH and POP
        */
-      if ((instr & 0xfe6f) == 0xe82d) {
+      if ((instr & 0xFE6F) == 0xE82D) {
         bool     L     = (instr &  0x10) ? true : false;
         uint16_t rList = instr2;
 
       /*
        * PUSH register
        */
-      else if (instr == 0xf84d && (instr2 & 0x0fff) == 0x0d04) {
+      else if (instr == 0xF84D && (instr2 & 0x0FFF) == 0x0D04) {
         uint8_t r = instr2 >> 12;
 
         /* Store to memory: PUSH */
       /*
        * POP register
        */
-      else if (instr == 0xf85d && (instr2 & 0x0fff) == 0x0b04) {
+      else if (instr == 0xF85D && (instr2 & 0x0FFF) == 0x0B04) {
         uint8_t r = instr2 >> 12;
 
         /* Load from memory: POP */
       /*
        * TBB / TBH
        */
-      else if ((instr & 0xfff0) == 0xe8d0 && (instr2 & 0xffe0) == 0xf000) {
+      else if ((instr & 0xFFF0) == 0xE8D0 && (instr2 & 0xFFE0) == 0xF000) {
         /* We are only interested in
          * the forms
          *  TBB [PC, ...]
          * as those are used by the C compiler to implement
          * the switch clauses
          */
-        uint8_t rn = instr & 0xf;
-        uint8_t rm = instr2 & 0xf;
+        uint8_t rn = instr & 0xF;
+        uint8_t rm = instr2 & 0xF;
         bool H = (instr2 & 0x10) ? true : false;
 
         UnwPrintd5("TB%c [r%d,r%d%s]\n", H ? 'H' : 'B', rn, rm, H ? ",LSL #1" : "");
       /*
        * Unconditional branch
        */
-      else if ((instr & 0xf800) == 0xf000 && (instr2 & 0xd000) == 0x9000) {
+      else if ((instr & 0xF800) == 0xF000 && (instr2 & 0xD000) == 0x9000) {
         uint32_t v;
 
         uint8_t      S = (instr & 0x400) >> 10;
-        uint16_t imm10 = (instr & 0x3ff);
+        uint16_t imm10 = (instr & 0x3FF);
         uint8_t     J1 = (instr2 & 0x2000) >> 13;
         uint8_t     J2 = (instr2 & 0x0800) >> 11;
-        uint16_t imm11 = (instr2 & 0x7ff);
+        uint16_t imm11 = (instr2 & 0x7FF);
 
         uint8_t I1 = J1 ^ S ^ 1;
         uint8_t I2 = J2 ^ S ^ 1;
         uint32_t imm32 = (S << 24) | (I1 << 23) | (I2 << 22) |(imm10 << 12) | (imm11 << 1);
-        if (S) imm32 |= 0xfe000000;
+        if (S) imm32 |= 0xFE000000;
 
         UnwPrintd2("B %d \n", imm32);
 
       /*
        * Branch with link
        */
-      else if ((instr & 0xf800) == 0xf000 && (instr2 & 0xd000) == 0xd000) {
+      else if ((instr & 0xF800) == 0xF000 && (instr2 & 0xD000) == 0xD000) {
 
         uint8_t      S = (instr & 0x400) >> 10;
-        uint16_t imm10 = (instr & 0x3ff);
+        uint16_t imm10 = (instr & 0x3FF);
         uint8_t     J1 = (instr2 & 0x2000) >> 13;
         uint8_t     J2 = (instr2 & 0x0800) >> 11;
-        uint16_t imm11 = (instr2 & 0x7ff);
+        uint16_t imm11 = (instr2 & 0x7FF);
 
         uint8_t I1 = J1 ^ S ^ 1;
         uint8_t I2 = J2 ^ S ^ 1;
         uint32_t imm32 = (S << 24) | (I1 << 23) | (I2 << 22) |(imm10 << 12) | (imm11 << 1);
-        if (S) imm32 |= 0xfe000000;
+        if (S) imm32 |= 0xFE000000;
 
         UnwPrintd2("BL %d \n", imm32);
 
       /*
        * Conditional branches. Usually not taken, unless infinite loop is detected
        */
-      else if ((instr & 0xf800) == 0xf000 && (instr2 & 0xd000) == 0x8000) {
+      else if ((instr & 0xF800) == 0xF000 && (instr2 & 0xD000) == 0x8000) {
 
         uint8_t      S = (instr & 0x400) >> 10;
-        uint16_t  imm6 = (instr &  0x3f);
+        uint16_t  imm6 = (instr &  0x3F);
         uint8_t     J1 = (instr2 & 0x2000) >> 13;
         uint8_t     J2 = (instr2 & 0x0800) >> 11;
-        uint16_t imm11 = (instr2 & 0x7ff);
+        uint16_t imm11 = (instr2 & 0x7FF);
 
         uint8_t I1 = J1 ^ S ^ 1;
         uint8_t I2 = J2 ^ S ^ 1;
         uint32_t imm32 = (S << 20) | (I1 << 19) | (I2 << 18) |(imm6 << 12) | (imm11 << 1);
-        if (S) imm32 |= 0xffe00000;
+        if (S) imm32 |= 0xFFE00000;
 
         UnwPrintd2("Bcond %d\n", imm32);
 
        * PC-relative load
        *  LDR Rd,[PC, #+/-imm]
        */
-      else if((instr & 0xff7f) == 0xf85f) {
-        uint8_t  rt    = (instr2 & 0xf000) >> 12;
-        uint8_t  imm12 = (instr2 & 0x0fff);
+      else if((instr & 0xFF7F) == 0xF85F) {
+        uint8_t  rt    = (instr2 & 0xF000) >> 12;
+        uint8_t  imm12 = (instr2 & 0x0FFF);
         bool     A     = (instr  & 0x80) ? true : false;
         uint32_t address;
 
        *  We are only interested when destination is PC.
        *  LDR Rt,[Rn , #n]
        */
-      else if ((instr & 0xfff0) == 0xf8d0) {
-        uint8_t     rn = (instr  & 0xf);
-        uint8_t     rt = (instr2 & 0xf000) >> 12;
-        uint16_t imm12 = (instr2 & 0xfff);
+      else if ((instr & 0xFFF0) == 0xF8D0) {
+        uint8_t     rn = (instr  & 0xF);
+        uint8_t     rt = (instr2 & 0xF000) >> 12;
+        uint16_t imm12 = (instr2 & 0xFFF);
 
         /* If destination is PC and we don't know the source value, then fail */
         if (!M_IsOriginValid(state->regData[rn].o)) {
        *  LDR Rt,[Rn], #+/-n]
        *  LDR Rt,[Rn, #+/-n]!
        */
-      else if ((instr & 0xfff0) == 0xf850 && (instr2 & 0x0800) == 0x0800) {
-        uint8_t     rn = (instr  & 0xf);
-        uint8_t     rt = (instr2 & 0xf000) >> 12;
-        uint16_t  imm8 = (instr2 & 0xff);
+      else if ((instr & 0xFFF0) == 0xF850 && (instr2 & 0x0800) == 0x0800) {
+        uint8_t     rn = (instr  & 0xF);
+        uint8_t     rt = (instr2 & 0xF000) >> 12;
+        uint16_t  imm8 = (instr2 & 0xFF);
         bool         P = (instr2 & 0x400) ? true : false;
         bool         U = (instr2 & 0x200) ? true : false;
         bool         W = (instr2 & 0x100) ? true : false;
        *   ldr  Rt, [Rn, Rm, lsl #x]
        *  Where Rt is PC, Rn value is known, Rm is not known or unknown
        */
-      else if ((instr & 0xfff0) == 0xf850 && (instr2 & 0x0fc0) == 0x0000) {
-        uint8_t   rn = (instr  & 0xf);
-        uint8_t   rt = (instr2 & 0xf000) >> 12;
-        uint8_t   rm = (instr2 & 0xf);
+      else if ((instr & 0xFFF0) == 0xF850 && (instr2 & 0x0FC0) == 0x0000) {
+        uint8_t   rn = (instr  & 0xF);
+        uint8_t   rt = (instr2 & 0xF000) >> 12;
+        uint8_t   rm = (instr2 & 0xF);
         uint8_t imm2 = (instr2 & 0x30) >> 4;
 
         if (!M_IsOriginValid(state->regData[rn].o) ||
      *  LSR Rd, Rs, #Offset5
      *  ASR Rd, Rs, #Offset5
      */
-    else if((instr & 0xe000) == 0x0000 && (instr & 0x1800) != 0x1800) {
+    else if((instr & 0xE000) == 0x0000 && (instr & 0x1800) != 0x1800) {
       bool signExtend;
       uint8_t op      = (instr & 0x1800) >> 11;
-      uint8_t offset5 = (instr & 0x07c0) >>  6;
+      uint8_t offset5 = (instr & 0x07C0) >>  6;
       uint8_t rs      = (instr & 0x0038) >>  3;
       uint8_t rd      = (instr & 0x0007);
 
           signExtend = (state->regData[rs].v & 0x8000) ? true : false;
           state->regData[rd].v = state->regData[rs].v >> offset5;
           if(signExtend) {
-            state->regData[rd].v |= 0xffffffff << (32 - offset5);
+            state->regData[rd].v |= 0xFFFFFFFF << (32 - offset5);
           }
           state->regData[rd].o = state->regData[rs].o;
           state->regData[rd].o |= REG_VAL_ARITHMETIC;
      *  SUB Rd, Rs, Rn
      *  SUB Rd, Rs, #Offset3
      */
-    else if((instr & 0xf800) == 0x1800) {
+    else if((instr & 0xF800) == 0x1800) {
       bool    I  = (instr & 0x0400) ? true : false;
       bool    op = (instr & 0x0200) ? true : false;
-      uint8_t rn = (instr & 0x01c0) >> 6;
+      uint8_t rn = (instr & 0x01C0) >> 6;
       uint8_t rs = (instr & 0x0038) >> 3;
       uint8_t rd = (instr & 0x0007);
 
      *  ADD Rd, #Offset8
      *  SUB Rd, #Offset8
      */
-    else if((instr & 0xe000) == 0x2000) {
+    else if((instr & 0xE000) == 0x2000) {
 
       uint8_t op      = (instr & 0x1800) >> 11;
       uint8_t rd      = (instr & 0x0700) >>  8;
-      uint8_t offset8 = (instr & 0x00ff);
+      uint8_t offset8 = (instr & 0x00FF);
 
       switch(op) {
         case 0: /* MOV */
      *  BIC Rd, Rs
      *  MVN Rd, Rs
      */
-    else if((instr & 0xfc00) == 0x4000) {
-      uint8_t op = (instr & 0x03c0) >> 6;
+    else if((instr & 0xFC00) == 0x4000) {
+      uint8_t op = (instr & 0x03C0) >> 6;
       uint8_t rs = (instr & 0x0038) >> 3;
       uint8_t rd = (instr & 0x0007);
 
         case 4: /* ASR */
           if(state->regData[rd].v & 0x80000000) {
             state->regData[rd].v >>= state->regData[rs].v;
-            state->regData[rd].v |= 0xffffffff << (32 - state->regData[rs].v);
+            state->regData[rd].v |= 0xFFFFFFFF << (32 - state->regData[rs].v);
           }
           else {
             state->regData[rd].v >>= state->regData[rs].v;
      *  CMP Hd, Rs
      *  MOV Hd, Hs
      */
-    else if((instr & 0xfc00) == 0x4400) {
+    else if((instr & 0xFC00) == 0x4400) {
       uint8_t op  = (instr & 0x0300) >> 8;
       bool    h1  = (instr & 0x0080) ? true: false;
       bool    h2  = (instr & 0x0040) ? true: false;
     /* Format 9: PC-relative load
      *  LDR Rd,[PC, #imm]
      */
-    else if((instr & 0xf800) == 0x4800) {
+    else if((instr & 0xF800) == 0x4800) {
       uint8_t  rd    = (instr & 0x0700) >> 8;
-      uint8_t  word8 = (instr & 0x00ff);
+      uint8_t  word8 = (instr & 0x00FF);
       uint32_t address;
 
       /* Compute load address, adding a word to account for prefetch */
      *  ADD sp,#+imm
      *  ADD sp,#-imm
      */
-    else if((instr & 0xff00) == 0xB000) {
-      uint8_t value = (instr & 0x7f) * 4;
+    else if((instr & 0xFF00) == 0xB000) {
+      uint8_t value = (instr & 0x7F) * 4;
 
       /* Check the negative bit */
       if((instr & 0x80) != 0) {
      *  POP {Rlist}
      *  POP {Rlist, PC}
      */
-    else if((instr & 0xf600) == 0xb400) {
+    else if((instr & 0xF600) == 0xB400) {
       bool    L     = (instr & 0x0800) ? true : false;
       bool    R     = (instr & 0x0100) ? true : false;
-      uint8_t rList = (instr & 0x00ff);
+      uint8_t rList = (instr & 0x00FF);
 
       if(L) {
         uint8_t r;
      * Conditional branches
      * Bcond
      */
-    else if((instr & 0xf000) == 0xd000) {
-      int32_t branchValue = (instr & 0xff);
-      if (branchValue & 0x80) branchValue |= 0xffffff00;
+    else if((instr & 0xF000) == 0xD000) {
+      int32_t branchValue = (instr & 0xFF);
+      if (branchValue & 0x80) branchValue |= 0xFFFFFF00;
 
       /* Branch distance is twice that specified in the instruction. */
       branchValue *= 2;
     /* Format 18: unconditional branch
      *  B label
      */
-    else if((instr & 0xf800) == 0xe000) {
+    else if((instr & 0xF800) == 0xE000) {
       uint32_t v;
-      int32_t branchValue = signExtend11(instr & 0x07ff);
+      int32_t branchValue = signExtend11(instr & 0x07FF);
 
       /* Branch distance is twice that specified in the instruction. */
       branchValue *= 2;

Marlin/src/backtrace/unwarmbytab.cpp

 
 static inline __attribute__((always_inline)) uint32_t prel31_to_addr(const uint32_t *prel31) {
   uint32_t offset = (((uint32_t)(*prel31)) << 1) >> 1;
-  return ((uint32_t)prel31 + offset) & 0x7fffffff;
+  return ((uint32_t)prel31 + offset) & 0x7FFFFFFF;
 }
 
 static const UnwTabEntry *UnwTabSearchIndex(const UnwTabEntry *start, const UnwTabEntry *end, uint32_t ip) {
   if (!cb->readW(address-4,&flag_word))
     return NULL;
 
-  if ((flag_word & 0xff000000) == 0xff000000) {
-    return (const char *)(address - 4 - (flag_word & 0x00ffffff));
+  if ((flag_word & 0xFF000000) == 0xFF000000) {
+    return (const char *)(address - 4 - (flag_word & 0x00FFFFFF));
   }
   return NULL;
 }
   uint32_t v = 0;
   if (!cb->readW(ucb->current, &v))
     return -1;
-  instruction = (v >> (ucb->byte << 3)) & 0xff;
+  instruction = (v >> (ucb->byte << 3)) & 0xFF;
 
   /* Move the next byte */
   --ucb->byte;
   if (!cb->readW(instructions, &v))
     return UNWIND_DREAD_W_FAIL;
 
-  if ((v & 0xff000000) == 0x80000000) {
+  if ((v & 0xFF000000) == 0x80000000) {
     ucb->remaining = 3;
     ucb->byte = 2;
   /* Is a long unwind description */
-  } else if ((v & 0xff000000) == 0x81000000) {
-    ucb->remaining = ((v & 0x00ff0000) >> 14) + 2;
+  } else if ((v & 0xFF000000) == 0x81000000) {
+    ucb->remaining = ((v & 0x00FF0000) >> 14) + 2;
     ucb->byte = 1;
   } else
     return UNWIND_UNSUPPORTED_DWARF_PERSONALITY;
   /* Consume all instruction byte */
   while ((instruction = UnwTabGetNextInstruction(cb, ucb)) != -1) {
 
-    if ((instruction & 0xc0) == 0x00) { // ARM_EXIDX_CMD_DATA_POP
+    if ((instruction & 0xC0) == 0x00) { // ARM_EXIDX_CMD_DATA_POP
       /* vsp = vsp + (xxxxxx << 2) + 4 */
-      ucb->vrs[13] += ((instruction & 0x3f) << 2) + 4;
+      ucb->vrs[13] += ((instruction & 0x3F) << 2) + 4;
     } else
-    if ((instruction & 0xc0) == 0x40) { // ARM_EXIDX_CMD_DATA_PUSH
+    if ((instruction & 0xC0) == 0x40) { // ARM_EXIDX_CMD_DATA_PUSH
       /* vsp = vsp - (xxxxxx << 2) - 4 */
-      ucb->vrs[13] -= ((instruction & 0x3f) << 2) - 4;
+      ucb->vrs[13] -= ((instruction & 0x3F) << 2) - 4;
     } else
-    if ((instruction & 0xf0) == 0x80) {
+    if ((instruction & 0xF0) == 0x80) {
       /* pop under mask {r15-r12},{r11-r4} or refuse to unwind */
       instruction = instruction << 8 | UnwTabGetNextInstruction(cb, ucb);
 
 
       /* Pop registers using mask */    // ARM_EXIDX_CMD_REG_POP
       vsp = ucb->vrs[13];
-      mask = instruction & 0xfff;
+      mask = instruction & 0xFFF;
 
       reg = 4;
       while (mask) {
         ucb->vrs[13] = vsp;
 
     } else
-    if ((instruction & 0xf0) == 0x90 && // ARM_EXIDX_CMD_REG_TO_SP
-        instruction != 0x9d &&
-        instruction != 0x9f) {
+    if ((instruction & 0xF0) == 0x90 && // ARM_EXIDX_CMD_REG_TO_SP
+        instruction != 0x9D &&
+        instruction != 0x9F) {
       /* vsp = r[nnnn] */
-      ucb->vrs[13] = ucb->vrs[instruction & 0x0f];
+      ucb->vrs[13] = ucb->vrs[instruction & 0x0F];
     } else
-    if ((instruction & 0xf0) == 0xa0) { // ARM_EXIDX_CMD_REG_POP
+    if ((instruction & 0xF0) == 0xA0) { // ARM_EXIDX_CMD_REG_POP
       /* pop r4-r[4+nnn] or pop r4-r[4+nnn], r14*/
       vsp = ucb->vrs[13];
 
       ucb->vrs[13] = vsp;
 
     } else
-    if (instruction == 0xb0) { // ARM_EXIDX_CMD_FINISH
+    if (instruction == 0xB0) { // ARM_EXIDX_CMD_FINISH
       /* finished */
       if (ucb->vrs[15] == 0)
         ucb->vrs[15] = ucb->vrs[14];
       return UNWIND_SUCCESS;
 
     } else
-    if (instruction == 0xb1) { // ARM_EXIDX_CMD_REG_POP
+    if (instruction == 0xB1) { // ARM_EXIDX_CMD_REG_POP
       /* pop register under mask {r3,r2,r1,r0} */
       vsp = ucb->vrs[13];
       mask = UnwTabGetNextInstruction(cb, ucb);
       ucb->vrs[13] = (uint32_t)vsp;
 
     } else
-    if (instruction == 0xb2) { // ARM_EXIDX_CMD_DATA_POP
+    if (instruction == 0xB2) { // ARM_EXIDX_CMD_DATA_POP
       /* vps = vsp + 0x204 + (uleb128 << 2) */
       ucb->vrs[13] += 0x204 + (UnwTabGetNextInstruction(cb, ucb) << 2);
 
     } else
-    if (instruction == 0xb3 || // ARM_EXIDX_CMD_VFP_POP
-      instruction == 0xc8 ||
-      instruction == 0xc9) {
+    if (instruction == 0xB3 || // ARM_EXIDX_CMD_VFP_POP
+      instruction == 0xC8 ||
+      instruction == 0xC9) {
 
       /* pop VFP double-precision registers */
       vsp = ucb->vrs[13];
       ucb->vrs[14] = v;
       vsp += 4;
 
-      if (instruction == 0xc8) {
+      if (instruction == 0xC8) {
         /* D[16+sssss]-D[16+ssss+cccc] */
         ucb->vrs[14] |= 1 << 16;
       }
 
-      if (instruction != 0xb3) {
+      if (instruction != 0xB3) {
         /* D[sssss]-D[ssss+cccc] */
         ucb->vrs[14] |= 1 << 17;
       }
       ucb->vrs[13] = vsp;
 
     } else
-    if ((instruction & 0xf8) == 0xb8 ||
-        (instruction & 0xf8) == 0xd0) {
+    if ((instruction & 0xF8) == 0xB8 ||
+        (instruction & 0xF8) == 0xD0) {
 
       /* Pop VFP double precision registers D[8]-D[8+nnn] */
       ucb->vrs[14] = 0x80 | (instruction & 0x07);
 
-      if ((instruction & 0xf8) == 0xd0) {
+      if ((instruction & 0xF8) == 0xD0) {
         ucb->vrs[14] = 1 << 17;
       }
 
 
   /* Check for exception return */
   /* TODO Test with other ARM processors to verify this method. */
-  if ((ucb.vrs[15] & 0xf0000000) == 0xf0000000) {
+  if ((ucb.vrs[15] & 0xF0000000) == 0xF0000000) {
     /* According to the Cortex Programming Manual (p.44), the stack address is always 8-byte aligned (Cortex-M7).
        Depending on where the exception came from (MSP or PSP), we need the right SP value to work with.
 
        If we need to start from the PSP, we need to go up exactly 6 words to find the PC.
        See the ARMv7-M Architecture Reference Manual p.594 and Cortex-M7 Processor Programming Manual p.44/p.45 for details.
     */
-    if ((ucb.vrs[15] & 0xc) == 0) {
-      /* Return to Handler Mode: MSP (0xffffff-1) */
+    if ((ucb.vrs[15] & 0xC) == 0) {
+      /* Return to Handler Mode: MSP (0xFFFFFF-1) */
       stack = ucb.vrs[13];
 
       /* The PC is always 2 words down from the MSP, if it was a non-floating-point exception */
       stack -= 2*4;
 
-      /* If there was a VFP exception (0xffffffe1), the PC is located another 18 words down */
-      if ((ucb.vrs[15] & 0xf0) == 0xe0) {
+      /* If there was a VFP exception (0xFFFFFFE1), the PC is located another 18 words down */
+      if ((ucb.vrs[15] & 0xF0) == 0xE0) {
         stack -= 18*4;
       }
     }
     else {
-      /* Return to Thread Mode: PSP (0xffffff-d) */
+      /* Return to Thread Mode: PSP (0xFFFFFF-d) */
       stack = read_psp();
 
       /* The PC is always 6 words up from the PSP */
     const UnwTabEntry *index = UnwTabSearchIndex(__exidx_start, __exidx_end, frame->pc);
 
     /* Clear last bit (Thumb indicator) */
-    frame->pc &= 0xfffffffeU;
+    frame->pc &= 0xFFFFFFFEU;
 
     /* Generate the backtrace information */
     entry.address = frame->pc;

Marlin/src/backtrace/unwarmmem.cpp

       M_SetIdxUsed(memData->tracked, i);
     }
     else {
-#if defined(UNW_DEBUG)
-      memData->v[i] = 0xdeadbeef;
-#endif
+      #if defined(UNW_DEBUG)
+        memData->v[i] = 0xDEADBEEF;
+      #endif
       M_ClrIdxUsed(memData->tracked, i);
     }
 

Marlin/src/lcd/dogm/u8g_dev_ssd1306_sh1106_128x64_I2C.cpp

         u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem);
         u8g_SetAddress(u8g, dev, 0);           // instruction mode
         u8g_WriteEscSeqP_2_wire(u8g, dev, u8g_dev_sh1106_128x64_data_start_2_wire);
-        u8g_WriteByte(u8g, dev, 0x0b0 | (pb->p.page*2)); // select current page
+        u8g_WriteByte(u8g, dev, 0x0B0 | (pb->p.page*2)); // select current page
         u8g_SetAddress(u8g, dev, 1);           // data mode
         u8g_WriteSequence(u8g, dev, pb->width, (uint8_t *) pb->buf);
         u8g_SetChipSelect(u8g, dev, 0);
         u8g_SetAddress(u8g, dev, 0);           // instruction mode
         u8g_WriteEscSeqP_2_wire(u8g, dev, u8g_dev_sh1106_128x64_data_start_2_wire);
-        u8g_WriteByte(u8g, dev, 0x0b0 | (pb->p.page*2+1)); // select current page
+        u8g_WriteByte(u8g, dev, 0x0B0 | (pb->p.page*2+1)); // select current page
         u8g_SetAddress(u8g, dev, 1);           // data mode
         u8g_WriteSequence(u8g, dev, pb->width, (uint8_t *)(pb->buf)+pb->width);
         u8g_SetChipSelect(u8g, dev, 0);
         u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem);
         u8g_SetAddress(u8g, dev, 0);           // instruction mode
         u8g_WriteEscSeqP_2_wire(u8g, dev, u8g_dev_ssd1306_128x64_data_start_2_wire);
-        u8g_WriteByte(u8g, dev, 0x0b0 | (pb->p.page*2)); // select current page
+        u8g_WriteByte(u8g, dev, 0x0B0 | (pb->p.page*2)); // select current page
         u8g_SetAddress(u8g, dev, 1);           // data mode
         u8g_WriteSequence(u8g, dev, pb->width, (uint8_t *) pb->buf);
         u8g_SetChipSelect(u8g, dev, 0);
         u8g_SetAddress(u8g, dev, 0);           // instruction mode
         u8g_WriteEscSeqP_2_wire(u8g, dev, u8g_dev_ssd1306_128x64_data_start_2_wire);
-        u8g_WriteByte(u8g, dev, 0x0b0 | (pb->p.page*2+1)); // select current page
+        u8g_WriteByte(u8g, dev, 0x0B0 | (pb->p.page*2+1)); // select current page
         u8g_SetAddress(u8g, dev, 1);           // data mode
         u8g_WriteSequence(u8g, dev, pb->width, (uint8_t *)(pb->buf)+pb->width);
         u8g_SetChipSelect(u8g, dev, 0);
       else if (value == 254) {
         break;
       }
-      else if (value >= 0x0f0) {
+      else if (value >= 0x0F0) {
         /* not yet used, do nothing */
       }
-      else if (value >= 0xe0 ) {
-        u8g_SetAddress(u8g, dev, value & 0x0f);
+      else if (value >= 0xE0 ) {
+        u8g_SetAddress(u8g, dev, value & 0x0F);
       }
-      else if (value >= 0xd0) {
-        u8g_SetChipSelect(u8g, dev, value & 0x0f);
+      else if (value >= 0xD0) {
+        u8g_SetChipSelect(u8g, dev, value & 0x0F);
       }
-      else if (value >= 0xc0) {
+      else if (value >= 0xC0) {
         u8g_SetResetLow(u8g, dev);
-        value &= 0x0f;
+        value &= 0x0F;
         value <<= 4;
         value+=2;
         u8g_Delay(value);
         u8g_SetResetHigh(u8g, dev);
         u8g_Delay(value);
       }
-      else if (value >= 0xbe) {                       /* not yet implemented */
+      else if (value >= 0xBE) {                       /* not yet implemented */
         /* u8g_SetVCC(u8g, dev, value & 0x01); */
       }
       else if (value <= 127) {

Marlin/src/lcd/dogm/u8g_dev_st7565_64128n_HAL.cpp

     U8G_ESC_CS(1),      // enable chip
     U8G_ESC_RST(15),    // do reset low pulse with (15*16)+2 milliseconds (=maximum delay)*/
 
-    0x0A2,              // 0x0a2: LCD bias 1/9 (according to Displaytech 64128N datasheet)
+    0x0A2,              // 0x0A2: LCD bias 1/9 (according to Displaytech 64128N datasheet)
     0x0A0,              // Normal ADC Select (according to Displaytech 64128N datasheet)
 
-    0x0c8,              // common output mode: set scan direction normal operation/SHL Select, 0x0c0 --> SHL = 0, normal, 0x0c8 --> SHL = 1
+    0x0C8,              // common output mode: set scan direction normal operation/SHL Select, 0x0C0 --> SHL = 0, normal, 0x0C8 --> SHL = 1
     0x040,              // Display start line for Displaytech 64128N
 
     0x028 | 0x04,       // power control: turn on voltage converter
 
     0x010,              // Set V0 voltage resistor ratio. Setting for controlling brightness of Displaytech 64128N
 
-    0x0a6,              // display normal, bit val 0: LCD pixel off.
+    0x0A6,              // display normal, bit val 0: LCD pixel off.
 
     0x081,              // set contrast
-    0x01e,              // Contrast value. Setting for controlling brightness of Displaytech 64128N
+    0x01E,              // Contrast value. Setting for controlling brightness of Displaytech 64128N
 
 
-    0x0af,              // display on
+    0x0AF,              // display on
 
     U8G_ESC_DLY(100),   // delay 100 ms
-    0x0a5,              // display all points, ST7565
+    0x0A5,              // display all points, ST7565
     U8G_ESC_DLY(100),   // delay 100 ms
     U8G_ESC_DLY(100),   // delay 100 ms
-    0x0a4,              // normal display
+    0x0A4,              // normal display
     U8G_ESC_CS(0),      // disable chip
     U8G_ESC_END         // end of sequence
 };
 static const uint8_t u8g_dev_st7565_64128n_HAL_sleep_on[] PROGMEM = {
   U8G_ESC_ADR(0),       // instruction mode
   U8G_ESC_CS(1),        // enable chip
-  0x0ac,                // static indicator off
+  0x0AC,                // static indicator off
   0x000,                // indicator register set (not sure if this is required)
-  0x0ae,                // display off
-  0x0a5,                // all points on
+  0x0AE,                // display off
+  0x0A5,                // all points on
   U8G_ESC_CS(0),        // disable chip, bugfix 12 nov 2014
   U8G_ESC_END           // end of sequence
   };
 static const uint8_t u8g_dev_st7565_64128n_HAL_sleep_off[] PROGMEM = {
   U8G_ESC_ADR(0),       // instruction mode
   U8G_ESC_CS(1),        // enable chip
-  0x0a4,                // all points off
-  0x0af,                // display on
+  0x0A4,                // all points off
+  0x0AF,                // display on
   U8G_ESC_DLY(50),      // delay 50 ms
   U8G_ESC_CS(0),        // disable chip, bugfix 12 nov 2014
   U8G_ESC_END           // end of sequence
     case U8G_DEV_MSG_PAGE_NEXT: {
         u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem);
         u8g_WriteEscSeqP(u8g, dev, u8g_dev_st7565_64128n_HAL_data_start);
-        u8g_WriteByte(u8g, dev, 0x0b0 | pb->p.page); /* select current page (ST7565R) */
+        u8g_WriteByte(u8g, dev, 0x0B0 | pb->p.page); /* select current page (ST7565R) */
         u8g_SetAddress(u8g, dev, 1);           /* data mode */
         if ( u8g_pb_WriteBuffer(pb, u8g, dev) == 0 )
           return 0;
         u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem);
 
         u8g_WriteEscSeqP(u8g, dev, u8g_dev_st7565_64128n_HAL_data_start);
-        u8g_WriteByte(u8g, dev, 0x0b0 | (2*pb->p.page)); /* select current page (ST7565R) */
+        u8g_WriteByte(u8g, dev, 0x0B0 | (2*pb->p.page)); /* select current page (ST7565R) */
         u8g_SetAddress(u8g, dev, 1);           /* data mode */
         u8g_WriteSequence(u8g, dev, pb->width, (uint8_t *)pb->buf);
         u8g_SetChipSelect(u8g, dev, 0);
 
         u8g_WriteEscSeqP(u8g, dev, u8g_dev_st7565_64128n_HAL_data_start);
-        u8g_WriteByte(u8g, dev, 0x0b0 | (2*pb->p.page+1)); /* select current page (ST7565R) */
+        u8g_WriteByte(u8g, dev, 0x0B0 | (2*pb->p.page+1)); /* select current page (ST7565R) */
         u8g_SetAddress(u8g, dev, 1);           /* data mode */
         u8g_WriteSequence(u8g, dev, pb->width, (uint8_t *)(pb->buf)+pb->width);
         u8g_SetChipSelect(u8g, dev, 0);

Marlin/src/lcd/dogm/u8g_dev_st7920_128x64_HAL.cpp

   U8G_ESC_DLY(50),    // delay 50 ms
 
   0x038,              // 8 Bit interface (DL=1), basic instruction set (RE=0)
-  0x00c,              // display on, cursor & blink off; 0x08: all off
+  0x00C,              // display on, cursor & blink off; 0x08: all off
   0x006,              // Entry mode: Cursor move to right ,DDRAM address counter (AC) plus 1, no shift
   0x002,              // disable scroll, enable CGRAM adress
   0x001,              // clear RAM, needs 1.6 ms
       ptr = (uint8_t *)pb->buf;
       for (i = 0; i < 8; i ++) {
         u8g_SetAddress(u8g, dev, 0);           /* cmd mode */
-        u8g_WriteByte(u8g, dev, 0x03e );      /* enable extended mode */
+        u8g_WriteByte(u8g, dev, 0x03E );      /* enable extended mode */
 
         if (y < 32) {
           u8g_WriteByte(u8g, dev, 0x080 | y );      /* y pos  */
       ptr = (uint8_t *)pb->buf;
       for (i = 0; i < 32; i ++) {
         u8g_SetAddress(u8g, dev, 0);           /* cmd mode */
-        u8g_WriteByte(u8g, dev, 0x03e );      /* enable extended mode */
+        u8g_WriteByte(u8g, dev, 0x03E );      /* enable extended mode */
 
         if (y < 32) {
           u8g_WriteByte(u8g, dev, 0x080 | y );      /* y pos  */

Marlin/src/lcd/dogm/u8g_dev_uc1701_mini12864_HAL.cpp

   U8G_ESC_RST(1),           /* do reset low pulse with (1*16)+2 milliseconds */
   U8G_ESC_CS(1),             /* enable chip */
 
-  0x0e2,            /* soft reset */
+  0x0E2,            /* soft reset */
   0x040,    /* set display start line to 0 */
-  0x0a0,    /* ADC set to reverse */
-  0x0c8,    /* common output mode */
-  0x0a6,    /* display normal, bit val 0: LCD pixel off. */
-  0x0a2,    /* LCD bias 1/9 */
-  0x02f,    /* all power  control circuits on */
-  0x0f8,    /* set booster ratio to */
+  0x0A0,    /* ADC set to reverse */
+  0x0C8,    /* common output mode */
+  0x0A6,    /* display normal, bit val 0: LCD pixel off. */
+  0x0A2,    /* LCD bias 1/9 */
+  0x02F,    /* all power  control circuits on */
+  0x0F8,    /* set booster ratio to */
   0x000,    /* 4x */
   0x023,    /* set V0 voltage resistor ratio to large */
   0x081,    /* set contrast */
   0x027,    /* contrast value */
-  0x0ac,    /* indicator */
+  0x0AC,    /* indicator */
   0x000,    /* disable */
-  0x0af,    /* display on */
+  0x0AF,    /* display on */
 
   U8G_ESC_DLY(100),       /* delay 100 ms */
-  0x0a5,                    /* display all points, ST7565 */
+  0x0A5,                    /* display all points, ST7565 */
   U8G_ESC_DLY(100),       /* delay 100 ms */
   U8G_ESC_DLY(100),       /* delay 100 ms */
-  0x0a4,                    /* normal display */
+  0x0A4,                    /* normal display */
   U8G_ESC_CS(0),             /* disable chip */
   U8G_ESC_END                /* end of sequence */
 };
       {
         u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem);
         u8g_WriteEscSeqP(u8g, dev, u8g_dev_uc1701_mini12864_HAL_data_start);
-        u8g_WriteByte(u8g, dev, 0x0b0 | pb->p.page); /* select current page */
+        u8g_WriteByte(u8g, dev, 0x0B0 | pb->p.page); /* select current page */
         u8g_SetAddress(u8g, dev, 1);           /* data mode */
         if ( u8g_pb_WriteBuffer(pb, u8g, dev) == 0 )
           return 0;
         u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem);
 
         u8g_WriteEscSeqP(u8g, dev, u8g_dev_uc1701_mini12864_HAL_data_start);
-        u8g_WriteByte(u8g, dev, 0x0b0 | (2*pb->p.page)); /* select current page */
+        u8g_WriteByte(u8g, dev, 0x0B0 | (2*pb->p.page)); /* select current page */
         u8g_SetAddress(u8g, dev, 1);           /* data mode */
   u8g_WriteSequence(u8g, dev, pb->width, (uint8_t *)pb->buf);
         u8g_SetChipSelect(u8g, dev, 0);
 
         u8g_WriteEscSeqP(u8g, dev, u8g_dev_uc1701_mini12864_HAL_data_start);
-        u8g_WriteByte(u8g, dev, 0x0b0 | (2*pb->p.page+1)); /* select current page */
+        u8g_WriteByte(u8g, dev, 0x0B0 | (2*pb->p.page+1)); /* select current page */
         u8g_SetAddress(u8g, dev, 1);           /* data mode */
   u8g_WriteSequence(u8g, dev, pb->width, (uint8_t *)(pb->buf)+pb->width);
         u8g_SetChipSelect(u8g, dev, 0);

Marlin/src/module/planner.cpp

     //  // Get most significant bit set on divider
     //  uint8_t idx = 0;
     //  uint32_t nr = d;
-    //  if (!(nr & 0xff0000)) {
+    //  if (!(nr & 0xFF0000)) {
     //    nr <<= 8;
     //    idx += 8;
-    //    if (!(nr & 0xff0000)) {
+    //    if (!(nr & 0xFF0000)) {
     //      nr <<= 8;
     //      idx += 8;
     //    }
     //  }
-    //  if (!(nr & 0xf00000)) {
+    //  if (!(nr & 0xF00000)) {
     //    nr <<= 4;
     //    idx += 4;
     //  }
-    //  if (!(nr & 0xc00000)) {
+    //  if (!(nr & 0xC00000)) {
     //    nr <<= 2;
     //    idx += 2;
     //  }

Marlin/src/module/stepper.h

         step_rate -= F_CPU / 500000; // Correct for minimal speed
         if (step_rate >= (8 * 256)) { // higher step rate
           unsigned short table_address = (unsigned short)&speed_lookuptable_fast[(unsigned char)(step_rate >> 8)][0];
-          unsigned char tmp_step_rate = (step_rate & 0x00ff);
+          unsigned char tmp_step_rate = (step_rate & 0x00FF);
           unsigned short gain = (unsigned short)pgm_read_word_near(table_address + 2);
           MultiU16X8toH16(timer, tmp_step_rate, gain);
           timer = (unsigned short)pgm_read_word_near(table_address) - timer;
         }
         else { // lower step rates
           unsigned short table_address = (unsigned short)&speed_lookuptable_slow[0][0];
-          table_address += ((step_rate) >> 1) & 0xfffc;
+          table_address += ((step_rate) >> 1) & 0xFFFC;
           timer = (unsigned short)pgm_read_word_near(table_address);
           timer -= (((unsigned short)pgm_read_word_near(table_address + 2) * (unsigned char)(step_rate & 0x0007)) >> 3);
         }

Marlin/src/sd/Sd2Card.cpp

 
   #ifdef FAST_CRC
     static const uint8_t crctab7[] PROGMEM = {
-      0x00,0x09,0x12,0x1b,0x24,0x2d,0x36,0x3f,0x48,0x41,0x5a,0x53,0x6c,0x65,0x7e,0x77,
-      0x19,0x10,0x0b,0x02,0x3d,0x34,0x2f,0x26,0x51,0x58,0x43,0x4a,0x75,0x7c,0x67,0x6e,
-      0x32,0x3b,0x20,0x29,0x16,0x1f,0x04,0x0d,0x7a,0x73,0x68,0x61,0x5e,0x57,0x4c,0x45,
-      0x2b,0x22,0x39,0x30,0x0f,0x06,0x1d,0x14,0x63,0x6a,0x71,0x78,0x47,0x4e,0x55,0x5c,
-      0x64,0x6d,0x76,0x7f,0x40,0x49,0x52,0x5b,0x2c,0x25,0x3e,0x37,0x08,0x01,0x1a,0x13,
-      0x7d,0x74,0x6f,0x66,0x59,0x50,0x4b,0x42,0x35,0x3c,0x27,0x2e,0x11,0x18,0x03,0x0a,
-      0x56,0x5f,0x44,0x4d,0x72,0x7b,0x60,0x69,0x1e,0x17,0x0c,0x05,0x3a,0x33,0x28,0x21,
-      0x4f,0x46,0x5d,0x54,0x6b,0x62,0x79,0x70,0x07,0x0e,0x15,0x1c,0x23,0x2a,0x31,0x38,
-      0x41,0x48,0x53,0x5a,0x65,0x6c,0x77,0x7e,0x09,0x00,0x1b,0x12,0x2d,0x24,0x3f,0x36,
-      0x58,0x51,0x4a,0x43,0x7c,0x75,0x6e,0x67,0x10,0x19,0x02,0x0b,0x34,0x3d,0x26,0x2f,
-      0x73,0x7a,0x61,0x68,0x57,0x5e,0x45,0x4c,0x3b,0x32,0x29,0x20,0x1f,0x16,0x0d,0x04,
-      0x6a,0x63,0x78,0x71,0x4e,0x47,0x5c,0x55,0x22,0x2b,0x30,0x39,0x06,0x0f,0x14,0x1d,
-      0x25,0x2c,0x37,0x3e,0x01,0x08,0x13,0x1a,0x6d,0x64,0x7f,0x76,0x49,0x40,0x5b,0x52,
-      0x3c,0x35,0x2e,0x27,0x18,0x11,0x0a,0x03,0x74,0x7d,0x66,0x6f,0x50,0x59,0x42,0x4b,
-      0x17,0x1e,0x05,0x0c,0x33,0x3a,0x21,0x28,0x5f,0x56,0x4d,0x44,0x7b,0x72,0x69,0x60,
-      0x0e,0x07,0x1c,0x15,0x2a,0x23,0x38,0x31,0x46,0x4f,0x54,0x5d,0x62,0x6b,0x70,0x79
+      0x00,0x09,0x12,0x1B,0x24,0x2D,0x36,0x3F,0x48,0x41,0x5A,0x53,0x6C,0x65,0x7E,0x77,
+      0x19,0x10,0x0B,0x02,0x3D,0x34,0x2F,0x26,0x51,0x58,0x43,0x4A,0x75,0x7C,0x67,0x6E,
+      0x32,0x3B,0x20,0x29,0x16,0x1F,0x04,0x0D,0x7A,0x73,0x68,0x61,0x5E,0x57,0x4C,0x45,
+      0x2B,0x22,0x39,0x30,0x0F,0x06,0x1D,0x14,0x63,0x6A,0x71,0x78,0x47,0x4E,0x55,0x5C,
+      0x64,0x6D,0x76,0x7F,0x40,0x49,0x52,0x5B,0x2C,0x25,0x3E,0x37,0x08,0x01,0x1A,0x13,
+      0x7D,0x74,0x6F,0x66,0x59,0x50,0x4B,0x42,0x35,0x3C,0x27,0x2E,0x11,0x18,0x03,0x0A,
+      0x56,0x5F,0x44,0x4D,0x72,0x7B,0x60,0x69,0x1E,0x17,0x0C,0x05,0x3A,0x33,0x28,0x21,
+      0x4F,0x46,0x5D,0x54,0x6B,0x62,0x79,0x70,0x07,0x0E,0x15,0x1C,0x23,0x2A,0x31,0x38,
+      0x41,0x48,0x53,0x5A,0x65,0x6C,0x77,0x7E,0x09,0x00,0x1B,0x12,0x2D,0x24,0x3F,0x36,
+      0x58,0x51,0x4A,0x43,0x7C,0x75,0x6E,0x67,0x10,0x19,0x02,0x0B,0x34,0x3D,0x26,0x2F,
+      0x73,0x7A,0x61,0x68,0x57,0x5E,0x45,0x4C,0x3B,0x32,0x29,0x20,0x1F,0x16,0x0D,0x04,
+      0x6A,0x63,0x78,0x71,0x4E,0x47,0x5C,0x55,0x22,0x2B,0x30,0x39,0x06,0x0F,0x14,0x1D,
+      0x25,0x2C,0x37,0x3E,0x01,0x08,0x13,0x1A,0x6D,0x64,0x7F,0x76,0x49,0x40,0x5B,0x52,
+      0x3C,0x35,0x2E,0x27,0x18,0x11,0x0A,0x03,0x74,0x7D,0x66,0x6F,0x50,0x59,0x42,0x4B,
+      0x17,0x1E,0x05,0x0C,0x33,0x3A,0x21,0x28,0x5F,0x56,0x4D,0x44,0x7B,0x72,0x69,0x60,
+      0x0E,0x07,0x1C,0x15,0x2A,0x23,0x38,0x31,0x46,0x4F,0x54,0x5D,0x62,0x6B,0x70,0x79
     };
 
     static uint8_t CRC7(const uint8_t* data, uint8_t n) {
         d ^= crc << 1;
         if (d & 0x80) d ^= 9;
         crc = d ^ (crc & 0x78) ^ (crc << 4) ^ ((crc >> 3) & 15);
-        crc &= 0x7f;
+        crc &= 0x7F;
       }
-      crc = (crc << 1) ^ (crc << 4) ^ (crc & 0x70) ^ ((crc >> 3) & 0x0f);
+      crc = (crc << 1) ^ (crc << 4) ^ (crc & 0x70) ^ ((crc >> 3) & 0x0F);
       return crc | 1;
     }
   #endif
       for (size_t i = 0; i < n; i++) {
         crc = (uint8_t)(crc >> 8) | (crc << 8);
         crc ^= data[i];
-        crc ^= (uint8_t)(crc & 0xff) >> 4;
+        crc ^= (uint8_t)(crc & 0xFF) >> 4;
         crc ^= crc << 12;
-        crc ^= (crc & 0xff) << 5;
+        crc ^= (crc & 0xFF) << 5;
       }
       return crc;
     }