🐛 Spellcheck comments (#22496)

codespell -q 3 --builtin=clear,rare,informal,code -S ./Marlin/src/lcd/language -L alo,amin,endcode,stdio,uint

Marlin/Configuration.h

 #endif
 
 // Duet Smart Effector (for delta printers) - https://bit.ly/2ul5U7J
-// When the pin is defined you can use M672 to set/reset the probe sensivity.
+// When the pin is defined you can use M672 to set/reset the probe sensitivity.
 //#define DUET_SMART_EFFECTOR
 #if ENABLED(DUET_SMART_EFFECTOR)
   #define SMART_EFFECTOR_MOD_PIN  -1  // Connect a GPIO pin to the Smart Effector MOD pin

Marlin/Configuration_adv.h

    */
   #define I2CPE_MIN_UPD_TIME_MS     4                       // (ms) Minimum time between encoder checks.
 
-  // Use a rolling average to identify persistant errors that indicate skips, as opposed to vibration and noise.
+  // Use a rolling average to identify persistent errors that indicate skips, as opposed to vibration and noise.
   #define I2CPE_ERR_ROLLING_AVERAGE
 
 #endif // I2C_POSITION_ENCODERS

Marlin/Makefile

 WIRE               ?= 0
 
 # This defines if Tone is needed (i.e SPEAKER is defined in Configuration.h)
-# Disabling this (and SPEAKER) saves approximatively 350 bytes of memory.
+# Disabling this (and SPEAKER) saves approximately 350 bytes of memory.
 TONE               ?= 1
 
 # This defines if U8GLIB is needed (may require RELOC_WORKAROUND)

Marlin/src/HAL/AVR/fastio.h

  * PWM availability macros
  */
 
-// Determine which harware PWMs are already in use
+// Determine which hardware PWMs are already in use
 #define _PWM_CHK_FAN_B(P) (P == E0_AUTO_FAN_PIN || P == E1_AUTO_FAN_PIN || P == E2_AUTO_FAN_PIN || P == E3_AUTO_FAN_PIN || P == E4_AUTO_FAN_PIN || P == E5_AUTO_FAN_PIN || P == E6_AUTO_FAN_PIN || P == E7_AUTO_FAN_PIN || P == CHAMBER_AUTO_FAN_PIN || P == COOLER_AUTO_FAN_PIN)
 #if PIN_EXISTS(CONTROLLER_FAN)
   #define PWM_CHK_FAN_B(P) (_PWM_CHK_FAN_B(P) || P == CONTROLLER_FAN_PIN)

Marlin/src/HAL/DUE/HAL_SPI.cpp

     } while (--todo);
   }
 
-  // Pointers to generic functions for block tranfers
+  // Pointers to generic functions for block transfers
   static pfnSpiTxBlock spiTxBlock = (pfnSpiTxBlock)spiTxBlockX;
   static pfnSpiRxBlock spiRxBlock = (pfnSpiRxBlock)spiRxBlockX;
 

Marlin/src/HAL/DUE/usb/arduino_due_x.h

 /* ------------------------------------------------------------------------ */
 
 /**
- * \page arduino_due_x_board_info "Arduino Due/X - Board informations"
+ * \page arduino_due_x_board_info "Arduino Due/X - Board information"
  * This page lists several definition related to the board description.
  *
  */

Marlin/src/HAL/DUE/usb/udd.h

 	//! This buffer must be word align for DATA IN phase (use prefix COMPILER_WORD_ALIGNED for buffer)
 	uint8_t *payload;
 
-	//! Size of buffer to send or fill, and content the number of byte transfered
+	//! Size of buffer to send or fill, and content the number of byte transferred
 	uint16_t payload_size;
 
 	//! Callback called after reception of ZLP from setup request
  *
  * \param status     UDD_EP_TRANSFER_OK, if transfer is complete
  * \param status     UDD_EP_TRANSFER_ABORT, if transfer is aborted
- * \param n          number of data transfered
+ * \param n          number of data transferred
  */
 typedef void (*udd_callback_trans_t) (udd_ep_status_t status,
 		iram_size_t nb_transfered, udd_ep_id_t ep);
  * The driver uses a specific DMA USB to transfer data
  * from internal RAM to endpoint, if this one is available.
  * When the transfer is finished or aborted (stall, reset, ...), the \a callback is called.
- * The \a callback returns the transfer status and eventually the number of byte transfered.
+ * The \a callback returns the transfer status and eventually the number of byte transferred.
  * Note: The control endpoint is not authorized.
  *
  * \param ep            The ID of the endpoint to use

Marlin/src/HAL/DUE/usb/udi_cdc.c

  *
  * \param status     UDD_EP_TRANSFER_OK, if transfer finished
  * \param status     UDD_EP_TRANSFER_ABORT, if transfer aborted
- * \param n          number of data transfered
+ * \param n          number of data transferred
  */
 static void udi_cdc_serial_state_msg_sent(udd_ep_status_t status, iram_size_t n, udd_ep_id_t ep);
 
  *
  * \param status     UDD_EP_TRANSFER_OK, if transfer finished
  * \param status     UDD_EP_TRANSFER_ABORT, if transfer aborted
- * \param n          number of data transfered
+ * \param n          number of data transferred
  */
 static void udi_cdc_data_sent(udd_ep_status_t status, iram_size_t n, udd_ep_id_t ep);
 

Marlin/src/HAL/DUE/usb/udi_cdc_conf.h

  */
 //@{
 #  if UDI_CDC_PORT_NB > 2
-#    error USBB, UDP, UDPHS and UOTGHS interfaces have not enought endpoints.
+#    error USBB, UDP, UDPHS and UOTGHS interfaces have not enough endpoints.
 #  endif
 #define  UDI_CDC_DATA_EP_IN_0          (1 | USB_EP_DIR_IN)  // TX
 #define  UDI_CDC_DATA_EP_OUT_0         (2 | USB_EP_DIR_OUT) // RX

Marlin/src/HAL/DUE/usb/udi_msc.c

  *
  * \param status       UDD_EP_TRANSFER_OK, if transfer is finished
  * \param status       UDD_EP_TRANSFER_ABORT, if transfer is aborted
- * \param nb_received  number of data transfered
+ * \param nb_received  number of data transferred
  */
 static void udi_msc_cbw_received(udd_ep_status_t status,
     iram_size_t nb_received, udd_ep_id_t ep);
  *
  * \param status     UDD_EP_TRANSFER_OK, if transfer finish
  * \param status     UDD_EP_TRANSFER_ABORT, if transfer aborted
- * \param nb_sent    number of data transfered
+ * \param nb_sent    number of data transferred
  */
 static void udi_msc_data_sent(udd_ep_status_t status, iram_size_t nb_sent,
     udd_ep_id_t ep);
  *
  * \param status     UDD_EP_TRANSFER_OK, if transfer is finished
  * \param status     UDD_EP_TRANSFER_ABORT, if transfer is aborted
- * \param nb_sent    number of data transfered
+ * \param nb_sent    number of data transferred
  */
 static void udi_msc_csw_sent(udd_ep_status_t status, iram_size_t nb_sent,
     udd_ep_id_t ep);
 static void udi_msc_cbw_invalid(void)
 {
   if (!udi_msc_b_cbw_invalid)
-    return; // Don't re-stall endpoint if error reseted by setup
+    return; // Don't re-stall endpoint if error reset by setup
   udd_ep_set_halt(UDI_MSC_EP_OUT);
   // If stall cleared then re-stall it. Only Setup MSC Reset can clear it
   udd_ep_wait_stall_clear(UDI_MSC_EP_OUT, udi_msc_cbw_invalid);
 static void udi_msc_csw_invalid(void)
 {
   if (!udi_msc_b_cbw_invalid)
-    return; // Don't re-stall endpoint if error reseted by setup
+    return; // Don't re-stall endpoint if error reset by setup
   udd_ep_set_halt(UDI_MSC_EP_IN);
   // If stall cleared then re-stall it. Only Setup MSC Reset can clear it
   udd_ep_wait_stall_clear(UDI_MSC_EP_IN, udi_msc_csw_invalid);

Marlin/src/HAL/DUE/usb/uotghs_device_due.c

 /**
  * \name Control endpoint low level management routine.
  *
- * This function performs control endpoint mangement.
+ * This function performs control endpoint management.
  * It handle the SETUP/DATA/HANDSHAKE phases of a control transaction.
  */
 //@{
 /**
  * \brief Main interrupt routine for control endpoint
  *
- * This switchs control endpoint events to correct sub function.
+ * This switches control endpoint events to correct sub function.
  *
- * \return \c 1 if an event about control endpoint is occured, otherwise \c 0.
+ * \return \c 1 if an event about control endpoint is occurred, otherwise \c 0.
  */
 static bool udd_ctrl_interrupt(void);
 
  * \name Management of bulk/interrupt/isochronous endpoints
  *
  * The UDD manages the data transfer on endpoints:
- * - Start data tranfer on endpoint with USB Device DMA
+ * - Start data transfer on endpoint with USB Device DMA
  * - Send a ZLP packet if requested
  * - Call callback registered to signal end of transfer
  * The transfer abort and stall feature are supported.
 	uint8_t *buf;
 	//! Size of buffer to send or fill
 	iram_size_t buf_size;
-	//!< Size of data transfered
+	//!< Size of data transferred
 	iram_size_t buf_cnt;
 	//!< Size of data loaded (or prepared for DMA) last time
 	iram_size_t buf_load;
 
 #ifdef UDD_EP_DMA_SUPPORTED
 	/**
-	 * \brief Start the next transfer if necessary or complet the job associated.
+	 * \brief Start the next transfer if necessary or complete the job associated.
 	 *
 	 * \param ep endpoint number without direction flag
 	 */
 /**
  * \brief Main interrupt routine for bulk/interrupt/isochronous endpoints
  *
- * This switchs endpoint events to correct sub function.
+ * This switches endpoint events to correct sub function.
  *
- * \return \c 1 if an event about bulk/interrupt/isochronous endpoints has occured, otherwise \c 0.
+ * \return \c 1 if an event about bulk/interrupt/isochronous endpoints has occurred, otherwise \c 0.
  */
 static bool udd_ep_interrupt(void);
 
  *
  * Note:
  * Here, the global interrupt mask is not clear when an USB interrupt is enabled
- * because this one can not be occured during the USB ISR (=during INTX is masked).
+ * because this one can not be occurred during the USB ISR (=during INTX is masked).
  * See Technical reference $3.8.3 Masking interrupt requests in peripheral modules.
  */
 #ifdef UHD_ENABLE
 	udd_sleep_mode(true);
 	otg_unfreeze_clock();
 
-	// This section of clock check can be improved with a chek of
+	// This section of clock check can be improved with a check of
 	// USB clock source via sysclk()
 	// Check USB clock because the source can be a PLL
 	while (!Is_otg_clock_usable());
 #ifdef USB_DEVICE_HS_SUPPORT
 	udd_enable_msof_interrupt();
 #endif
-	// Reset following interupts flag
+	// Reset following interrupts flag
 	udd_ack_reset();
 	udd_ack_sof();
 	udd_ack_msof();
 	}
 	dbg_print("alloc(%x, %d) ", ep, MaxEndpointSize);
 
-	// Bank choise
+	// Bank choice
 	switch (bmAttributes & USB_EP_TYPE_MASK) {
 	case USB_EP_TYPE_ISOCHRONOUS:
 		nb_bank = UDD_ISOCHRONOUS_NB_BANK(ep);
 
 	if (Is_udd_endpoint_stall_requested(ep)
 			|| ptr_job->stall_requested) {
-		// Endpoint halted then registes the callback
+		// Endpoint halted then registers the callback
 		ptr_job->busy = true;
 		ptr_job->call_nohalt = callback;
 	} else {
 
 	// Decode setup request
 	if (udc_process_setup() == false) {
-		// Setup request unknow then stall it
+		// Setup request unknown then stall it
 		udd_ctrl_stall_data();
 		udd_ack_setup_received(0);
 		return;
 		udd_ctrl_prev_payload_buf_cnt += udd_ctrl_payload_buf_cnt;
 		if ((udd_g_ctrlreq.req.wLength == udd_ctrl_prev_payload_buf_cnt)
 					|| b_shortpacket) {
-			// All data requested are transfered or a short packet has been sent
+			// All data requested are transferred or a short packet has been sent
 			// then it is the end of data phase.
 			// Generate an OUT ZLP for handshake phase.
 			udd_ctrl_send_zlp_out();
 			// End of SETUP request:
 			// - Data IN Phase aborted,
 			// - or last Data IN Phase hidden by ZLP OUT sending quiclky,
-			// - or ZLP OUT received normaly.
+			// - or ZLP OUT received normally.
 			udd_ctrl_endofrequest();
 		} else {
 			// Protocol error during SETUP request
 					(udd_ctrl_prev_payload_buf_cnt +
 							udd_ctrl_payload_buf_cnt))) {
 		// End of reception because it is a short packet
-		// Before send ZLP, call intermediat calback
+		// Before send ZLP, call intermediate callback
 		// in case of data receiv generate a stall
 		udd_g_ctrlreq.payload_size = udd_ctrl_payload_buf_cnt;
 		if (NULL != udd_g_ctrlreq.over_under_run) {
 	if (udd_g_ctrlreq.payload_size == udd_ctrl_payload_buf_cnt) {
 		// Overrun then request a new payload buffer
 		if (!udd_g_ctrlreq.over_under_run) {
-			// No callback availabled to request a new payload buffer
+			// No callback available to request a new payload buffer
 			udd_ctrl_stall_data();
 			// Ack reception of OUT to replace NAK by a STALL
 			udd_ack_out_received(0);
 			// transfer size of UDD_ENDPOINT_MAX_TRANS Bytes
 			next_trans = UDD_ENDPOINT_MAX_TRANS;
 
-			// Set 0 to tranfer the maximum
+			// Set 0 to transfer the maximum
 			udd_dma_ctrl = UOTGHS_DEVDMACONTROL_BUFF_LENGTH(0);
 		} else {
 			udd_dma_ctrl = UOTGHS_DEVDMACONTROL_BUFF_LENGTH(next_trans);
 		}
 		cpu_irq_restore(flags);
 
-		// Here a ZLP has been recieved
+		// Here a ZLP has been received
 		// and the DMA transfer must be not started.
 		// It is the end of transfer
 		ptr_job->buf_size = ptr_job->buf_cnt;
 			}
 			dbg_print("dma%x: ", ep);
 			udd_disable_endpoint_dma_interrupt(ep);
-			// Save number of data no transfered
+			// Save number of data no transferred
 			nb_remaining = (udd_endpoint_dma_get_status(ep) &
 					UOTGHS_DEVDMASTATUS_BUFF_COUNT_Msk)
 					>> UOTGHS_DEVDMASTATUS_BUFF_COUNT_Pos;
 			if (nb_remaining) {
 				// Transfer no complete (short packet or ZLP) then:
-				// Update number of data transfered
+				// Update number of data transferred
 				ptr_job->buf_cnt -= nb_remaining;
 				// Set transfer complete to stop the transfer
 				ptr_job->buf_size = ptr_job->buf_cnt;
 				udd_disable_endpoint_interrupt(ep);
 
 				Assert(ptr_job->stall_requested);
-				// A stall has been requested during backgound transfer
+				// A stall has been requested during background transfer
 				ptr_job->stall_requested = false;
 				udd_disable_endpoint_bank_autoswitch(ep);
 				udd_enable_stall_handshake(ep);

Marlin/src/HAL/DUE/usb/usb_protocol_msc.h

 struct usb_msc_csw {
 	le32_t dCSWSignature;	//!< Must contain 'USBS'
 	le32_t dCSWTag;	//!< Same as dCBWTag
-	le32_t dCSWDataResidue;	//!< Number of bytes not transfered
+	le32_t dCSWDataResidue;	//!< Number of bytes not transferred
 	uint8_t bCSWStatus;	//!< Status code
 };
 

Marlin/src/HAL/LINUX/hardware/Heater.cpp

 }
 
 void Heater::interrupt(GpioEvent ev) {
-  // ununsed
+  // unused
 }
 
 #endif // __PLAT_LINUX__

Marlin/src/HAL/LINUX/include/pinmapping.h

 // Test whether the pin is PWM
 constexpr bool PWM_PIN(const pin_t p) { return false; }
 
-// Test whether the pin is interruptable
+// Test whether the pin is interruptible
 constexpr bool INTERRUPT_PIN(const pin_t p) { return false; }
 
 // Get the pin number at the given index

Marlin/src/HAL/SAMD51/HAL.cpp

   // Struct must be 32 bits aligned because of DMA accesses but fields needs to be 8 bits packed
   typedef struct  __attribute__((aligned(4), packed)) {
     ADC_INPUTCTRL_Type INPUTCTRL;
-  } HAL_DMA_DAC_Registers;    // DMA transfered registers
+  } HAL_DMA_DAC_Registers;    // DMA transferred registers
 
 #endif
 

Marlin/src/HAL/SAMD51/fastio.h

    */
   #define PWM_PIN(P)        (WITHIN(P, 2, 13) || WITHIN(P, 22, 23) || WITHIN(P, 44, 45) || P == 48)
 
-  // Return fullfilled ADCx->INPUTCTRL.reg
+  // Return fulfilled ADCx->INPUTCTRL.reg
   #define PIN_TO_INPUTCTRL(P)     (  (PIN_TO_AIN(P) == 0) ? ADC_INPUTCTRL_MUXPOS_AIN0   \
                                    : (PIN_TO_AIN(P) == 1) ? ADC_INPUTCTRL_MUXPOS_AIN1   \
                                    : (PIN_TO_AIN(P) == 2) ? ADC_INPUTCTRL_MUXPOS_AIN2   \

Marlin/src/HAL/SAMD51/timers.cpp

     tc->COUNT32.INTENCLR.reg = TC_INTENCLR_OVF; // disable overflow interrupt
 
     // TCn clock setup
-    const uint8_t clockID = GCLK_CLKCTRL_IDs[TCC_INST_NUM + timer_num];   // TC clock are preceeded by TCC ones
+    const uint8_t clockID = GCLK_CLKCTRL_IDs[TCC_INST_NUM + timer_num];   // TC clock are preceded by TCC ones
     GCLK->PCHCTRL[clockID].bit.CHEN = false;
     SYNC(GCLK->PCHCTRL[clockID].bit.CHEN);
     GCLK->PCHCTRL[clockID].reg = GCLK_PCHCTRL_GEN_GCLK0 | GCLK_PCHCTRL_CHEN;   // 120MHz startup code programmed

Marlin/src/HAL/STM32/HAL_MinSerial.cpp

     }
     regs->DR = c;
   #else
-    // Let's hope a mystical guru will fix this, one day by writting interrupt-free USB CDC ACM code (or, at least, by polling the registers since interrupt will be queued but will never trigger)
+    // Let's hope a mystical guru will fix this, one day by writing interrupt-free USB CDC ACM code (or, at least, by polling the registers since interrupt will be queued but will never trigger)
     // For now, it's completely lost to oblivion.
   #endif
 }

Marlin/src/HAL/STM32/Servo.cpp

 // This allows all timer interrupt priorities to be managed from a single location in the HAL.
 static uint32_t servo_interrupt_priority = NVIC_EncodePriority(NVIC_GetPriorityGrouping(), TIM_IRQ_PRIO, TIM_IRQ_SUBPRIO);
 
-// This must be called after the STM32 Servo class has intialized the timer.
+// This must be called after the STM32 Servo class has initialized the timer.
 // It may only be needed after the first call to attach(), but it is possible
 // that is is necessary after every detach() call. To be safe this is currently
 // called after every call to attach().

Marlin/src/HAL/STM32/eeprom_flash.cpp

         address += sizeof(uint32_t);
       }
       if (current_slot == -1) {
-        // We didn't find anything, so we'll just intialize to empty
+        // We didn't find anything, so we'll just initialize to empty
         for (int i = 0; i < MARLIN_EEPROM_SIZE; i++) ram_eeprom[i] = EMPTY_UINT8;
         current_slot = EEPROM_SLOTS;
       }

Marlin/src/HAL/STM32/msc_sd.cpp

       return true;
     }
 
-    // multi block optmization
+    // multi block optimization
     sd2card->writeStart(blkAddr, blkLen);
     while (blkLen--) {
       watchdog_refresh();
       return true;
     }
 
-    // multi block optmization
+    // multi block optimization
     sd2card->readStart(blkAddr);
     while (blkLen--) {
       watchdog_refresh();

Marlin/src/HAL/STM32F1/HAL.cpp

   reg_value &= ~(SCB_AIRCR_VECTKEY_Msk | SCB_AIRCR_PRIGROUP_Msk);             /* clear bits to change               */
   reg_value  =  (reg_value                                 |
                 ((uint32_t)0x5FA << SCB_AIRCR_VECTKEY_Pos) |
-                (PriorityGroupTmp << 8));                                     /* Insert write key and priorty group */
+                (PriorityGroupTmp << 8));                                     /* Insert write key & priority group  */
   SCB->AIRCR =  reg_value;
 }
 

Marlin/src/HAL/STM32F1/SPI.cpp

 /**
  * Roger Clark and Victor Perez, 2015
  * Performs a DMA SPI transfer with at least a receive buffer.
- * If a TX buffer is not provided, FF is sent over and over for the lenght of the transfer.
- * On exit TX buffer is not modified, and RX buffer cotains the received data.
+ * If a TX buffer is not provided, FF is sent over and over for the length of the transfer.
+ * On exit TX buffer is not modified, and RX buffer contains the received data.
  * Still in progress.
  */
 void SPIClass::dmaTransferSet(const void *transmitBuf, void *receiveBuf) {

Marlin/src/HAL/STM32F1/onboard_sd.h

 #pragma once
 
 #define _DISKIO_WRITE   1   /* 1: Enable disk_write function */
-#define _DISKIO_IOCTL   1   /* 1: Enable disk_ioctl fucntion */
-#define _DISKIO_ISDIO   0   /* 1: Enable iSDIO control fucntion */
+#define _DISKIO_IOCTL   1   /* 1: Enable disk_ioctl function */
+#define _DISKIO_ISDIO   0   /* 1: Enable iSDIO control function */
 
 typedef unsigned char BYTE;
 typedef unsigned short WORD;
 #define STA_NODISK      0x02    /* No medium in the drive */
 #define STA_PROTECT     0x04    /* Write protected */
 
-/* Command code for disk_ioctrl fucntion */
+/* Command code for disk_ioctrl function */
 
 /* Generic command (Used by FatFs) */
 #define CTRL_SYNC        0  /* Complete pending write process (needed at _FS_READONLY == 0) */

Marlin/src/HAL/STM32F1/timers.h

   case STEP_TIMER_NUM:
     // NOTE: WE have set ARPE = 0, which means the Auto reload register is not preloaded
     // and there is no need to use any compare, as in the timer mode used, setting ARR to the compare value
-    // will result in exactly the same effect, ie trigerring an interrupt, and on top, set counter to 0
+    // will result in exactly the same effect, ie triggering an interrupt, and on top, set counter to 0
     timer_set_reload(STEP_TIMER_DEV, compare); // We reload direct ARR as needed during counting up
     break;
   case TEMP_TIMER_NUM:

Marlin/src/HAL/TEENSY31_32/HAL_SPI.cpp

     case SPI_EIGHTH_SPEED:  clock =  1250000; break;
     case SPI_SPEED_5:       clock =   625000; break;
     case SPI_SPEED_6:       clock =   312500; break;
-    default:                clock = 4000000; // Default from the SPI libarary
+    default:                clock = 4000000; // Default from the SPI library
   }
   spiConfig = SPISettings(clock, MSBFIRST, SPI_MODE0);
   SPI.begin();

Marlin/src/HAL/TEENSY35_36/HAL_SPI.cpp

   case SPI_SPEED_5:       clock =   625000; break;
   case SPI_SPEED_6:       clock =   312500; break;
   default:
-    clock = 4000000; // Default from the SPI libarary
+    clock = 4000000; // Default from the SPI library
   }
   spiConfig = SPISettings(clock, MSBFIRST, SPI_MODE0);
   SPI.begin();

Marlin/src/HAL/TEENSY40_41/HAL_SPI.cpp

   case SPI_SPEED_5:       clock =   625000; break;
   case SPI_SPEED_6:       clock =   312500; break;
   default:
-    clock = 4000000; // Default from the SPI libarary
+    clock = 4000000; // Default from the SPI library
   }
   spiConfig = SPISettings(clock, MSBFIRST, SPI_MODE0);
   SPI.begin();

Marlin/src/HAL/shared/backtrace/unwarm.h

  * This program is PUBLIC DOMAIN.
  * This means that there is no copyright and anyone is able to take a copy
  * for free and use it as they wish, with or without modifications, and in
- * any context, commerically or otherwise. The only limitation is that I
+ * any context, commercially or otherwise. The only limitation is that I
  * don't guarantee that the software is fit for any purpose or accept any
  * liability for its use or misuse - this software is without warranty.
  ***************************************************************************

Marlin/src/HAL/shared/backtrace/unwarmbytab.h

  * This program is PUBLIC DOMAIN.
  * This means that there is no copyright and anyone is able to take a copy
  * for free and use it as they wish, with or without modifications, and in
- * any context, commerically or otherwise. The only limitation is that I
+ * any context, commercially or otherwise. The only limitation is that I
  * don't guarantee that the software is fit for any purpose or accept any
  * liability for its use or misuse - this software is without warranty.
  ***************************************************************************

Marlin/src/HAL/shared/backtrace/unwarmmem.cpp

  * This program is PUBLIC DOMAIN.
  * This means that there is no copyright and anyone is able to take a copy
  * for free and use it as they wish, with or without modifications, and in
- * any context, commerically or otherwise. The only limitation is that I
+ * any context, commercially or otherwise. The only limitation is that I
  * don't guarantee that the software is fit for any purpose or accept any
  * liability for its use or misuse - this software is without warranty.
  ***************************************************************************

Marlin/src/HAL/shared/backtrace/unwarmmem.h

  * This program is PUBLIC DOMAIN.
  * This means that there is no copyright and anyone is able to take a copy
  * for free and use it as they wish, with or without modifications, and in
- * any context, commerically or otherwise. The only limitation is that I
+ * any context, commercially or otherwise. The only limitation is that I
  * don't guarantee that the software is fit for any purpose or accept any
  * liability for its use or misuse - this software is without warranty.
  ***************************************************************************

Marlin/src/HAL/shared/backtrace/unwinder.cpp

 
 // Detect if unwind information is present or not
 static int HasUnwindTableInfo() {
-  // > 16 because there are default entries we can't supress
+  // > 16 because there are default entries we can't suppress
   return ((char*)(&__exidx_end) - (char*)(&__exidx_start)) > 16 ? 1 : 0;
 }
 

Marlin/src/HAL/shared/backtrace/unwinder.h

  * This program is PUBLIC DOMAIN.
  * This means that there is no copyright and anyone is able to take a copy
  * for free and use it as they wish, with or without modifications, and in
- * any context, commerically or otherwise. The only limitation is that I
+ * any context, commercially or otherwise. The only limitation is that I
  * don't guarantee that the software is fit for any purpose or accept any
  * liability for its use or misuse - this software is without warranty.
  **************************************************************************/

Marlin/src/HAL/shared/backtrace/unwmemaccess.h

  * This program is PUBLIC DOMAIN.
  * This means that there is no copyright and anyone is able to take a copy
  * for free and use it as they wish, with or without modifications, and in
- * any context, commerically or otherwise. The only limitation is that I
+ * any context, commercially or otherwise. The only limitation is that I
  * don't guarantee that the software is fit for any purpose or accept any
  * liability for its use or misuse - this software is without warranty.
  ***************************************************************************

Marlin/src/HAL/shared/cpu_exception/exception_arm.cpp

       // We failed to find a valid vector table size, let's abort hooking up
       if (vec_size == VECTOR_TABLE_SENTINEL) return;
       // Poor method that's wasting RAM here, but allocating with malloc and alignment would be worst
-      // 128 bytes alignement is required for writing the VTOR register
+      // 128 bytes alignment is required for writing the VTOR register
       alignas(128) static unsigned long vectable[VECTOR_TABLE_SENTINEL];
 
       SERIAL_ECHOPGM("Detected vector table size: ");

Marlin/src/core/macros.h

     template <typename T, typename ... Args> struct first_type_of { typedef T type; };
     template <typename T> struct first_type_of<T> { typedef T type; };
   }
-  // C++11 solution using SFINAE to detect the existance of a member in a class at compile time.
+  // C++11 solution using SFINAE to detect the existence of a member in a class at compile time.
   // It creates a HasMember<Type> structure containing 'value' set to true if the member exists
   #define HAS_MEMBER_IMPL(Member) \
     namespace Private { \

Marlin/src/core/serial_hook.h

   ConditionalSerial(bool & conditionVariable, SerialT & out, const bool e) : BaseClassT(e), condition(conditionVariable), out(out) {}
 };
 
-// A simple foward class that taking a reference to an existing serial instance (likely created in their respective framework)
+// A simple forward class that taking a reference to an existing serial instance (likely created in their respective framework)
 template <class SerialT>
 struct ForwardSerial : public SerialBase< ForwardSerial<SerialT> > {
   typedef SerialBase< ForwardSerial<SerialT> > BaseClassT;

Marlin/src/feature/bedlevel/hilbert_curve.cpp

 
 static inline bool eval_candidate(int8_t x, int8_t y, hilbert_curve::callback_ptr func, void *data) {
   // The print bed likely has fewer points than the full Hilbert
-  // curve, so cull unecessary points
+  // curve, so cull unnecessary points
   return x < (GRID_MAX_POINTS_X) && y < (GRID_MAX_POINTS_Y) ? func(x, y, data) : false;
 }
 

Marlin/src/feature/dac/dac_mcp4728.cpp

 }
 
 /**
- * Write Voltage reference setting to all input regiters
+ * Write Voltage reference setting to all input registers
  */
 uint8_t MCP4728::setVref_all(const uint8_t value) {
   Wire.beginTransmission(I2C_ADDRESS(DAC_DEV_ADDRESS));
   return Wire.endTransmission();
 }
 /**
- * Write Gain setting to all input regiters
+ * Write Gain setting to all input registers
  */
 uint8_t MCP4728::setGain_all(const uint8_t value) {
   Wire.beginTransmission(I2C_ADDRESS(DAC_DEV_ADDRESS));
 }
 
 /**
- * FastWrite input register values - All DAC ouput update. refer to DATASHEET 5.6.1
+ * FastWrite input register values - All DAC output update. refer to DATASHEET 5.6.1
  * DAC Input and PowerDown bits update.
  * No EEPROM update
  */

Marlin/src/feature/encoder_i2c.cpp

 
         SERIAL_ECHOLNPAIR("Untrusted encoder module on ", AS_CHAR(axis_codes[encoderAxis]), " axis has been fault-free for set duration, reinstating error correction.");
 
-        //the encoder likely lost its place when the error occured, so we'll reset and use the printer's
+        //the encoder likely lost its place when the error occurred, so we'll reset and use the printer's
         //idea of where it the axis is to re-initialize
         const float pos = planner.get_axis_position_mm(encoderAxis);
         int32_t positionInTicks = pos * get_ticks_unit();

Marlin/src/gcode/calibrate/G76_M192_M871.cpp

  *    Compensation values are deltas to first probe measurement at bed temp. = 60°C.
  *  - The hotend will not be heated at any time.
  *  - On my Průša MK3S clone I put a piece of paper between the probe and the hotend
- *    so the hotend fan would not cool my probe constantly. Alternativly you could just
+ *    so the hotend fan would not cool my probe constantly. Alternatively you could just
  *    make sure the fan is not running while running the calibration process.
  *
  *  Probe calibration:

Marlin/src/gcode/config/M43.cpp

  *                  S<pin>  - Start Pin number.   If not given, will default to 0
  *                  L<pin>  - End Pin number.   If not given, will default to last pin defined for this board
  *                  I<bool> - Flag to ignore Marlin's pin protection.   Use with caution!!!!
- *                  R       - Repeat pulses on each pin this number of times before continueing to next pin
- *                  W       - Wait time (in miliseconds) between pulses.  If not given will default to 500
+ *                  R       - Repeat pulses on each pin this number of times before continuing to next pin
+ *                  W       - Wait time (in milliseconds) between pulses.  If not given will default to 500
  *
  *  M43 S       - Servo probe test
  *                  P<index> - Probe index (optional - defaults to 0

Marlin/src/gcode/feature/L6470/M906.cpp

  *     L6474 - current in mA (4A max)
  *     All others - 0-255
  *
- * Sets KVAL_HOLD wich affects the current being driven through the stepper.
+ * Sets KVAL_HOLD which affects the current being driven through the stepper.
  *
  * L6470 is used in the STEP-CLOCK mode.  KVAL_HOLD is the only KVAL_xxx
  * that affects the effective voltage seen by the stepper.

Marlin/src/gcode/feature/L6470/M916-918.cpp

   if ((status_composite & (sh.STATUS_AXIS_TH_WRN | sh.STATUS_AXIS_TH_SD)))
     DEBUG_ECHOLNPGM(".\n.\nTest completed normally - Thermal warning/shutdown has occurred");
   else if (status_composite)
-    DEBUG_ECHOLNPGM(".\n.\nTest completed abnormally - non-thermal error has occured");
+    DEBUG_ECHOLNPGM(".\n.\nTest completed abnormally - non-thermal error has occurred");
   else
     DEBUG_ECHOLNPGM(".\n.\nTest completed normally - Unable to get to thermal warning/shutdown");
 

Marlin/src/inc/Conditionals_LCD.h

     #define LCD_PROGRESS_BAR
   #endif
   #if ENABLED(TFTGLCD_PANEL_I2C)
-    #define LCD_I2C_ADDRESS           0x33  // Must be 0x33 for STM32 main boards and equal to panel's I2C slave addres
+    #define LCD_I2C_ADDRESS           0x33  // Must be 0x33 for STM32 main boards and equal to panel's I2C slave address
   #endif
   #define LCD_USE_I2C_BUZZER                // Enable buzzer on LCD, used for both I2C and SPI buses (LiquidTWI2 not required)
   #define STD_ENCODER_PULSES_PER_STEP 2

Marlin/src/lcd/HD44780/marlinui_HD44780.cpp

         y_map_pixels = pixels_per_y_mesh_pnt * (GRID_MAX_POINTS_Y);         // Directions fit nicely
 
         right_edge   = pixels_per_x_mesh_pnt * (GRID_MAX_POINTS_X) + 1;     // Find location of right edge within the character cell
-        bottom_line  = pixels_per_y_mesh_pnt * (GRID_MAX_POINTS_Y) + 1;     // Find location of bottome line within the character cell
+        bottom_line  = pixels_per_y_mesh_pnt * (GRID_MAX_POINTS_Y) + 1;     // Find location of bottom line within the character cell
 
         n_rows = bottom_line / (HD44780_CHAR_HEIGHT) + 1;
         n_cols = right_edge / (HD44780_CHAR_WIDTH) + 1;

Marlin/src/lcd/TFTGLCD/marlinui_TFTGLCD.cpp

 #define COLOR_EDIT      '#'
 #define COLOR_ERROR     '!'
 
-#ifdef CONVERT_TO_EXT_ASCII   //use standart pseudographic symbols in ASCII table
+#ifdef CONVERT_TO_EXT_ASCII   //use standard pseudographic symbols in ASCII table
   #define LR            179   //vertical line
   #define TRC           191   //top right corner
   #define BLC           192   //bottom left corner
     //
     uint8_t indent = (LCD_WIDTH - 8) / 2;
     // symbols 217 (bottom right corner) and 218 (top left corner) are using for letters in some languages
-    // and they should be moved to begining ASCII table as spetial symbols
+    // and they should be moved to beginning ASCII table as special symbols
     lcd.setCursor(indent, 0); lcd.write(TLC); lcd_put_u8str_P(PSTR("------"));  lcd.write(TRC);
     lcd.setCursor(indent, 1); lcd.write(LR);  lcd_put_u8str_P(PSTR("Marlin"));  lcd.write(LR);
     lcd.setCursor(indent, 2); lcd.write(BLC); lcd_put_u8str_P(PSTR("------"));  lcd.write(BRC);
 |                    |
 |  HE  BED  FAN      |
 | ttc  ttc   %       | ttc - current temperature
-| tts  tts  %%%      | tts - setted temperature, %%% - percent for FAN
+| tts  tts  %%%      | tts - set temperature, %%% - percent for FAN
 | ICO  ICO  ICO  ICO | ICO - icon 48x48, placed in 2 text lines
 | ICO  ICO  ICO  ICO | ICO
 

Marlin/src/lcd/dogm/status_screen_lite_ST7920.cpp

  * data buffer (DDRAM) to be used in conjunction with the graphics
  * bitmap buffer (CGRAM). The contents of the graphics buffer is
  * XORed with the data from the character generator. This allows
- * us to make the progess bar out of graphical data (the bar) and
+ * us to make the progress bar out of graphical data (the bar) and
  * text data (the percentage).
  */
 void ST7920_Lite_Status_Screen::draw_progress_bar(const uint8_t value) {

Marlin/src/lcd/dogm/u8g_dev_st7920_128x64_HAL.cpp

   0x038,              // 8 Bit interface (DL=1), basic instruction set (RE=0)
   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
+  0x002,              // disable scroll, enable CGRAM address
   0x001,              // clear RAM, needs 1.6 ms
   U8G_ESC_DLY(100),   // delay 100 ms
 

Marlin/src/lcd/extui/anycubic_chiron/chiron_tft.cpp

     case AC_printer_resuming_from_power_outage:
     case AC_printer_printing:
     case AC_printer_paused: {
-      // Heater timout, send acknowledgement
+      // Heater timeout, send acknowledgement
       if (strcmp_P(msg, MARLIN_msg_heater_timeout) == 0) {
         pause_state = AC_paused_heater_timed_out;
         SendtoTFTLN(AC_msg_paused); // enable continue button
         printer_state = AC_printer_idle;
         msg_matched = true;
       }
-      // If probing fails dont save the mesh raise the probe above the bad point
+      // If probing fails don't save the mesh raise the probe above the bad point
       if (strcmp_P(msg, MARLIN_msg_probing_failed) == 0) {
         PlayTune(BEEPER_PIN, BeepBeepBeeep, 1);
         injectCommands_P(PSTR("G1 Z50 F500"));
       break;
 
     case 14: { // A14 Start Printing
-      // Allows printer to restart the job if we dont want to recover
+      // Allows printer to restart the job if we don't want to recover
       if (printer_state == AC_printer_resuming_from_power_outage) {
         injectCommands_P(PSTR("M1000 C")); // Cancel recovery
         printer_state = AC_printer_idle;

Marlin/src/lcd/extui/dgus/DGUSDisplay.h

   // Helper for users of this class to estimate if an interaction would be blocking.
   static size_t GetFreeTxBuffer();
 
-  // Checks two things: Can we confirm the presence of the display and has we initiliazed it.
+  // Checks two things: Can we confirm the presence of the display and has we initialized it.
   // (both boils down that the display answered to our chatting)
   static inline bool isInitialized() { return Initialized; }
 

Marlin/src/lcd/extui/dgus/fysetc/DGUSDisplayDef.cpp

     VPHELPER(VP_WAITING_STATUS, nullptr, nullptr, ScreenHandler.DGUSLCD_SendWaitingStatusToDisplay),
   #endif
 
-  // Messages for the User, shared by the popup and the kill screen. They cant be autouploaded as we do not buffer content.
+  // Messages for the User, shared by the popup and the kill screen. They can't be autouploaded as we do not buffer content.
   { .VP = VP_MSGSTR1, .memadr = nullptr, .size = VP_MSGSTR1_LEN, .set_by_display_handler = nullptr, .send_to_display_handler = ScreenHandler.DGUSLCD_SendStringToDisplayPGM },
   { .VP = VP_MSGSTR2, .memadr = nullptr, .size = VP_MSGSTR2_LEN, .set_by_display_handler = nullptr, .send_to_display_handler = ScreenHandler.DGUSLCD_SendStringToDisplayPGM },
   { .VP = VP_MSGSTR3, .memadr = nullptr, .size = VP_MSGSTR3_LEN, .set_by_display_handler = nullptr, .send_to_display_handler = ScreenHandler.DGUSLCD_SendStringToDisplayPGM },

Marlin/src/lcd/extui/dgus/fysetc/DGUSDisplayDef.h

 constexpr uint16_t VP_BED_PID_I = 0x3712;
 constexpr uint16_t VP_BED_PID_D = 0x3714;
 
-// Wating screen status
+// Waiting screen status
 constexpr uint16_t VP_WAITING_STATUS = 0x3800;
 
 // SPs for certain variables...

Marlin/src/lcd/extui/dgus/fysetc/DGUSScreenHandler.cpp

     }
   #endif
   char axiscode;
-  unsigned int speed = 1500; // FIXME: get default feedrate for manual moves, dont hardcode.
+  unsigned int speed = 1500; // FIXME: get default feedrate for manual moves, don't hardcode.
 
   switch (var.VP) {
     default: return;

Marlin/src/lcd/extui/dgus/fysetc/DGUSScreenHandler.h

   static bool loop();
 
   // Send all 4 strings that are displayed on the infoscreen, confirmation screen and kill screen
-  // The bools specifing whether the strings are in RAM or FLASH.
+  // The bools specifying whether the strings are in RAM or FLASH.
   static void sendinfoscreen(const char *line1, const char *line2, const char *line3, const char *line4, bool l1inflash, bool l2inflash, bool l3inflash, bool liinflash);
 
   static void HandleUserConfirmationPopUp(uint16_t ConfirmVP, const char *line1, const char *line2, const char *line3, const char *line4, bool l1inflash, bool l2inflash, bool l3inflash, bool liinflash);

Marlin/src/lcd/extui/dgus/hiprecy/DGUSDisplayDef.cpp

     VPHELPER(VP_WAITING_STATUS, nullptr, nullptr, ScreenHandler.DGUSLCD_SendWaitingStatusToDisplay),
   #endif
 
-  // Messages for the User, shared by the popup and the kill screen. They cant be autouploaded as we do not buffer content.
+  // Messages for the User, shared by the popup and the kill screen. They can't be autouploaded as we do not buffer content.
   { .VP = VP_MSGSTR1, .memadr = nullptr, .size = VP_MSGSTR1_LEN, .set_by_display_handler = nullptr, .send_to_display_handler = ScreenHandler.DGUSLCD_SendStringToDisplayPGM },
   { .VP = VP_MSGSTR2, .memadr = nullptr, .size = VP_MSGSTR2_LEN, .set_by_display_handler = nullptr, .send_to_display_handler = ScreenHandler.DGUSLCD_SendStringToDisplayPGM },
   { .VP = VP_MSGSTR3, .memadr = nullptr, .size = VP_MSGSTR3_LEN, .set_by_display_handler = nullptr, .send_to_display_handler = ScreenHandler.DGUSLCD_SendStringToDisplayPGM },

Marlin/src/lcd/extui/dgus/hiprecy/DGUSDisplayDef.h

 constexpr uint16_t VP_BED_PID_I = 0x3712;
 constexpr uint16_t VP_BED_PID_D = 0x3714;
 
-// Wating screen status
+// Waiting screen status
 constexpr uint16_t VP_WAITING_STATUS = 0x3800;
 
 // SPs for certain variables...

Marlin/src/lcd/extui/dgus/hiprecy/DGUSScreenHandler.cpp

     }
   #endif
   char axiscode;
-  unsigned int speed = 1500; // FIXME: get default feedrate for manual moves, dont hardcode.
+  unsigned int speed = 1500; // FIXME: get default feedrate for manual moves, don't hardcode.
 
   switch (var.VP) {
     default: return;

Marlin/src/lcd/extui/dgus/hiprecy/DGUSScreenHandler.h

   static bool loop();
 
   // Send all 4 strings that are displayed on the infoscreen, confirmation screen and kill screen
-  // The bools specifing whether the strings are in RAM or FLASH.
+  // The bools specifying whether the strings are in RAM or FLASH.
   static void sendinfoscreen(const char *line1, const char *line2, const char *line3, const char *line4, bool l1inflash, bool l2inflash, bool l3inflash, bool liinflash);
 
   static void HandleUserConfirmationPopUp(uint16_t ConfirmVP, const char *line1, const char *line2, const char *line3, const char *line4, bool l1inflash, bool l2inflash, bool l3inflash, bool liinflash);

Marlin/src/lcd/extui/dgus/mks/DGUSDisplayDef.cpp

     VPHELPER(VP_WAITING_STATUS, nullptr, nullptr, ScreenHandler.DGUSLCD_SendWaitingStatusToDisplay),
   #endif
 
-  // Messages for the User, shared by the popup and the kill screen. They cant be autouploaded as we do not buffer content.
+  // Messages for the User, shared by the popup and the kill screen. They can't be autouploaded as we do not buffer content.
   //{.VP = VP_MSGSTR1, .memadr = nullptr, .size = VP_MSGSTR1_LEN, .set_by_display_handler = nullptr, .send_to_display_handler = ScreenHandler.DGUSLCD_SendStringToDisplayPGM},
   //{.VP = VP_MSGSTR2, .memadr = nullptr, .size = VP_MSGSTR2_LEN, .set_by_display_handler = nullptr, .send_to_display_handler = ScreenHandler.DGUSLCD_SendStringToDisplayPGM},
   //{.VP = VP_MSGSTR3, .memadr = nullptr, .size = VP_MSGSTR3_LEN, .set_by_display_handler = nullptr, .send_to_display_handler = ScreenHandler.DGUSLCD_SendStringToDisplayPGM},

Marlin/src/lcd/extui/dgus/mks/DGUSDisplayDef.h

 // constexpr uint16_t VP_BED_PID_I = 0x3712;
 // constexpr uint16_t VP_BED_PID_D = 0x3714;
 
-// Wating screen status
+// Waiting screen status
 constexpr uint16_t VP_WAITING_STATUS = 0x3800;
 
 // SPs for certain variables...

Marlin/src/lcd/extui/dgus/mks/DGUSScreenHandler.cpp

     return;
 
   char axiscode;
-  unsigned int speed = 1500; // FIXME: get default feedrate for manual moves, dont hardcode.
+  unsigned int speed = 1500; // FIXME: get default feedrate for manual moves, don't hardcode.
 
   switch (var.VP) { // switch X Y Z or Home
     default: return;

Marlin/src/lcd/extui/dgus/mks/DGUSScreenHandler.h

   static bool loop();
 
   // Send all 4 strings that are displayed on the infoscreen, confirmation screen and kill screen
-  // The bools specifing whether the strings are in RAM or FLASH.
+  // The bools specifying whether the strings are in RAM or FLASH.
   static void sendinfoscreen(const char *line1, const char *line2, const char *line3, const char *line4, bool l1inflash, bool l2inflash, bool l3inflash, bool liinflash);
 
   static void HandleUserConfirmationPopUp(uint16_t ConfirmVP, const char *line1, const char *line2, const char *line3, const char *line4, bool l1inflash, bool l2inflash, bool l3inflash, bool liinflash);

Marlin/src/lcd/extui/dgus/origin/DGUSDisplayDef.cpp

     VPHELPER(VP_WAITING_STATUS, nullptr, nullptr, ScreenHandler.DGUSLCD_SendWaitingStatusToDisplay),
   #endif
 
-  // Messages for the User, shared by the popup and the kill screen. They cant be autouploaded as we do not buffer content.
+  // Messages for the User, shared by the popup and the kill screen. They can't be autouploaded as we do not buffer content.
   { .VP = VP_MSGSTR1, .memadr = nullptr, .size = VP_MSGSTR1_LEN, .set_by_display_handler = nullptr, .send_to_display_handler = ScreenHandler.DGUSLCD_SendStringToDisplayPGM },
   { .VP = VP_MSGSTR2, .memadr = nullptr, .size = VP_MSGSTR2_LEN, .set_by_display_handler = nullptr, .send_to_display_handler = ScreenHandler.DGUSLCD_SendStringToDisplayPGM },
   { .VP = VP_MSGSTR3, .memadr = nullptr, .size = VP_MSGSTR3_LEN, .set_by_display_handler = nullptr, .send_to_display_handler = ScreenHandler.DGUSLCD_SendStringToDisplayPGM },

Marlin/src/lcd/extui/dgus/origin/DGUSDisplayDef.h

 constexpr uint16_t VP_BED_PID_I = 0x3712;
 constexpr uint16_t VP_BED_PID_D = 0x3714;
 
-// Wating screen status
+// Waiting screen status
 constexpr uint16_t VP_WAITING_STATUS = 0x3800;
 
 // SPs for certain variables...

Marlin/src/lcd/extui/dgus/origin/DGUSScreenHandler.cpp

     }
   #endif
   char axiscode;
-  unsigned int speed = 1500; // FIXME: get default feedrate for manual moves, dont hardcode.
+  unsigned int speed = 1500; // FIXME: get default feedrate for manual moves, don't hardcode.
 
   switch (var.VP) {
     default: return;

Marlin/src/lcd/extui/dgus/origin/DGUSScreenHandler.h

   static bool loop();
 
   // Send all 4 strings that are displayed on the infoscreen, confirmation screen and kill screen
-  // The bools specifing whether the strings are in RAM or FLASH.
+  // The bools specifying whether the strings are in RAM or FLASH.
   static void sendinfoscreen(const char *line1, const char *line2, const char *line3, const char *line4, bool l1inflash, bool l2inflash, bool l3inflash, bool liinflash);
 
   static void HandleUserConfirmationPopUp(uint16_t ConfirmVP, const char *line1, const char *line2, const char *line3, const char *line4, bool l1inflash, bool l2inflash, bool l3inflash, bool liinflash);

Marlin/src/lcd/extui/ftdi_eve_touch_ui/archim2-flash/flash_storage.cpp

 
   /* In order to provide some degree of wear leveling, each data write to the
    * SPI Flash chip is appended to data that was already written before, until
-   * the data storage area is completely filled. New data is written preceeded
+   * the data storage area is completely filled. New data is written preceded
    * with a 32-bit delimiter 'LULZ', so that we can distinguish written and
    * unwritten data:
    *

Marlin/src/lcd/extui/ftdi_eve_touch_ui/ftdi_eve_lib/basic/commands.cpp

 
 void CLCD::init() {
   spi_init();                                  // Set Up I/O Lines for SPI and FT800/810 Control
-  ftdi_reset();                                // Power down/up the FT8xx with the apropriate delays
+  ftdi_reset();                                // Power down/up the FT8xx with the appropriate delays
 
   host_cmd(Use_Crystal ? CLKEXT : CLKINT, 0);
   host_cmd(FTDI::ACTIVE, 0);                        // Activate the System Clock

Marlin/src/lcd/extui/ftdi_eve_touch_ui/ftdi_eve_lib/basic/commands.h

   *
   * CommandFifo::fgcolor               Set Graphic Item Foreground Color      *
   * CommandFifo::bgcolor               Set Graphic Item Background Color      *
-  * CommandFifo::begin()               Begin Drawing a Primative              *
+  * CommandFifo::begin()               Begin Drawing a Primitive              *
   * CommandFifo::mem_copy()            Copy a Block of Memory                 *
   * CommandFifo::append()              Append Commands to Current DL          *
   * CommandFifo::gradient_color()      Set 3D Button Highlight Color          *

Marlin/src/lcd/extui/ftdi_eve_touch_ui/ftdi_eve_lib/extended/command_processor.h

     uint8_t _style = 0;
 
   protected:
-    // Returns the cannonical thickness of a widget (i.e. the height of a toggle element)
+    // Returns the canonical thickness of a widget (i.e. the height of a toggle element)
     uint16_t widget_thickness() {
       CLCD::FontMetrics fm(_font);
       return fm.height * 20.0/16;
       return toggle(x, y, w, h, text, state, options);
     }
 
-    // Contrained drawing routines. These constrain the widget inside a box for easier layout.
+    // Constrained drawing routines. These constrain the widget inside a box for easier layout.
     // The FORCEDINLINE ensures that the code is inlined so that all the math is done at compile time.
 
     FORCEDINLINE CommandProcessor& track_linear(int16_t x, int16_t y, int16_t w, int16_t h, int16_t tag) {

Marlin/src/lcd/extui/ftdi_eve_touch_ui/ftdi_eve_lib/extended/event_loop.cpp

    *  - Dispatches onTouchStart and onTouchEnd events to the active screen.
    *  - Handles auto-repetition by sending onTouchHeld to the active screen periodically.
    *  - Plays touch feedback "click" sounds when appropriate.
-   *  - Performs debouncing to supress spurious touch events.
+   *  - Performs debouncing to suppress spurious touch events.
    */
   void EventLoop::process_events() {
     // If the LCD is processing commands, don't check

Marlin/src/lcd/extui/ftdi_eve_touch_ui/ftdi_eve_lib/extended/poly_ui.h

       if (clip) {
         // Clipping reduces the number of pixels that are
         // filled, allowing more complex shapes to be drawn
-        // in the alloted time.
+        // in the allotted time.
         bounds(r, x, y, w, h);
         cmd.cmd(SAVE_CONTEXT());
         cmd.cmd(SCISSOR_XY(x, y));

Marlin/src/lcd/extui/ftdi_eve_touch_ui/ftdi_eve_lib/extended/polygon.h

  *        ...
  *   p.end_fill();
  *
- * Based on the example from "Applicaton Note AN_334, FT801 Polygon Application":
+ * Based on the example from "Application Note AN_334, FT801 Polygon Application":
  *
  *   https://brtchip.com/wp-content/uploads/Support/Documentation/Application_Notes/ICs/EVE/AN_334-FT801_Polygon_Application.pdf
  */

Marlin/src/lcd/extui/ftdi_eve_touch_ui/ftdi_eve_lib/extended/screen_types.h

 #define AT_SCREEN(screen)     (current_screen.getType() == current_screen.lookupScreen(screen::onRedraw))
 #define IS_PARENT_SCREEN(screen) (current_screen.peek() == current_screen.lookupScreen(screen::onRedraw))
 
-/************************** CACHED VS UNCHACHED SCREENS ***************************/
+/************************** CACHED VS UNCACHED SCREENS ***************************/
 
 class UncachedScreen {
   public:

Marlin/src/lcd/extui/ftdi_eve_touch_ui/ftdi_eve_lib/extended/tiny_timer.h

 
 /* tiny_interval_t downsamples a 32-bit millis() value
    into a 8-bit value which can record periods of
-   a few seconds with a rougly 1/16th of second
+   a few seconds with a roughly 1/16th of second
    resolution. This allows us to measure small
    intervals without needing to use four-byte counters.
  */

Marlin/src/lcd/extui/ftdi_eve_touch_ui/ftdi_eve_lib/scripts/svg2cpp.py

 
   def process_svg_path_data_cmd(self, id, cmd, a, b):
     """Converts the various types of moves into L or M commands
-    and dispatches to process_svg_path_L_or_M for futher processing."""
+    and dispatches to process_svg_path_L_or_M for further processing."""
     if cmd == "Z" or cmd == "z":
       self.process_svg_path_L_or_M("L", self.initial_x, self.initial_y)
     elif cmd == "H":

Marlin/src/lcd/extui/mks_ui/SPIFlashStorage.cpp

       return;
     }
 
-    // Part of the m_pageData was compressed, so ajust the pointers, freeing what was processed, shift the buffer
+    // Part of the m_pageData was compressed, so adjust the pointers, freeing what was processed, shift the buffer
     // TODO: To avoid this copy, use a circular buffer
     memmove(m_pageData, m_pageData + inputProcessed, m_pageDataUsed - inputProcessed);
     m_pageDataUsed -= inputProcessed;

Marlin/src/lcd/extui/mks_ui/SPIFlashStorage.h

  *
  * When reading, it loads a full page from SPI Flash at once and
  * keeps it in a private SRAM buffer. Data is loaded as needed to
- * fullfill requests. Sequential reads are optimal.
+ * fulfill requests. Sequential reads are optimal.
  *
  *    SPIFlashStorage.beginRead(myStartAddress);
  *    while (there is data to read)

Marlin/src/lcd/extui/mks_ui/draw_ui.cpp

   uint8_t command_buf[512];
 
   W25QXX.init(SPI_QUARTER_SPEED);
-  //read back the gcode command befor erase spi flash
+  //read back the gcode command before erase spi flash
   W25QXX.SPI_FLASH_BufferRead((uint8_t *)&command_buf, GCODE_COMMAND_ADDR, sizeof(command_buf));
   W25QXX.SPI_FLASH_SectorErase(VAR_INF_ADDR);
   W25QXX.SPI_FLASH_BufferWrite((uint8_t *)&gCfgItems, VAR_INF_ADDR, sizeof(gCfgItems));
   uint8_t command_buf[512];
 
   W25QXX.init(SPI_QUARTER_SPEED);
-  //read back the gcode command befor erase spi flash
+  //read back the gcode command before erase spi flash
   W25QXX.SPI_FLASH_BufferRead((uint8_t *)&command_buf, GCODE_COMMAND_ADDR, sizeof(command_buf));
   W25QXX.SPI_FLASH_SectorErase(VAR_INF_ADDR);
   W25QXX.SPI_FLASH_BufferWrite((uint8_t *)&gCfgItems, VAR_INF_ADDR, sizeof(gCfgItems));

Marlin/src/lcd/extui/mks_ui/pic_manager.cpp

       disp_assets_update_progress("Reading files...");
       dir_t d;
       while (dir.readDir(&d, card.longFilename) > 0) {
-        // If we dont get a long name, but gets a short one, try it
+        // If we don't get a long name, but gets a short one, try it
         if (card.longFilename[0] == 0 && d.name[0] != 0)
           dosName2LongName((const char*)d.name, card.longFilename);
         if (card.longFilename[0] == 0) continue;

Marlin/src/lcd/extui/mks_ui/printer_operation.cpp

 
         gcode.process_subcommands_now_P(PSTR("M25"));
 
-        //save the positon
+        //save the position
         uiCfg.current_x_position_bak = current_position.x;
         uiCfg.current_y_position_bak = current_position.y;
         uiCfg.current_z_position_bak = current_position.z;

Marlin/src/lcd/extui/mks_ui/wifiSerial_STM32.cpp

     // nop, the interrupt handler will free up space for us
   }
   // If we get here, nothing is queued anymore (DRIE is disabled) and
-  // the hardware finished tranmission (TXC is set).
+  // the hardware finished transmission (TXC is set).
 }
 
 bool WifiSerial::isHalfDuplex() const { return _serial.pin_rx == NC; }

Marlin/src/lcd/marlinui.cpp

      *     This is used to achieve more rapid stepping on kinematic machines.
      *
      * Currently used by the _lcd_move_xyz function in menu_motion.cpp
-     * and the ubl_map_move_to_xy funtion in menu_ubl.cpp.
+     * and the ubl_map_move_to_xy function in menu_ubl.cpp.
      */
     void ManualMove::task() {
 

Marlin/src/lcd/tft/canvas.cpp

 }
 
 void CANVAS::SetBackground(uint16_t color) {
-  /* TODO: test and optimize perfomance */
+  /* TODO: test and optimize performance */
   /*
   uint32_t count = (endLine - startLine) * width;
   uint16_t *pixel = buffer;

Marlin/src/libs/MAX31865.cpp

   // From the datasheet:
   // Note that a single conversion requires approximately 52ms in 60Hz filter
   // mode or 62.5ms in 50Hz filter mode to complete. 1-Shot is a self-clearing bit.
-  // TODO: switch this out depeding on the filter mode.
+  // TODO: switch this out depending on the filter mode.
   DELAY_US(65000); // 65ms
 }
 
 }
 
 /**
- * Calulate and return the resistance value of the connected RTD.
+ * Calculate and return the resistance value of the connected RTD.
  *
  * @param  refResistor The value of the matching reference resistor, usually 430 or 4300
  * @return             The raw RTD resistance value, NOT temperature!

Marlin/src/libs/MAX31865.h

 #define MAX31865_FAULT_OVUV 0x04        // D2
 
 // http://www.analog.com/media/en/technical-documentation/application-notes/AN709_0.pdf
-// constants for calulating temperature from the measured RTD resistance.
+// constants for calculating temperature from the measured RTD resistance.
 #define RTD_Z1 -0.0039083
 #define RTD_Z2 0.00001758480889
 #define RTD_Z3 -0.0000000231

Marlin/src/libs/W25Qxx.cpp

 /*******************************************************************************
 * Function Name  : SPI_FLASH_WaitForWriteEnd
 * Description    : Polls the status of the Write In Progress (WIP) flag in the
-*                  FLASH's status  register  and  loop  until write  opertaion
-*                  has completed.
+*                  FLASH's status register and loop until write operation has
+*                  completed.
 * Input          : None
 * Output         : None
 * Return         : None

Marlin/src/libs/buzzer.h

       static CircularQueue<tone_t, TONE_QUEUE_LENGTH> buffer;
 
       /**
-       * @brief Inverts the sate of a digital PIN
+       * @brief Inverts the state of a digital PIN
        * @details This will invert the current state of an digital IO pin.
        */
       FORCE_INLINE static void invert() { TOGGLE(BEEPER_PIN); }

Marlin/src/libs/duration_t.h

 
   /**
    * @brief Formats the duration as a string
-   * @details String will be formated using a "full" representation of duration
+   * @details String will be formatted using a "full" representation of duration
    *
    * @param buffer The array pointed to must be able to accommodate 22 bytes
    *               (21 for the string, 1 more for the terminating nul)
 
   /**
    * @brief Formats the duration as a string
-   * @details String will be formated using a "digital" representation of duration
+   * @details String will be formatted using a "digital" representation of duration
    *
    * @param buffer The array pointed to must be able to accommodate 10 bytes
    *

Marlin/src/module/endstops.cpp

     const byte dual_hit = TEST_ENDSTOP(_ENDSTOP(A, MINMAX)) | (TEST_ENDSTOP(_ENDSTOP(A##2, MINMAX)) << 1); \
     if (dual_hit) { \
       _ENDSTOP_HIT(A, MINMAX); \
-      /* if not performing home or if both endstops were trigged during homing... */ \
+      /* if not performing home or if both endstops were triggered during homing... */ \
       if (!stepper.separate_multi_axis || dual_hit == 0b11) \
         planner.endstop_triggered(_AXIS(A)); \
     } \
     const byte triple_hit = TEST_ENDSTOP(_ENDSTOP(A, MINMAX)) | (TEST_ENDSTOP(_ENDSTOP(A##2, MINMAX)) << 1) | (TEST_ENDSTOP(_ENDSTOP(A##3, MINMAX)) << 2); \
     if (triple_hit) { \
       _ENDSTOP_HIT(A, MINMAX); \
-      /* if not performing home or if both endstops were trigged during homing... */ \
+      /* if not performing home or if both endstops were triggered during homing... */ \
       if (!stepper.separate_multi_axis || triple_hit == 0b111) \
         planner.endstop_triggered(_AXIS(A)); \
     } \
     const byte quad_hit = TEST_ENDSTOP(_ENDSTOP(A, MINMAX)) | (TEST_ENDSTOP(_ENDSTOP(A##2, MINMAX)) << 1) | (TEST_ENDSTOP(_ENDSTOP(A##3, MINMAX)) << 2) | (TEST_ENDSTOP(_ENDSTOP(A##4, MINMAX)) << 3); \
     if (quad_hit) { \
       _ENDSTOP_HIT(A, MINMAX); \
-      /* if not performing home or if both endstops were trigged during homing... */ \
+      /* if not performing home or if both endstops were triggered during homing... */ \
       if (!stepper.separate_multi_axis || quad_hit == 0b1111) \
         planner.endstop_triggered(_AXIS(A)); \
     } \

Marlin/src/module/planner.h

       static void quick_resume();
     #endif
 
-    // Called when an endstop is triggered. Causes the machine to stop inmediately
+    // Called when an endstop is triggered. Causes the machine to stop immediately
     static void endstop_triggered(const AxisEnum axis);
 
     // Triggered position of an axis in mm (not core-savvy)

Marlin/src/module/stepper/trinamic.cpp

 // TMC Slave Address Conflict Detection
 //
 // Conflict detection is performed in the following way. Similar methods are used for
-// hardware and software serial, but the implementations are indepenent.
+// hardware and software serial, but the implementations are independent.
 //
 // 1. Populate a data structure with UART parameters and addresses for all possible axis.
 //      If an axis is not in use, populate it with recognizable placeholder data.

Marlin/src/module/temperature.cpp

     #endif
 
     #if ENABLED(PIDTEMPCHAMBER)
-      // PIDTEMPCHAMBER doens't support a CHAMBER_VENT yet.
+      // PIDTEMPCHAMBER doesn't support a CHAMBER_VENT yet.
       temp_chamber.soft_pwm_amount = WITHIN(temp_chamber.celsius, CHAMBER_MINTEMP, CHAMBER_MAXTEMP) ? (int)get_pid_output_chamber() >> 1 : 0;
     #else
       if (ELAPSED(ms, next_chamber_check_ms)) {

Marlin/src/module/thermistor/thermistor_61.h

 // B Value             3950K at 25/50 deg. C
 // B Value Tolerance         + / - 1%
 constexpr temp_entry_t temptable_61[] PROGMEM = {
-  { OV(   2.00), 420 }, // Guestimate to ensure we dont lose a reading and drop temps to -50 when over
+  { OV(   2.00), 420 }, // Guestimate to ensure we don't lose a reading and drop temps to -50 when over
   { OV(  12.07), 350 },
   { OV(  12.79), 345 },
   { OV(  13.59), 340 },

Marlin/src/pins/lpc1768/pins_BTT_SKR_V1_1.h

   // Using TMC devices in intelligent mode requires extra connections to each device. Unfortunately
   // the SKR does not have many free pins (especially if a display is in use). The SPI-based devices
   // will require 3 connections (clock, mosi, miso), plus a chip select line (CS) for each driver.
-  // The UART-based devices require 2 pis per deriver (one of which must be interrupt capable).
+  // The UART-based devices require 2 pis per driver (one of which must be interrupt capable).
   // The same SPI pins can be shared with the display/SD card reader, meaning SPI-based devices are
   // probably a good choice for this board.
   //

Marlin/src/pins/lpc1768/pins_BTT_SKR_V1_3.h

 
   #elif HAS_ADC_BUTTONS
 
-    #error "ADC BUTTONS do not work unmodifed on SKR 1.3, The ADC ports cannot take more than 3.3v."
+    #error "ADC BUTTONS do not work unmodified on SKR 1.3, The ADC ports cannot take more than 3.3v."
 
   #elif HAS_SPI_TFT                               // Config for Classic UI (emulated DOGM) and Color UI
 

Marlin/src/pins/lpc1768/pins_BTT_SKR_V1_4.h

 #endif // HAS_WIRED_LCD
 
 #if HAS_ADC_BUTTONS
-  #error "ADC BUTTONS do not work unmodifed on SKR 1.4, The ADC ports cannot take more than 3.3v."
+  #error "ADC BUTTONS do not work unmodified on SKR 1.4, The ADC ports cannot take more than 3.3v."
 #endif
 
 //