Use American English

Marlin/src/HAL/HAL_LPC1768/main.cpp

 
   // Runs after clock init and before global static constructors
   void SystemPostInit() {
-    _millis = 0;                            // Initialise the millisecond counter value;
+    _millis = 0;                            // Initialize the millisecond counter value
     SysTick_Config(SystemCoreClock / 1000); // Start millisecond global counter
 
     // Runs before setup() need to configure LED_PIN and use to indicate succsessful bootloader execution
   while (!USB_Configuration && PENDING(millis(), usb_timeout)) {
     delay(50);
     #if PIN_EXISTS(LED)
-      TOGGLE(LED_PIN);     // Flash fast while USB initialisation completes
+      TOGGLE(LED_PIN);     // Flash quickly during USB initialization
     #endif
   }
 
     #if NUM_SERIAL > 1
       MYSERIAL1.begin(BAUDRATE);
     #endif
-    SERIAL_PRINTF("\n\necho:%s (%dMhz) Initialised\n", isLPC1769() ? "LPC1769" : "LPC1768", SystemCoreClock / 1000000);
+    SERIAL_PRINTF("\n\necho:%s (%dMhz) Initialized\n", isLPC1769() ? "LPC1769" : "LPC1768", SystemCoreClock / 1000000);
     SERIAL_FLUSHTX();
   #endif
 

Marlin/src/HAL/HAL_STM32F4/EEPROM_Emul/eeprom_emul.cpp

   * @retval - Flash error code: on write Flash error
   *         - FLASH_COMPLETE: on success
   */
-uint16_t EE_Initialise(void) {
+uint16_t EE_Initialize(void) {
   uint16_t PageStatus0 = 6, PageStatus1 = 6;
   uint16_t VarIdx = 0;
   uint16_t EepromStatus = 0, ReadStatus = 0;

Marlin/src/HAL/HAL_STM32F4/EEPROM_Emul/eeprom_emul.h

 /* Exported types ------------------------------------------------------------*/
 /* Exported macro ------------------------------------------------------------*/
 /* Exported functions ------------------------------------------------------- */
-uint16_t EE_Initialise(void);
+uint16_t EE_Initialize(void);
 uint16_t EE_ReadVariable(uint16_t VirtAddress, uint16_t* Data);
 uint16_t EE_WriteVariable(uint16_t VirtAddress, uint16_t Data);
 

Marlin/src/HAL/HAL_STM32F4/EmulatedEeprom.cpp

 // --------------------------------------------------------------------------
 // Private Variables
 // --------------------------------------------------------------------------
-static bool eeprom_initialised = false;
+static bool eeprom_initialized = false;
 // --------------------------------------------------------------------------
 // Function prototypes
 // --------------------------------------------------------------------------
 
 
 void eeprom_init() {
-  if (!eeprom_initialised) {
+  if (!eeprom_initialized) {
     HAL_FLASH_Unlock();
 
     __HAL_FLASH_CLEAR_FLAG(FLASH_FLAG_EOP | FLASH_FLAG_OPERR | FLASH_FLAG_WRPERR |FLASH_FLAG_PGAERR | FLASH_FLAG_PGPERR | FLASH_FLAG_PGSERR);
 
     /* EEPROM Init */
-    if (EE_Initialise() != EE_OK)
+    if (EE_Initialize() != EE_OK)
       for (;;) HAL_Delay(1); // Spin forever until watchdog reset
 
     HAL_FLASH_Lock();
-    eeprom_initialised = true;
+    eeprom_initialized = true;
   }
 }
 

Marlin/src/HAL/HAL_STM32F4/HAL_timers_STM32F4.cpp

 // Public functions
 // --------------------------------------------------------------------------
 
-bool timers_initialised[NUM_HARDWARE_TIMERS] = {false};
+bool timers_initialized[NUM_HARDWARE_TIMERS] = {false};
 
 void HAL_timer_start(const uint8_t timer_num, const uint32_t frequency) {
 
-  if (!timers_initialised[timer_num]) {
+  if (!timers_initialized[timer_num]) {
     constexpr uint32_t step_prescaler = STEPPER_TIMER_PRESCALE - 1,
                        temp_prescaler = TEMP_TIMER_PRESCALE - 1;
     switch (timer_num) {
         HAL_NVIC_SetPriority(TEMP_TIMER_IRQ_ID, 2, 0);
         break;
     }
-    timers_initialised[timer_num] = true;
+    timers_initialized[timer_num] = true;
   }
 
   #ifdef STM32GENERIC

Marlin/src/HAL/HAL_STM32F7/EEPROM_Emul/eeprom_emul.cpp

   * @retval - Flash error code: on write Flash error
   *         - FLASH_COMPLETE: on success
   */
-uint16_t EE_Initialise(void) {
+uint16_t EE_Initialize(void) {
   uint16_t PageStatus0 = 6, PageStatus1 = 6;
   uint16_t VarIdx = 0;
   uint16_t EepromStatus = 0, ReadStatus = 0;

Marlin/src/HAL/HAL_STM32F7/EEPROM_Emul/eeprom_emul.h

 /* Exported types ------------------------------------------------------------*/
 /* Exported macro ------------------------------------------------------------*/
 /* Exported functions ------------------------------------------------------- */
-uint16_t EE_Initialise(void);
+uint16_t EE_Initialize(void);
 uint16_t EE_ReadVariable(uint16_t VirtAddress, uint16_t* Data);
 uint16_t EE_WriteVariable(uint16_t VirtAddress, uint16_t Data);
 

Marlin/src/HAL/HAL_STM32F7/EmulatedEeprom.cpp

 // --------------------------------------------------------------------------
 // Private Variables
 // --------------------------------------------------------------------------
-static bool eeprom_initialised = false;
+static bool eeprom_initialized = false;
 // --------------------------------------------------------------------------
 // Function prototypes
 // --------------------------------------------------------------------------
 
 
 void eeprom_init() {
-  if (!eeprom_initialised) {
+  if (!eeprom_initialized) {
     HAL_FLASH_Unlock();
 
     __HAL_FLASH_CLEAR_FLAG(FLASH_FLAG_EOP | FLASH_FLAG_OPERR | FLASH_FLAG_WRPERR |FLASH_FLAG_PGAERR | FLASH_FLAG_PGPERR | FLASH_FLAG_PGSERR);
 
     /* EEPROM Init */
-    if (EE_Initialise() != EE_OK)
+    if (EE_Initialize() != EE_OK)
       for (;;) HAL_Delay(1); // Spin forever until watchdog reset
 
     HAL_FLASH_Lock();
-    eeprom_initialised = true;
+    eeprom_initialized = true;
   }
 }
 

Marlin/src/HAL/HAL_STM32F7/HAL_timers_STM32F7.cpp

 // --------------------------------------------------------------------------
 
 
-bool timers_initialised[NUM_HARDWARE_TIMERS] = {false};
+bool timers_initialized[NUM_HARDWARE_TIMERS] = {false};
 
 void HAL_timer_start(const uint8_t timer_num, const uint32_t frequency) {
 
-  if (!timers_initialised[timer_num]) {
+  if (!timers_initialized[timer_num]) {
     switch (timer_num) {
       case STEP_TIMER_NUM:
       //STEPPER TIMER TIM5 //use a 32bit timer
       HAL_NVIC_SetPriority(timerConfig[1].IRQ_Id, 2, 0);
       break;
     }
-    timers_initialised[timer_num] = true;
+    timers_initialized[timer_num] = true;
   }
 
   timerConfig[timer_num].timerdef.Init.Period = (((HAL_TIMER_RATE) / timerConfig[timer_num].timerdef.Init.Prescaler) / frequency) - 1;

Marlin/src/HAL/HAL_TEENSY35_36/HAL_spi_Teensy.cpp

 static SPISettings spiConfig;
 
 // Standard SPI functions
-/** Initialise SPI bus */
+/** Initialize SPI bus */
 void spiBegin(void) {
   #if !PIN_EXISTS(SS)
     #error SS_PIN not defined!

Marlin/src/HAL/shared/HAL_SPI.h

 #define SPI_DATAMODE_3 0x0C
 
 // Standard SPI functions
-/** Initialise SPI bus */
+/** Initialize SPI bus */
 void spiBegin(void);
 /** Configure SPI for specified SPI speed */
 void spiInit(uint8_t spiRate);

Marlin/src/HAL/shared/I2cEeprom.cpp

 static uint8_t eeprom_device_address = 0x50;
 
 static void eeprom_init(void) {
-  static bool eeprom_initialised = false;
-  if (!eeprom_initialised) {
+  static bool eeprom_initialized = false;
+  if (!eeprom_initialized) {
     Wire.begin();
-    eeprom_initialised = true;
+    eeprom_initialized = true;
   }
 }
 

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

 
 
 /**
- * Initialise the data used for unwinding.
+ * Initialize the data used for unwinding.
  */
 void UnwInitState(UnwState * const state,     /**< Pointer to structure to fill. */
                   const UnwindCallbacks *cb,  /**< Callbacks. */

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

     /* We don't have unwind information tables */
     UnwState state;
 
-    /* Initialise the unwinding state */
+    /* Initialize the unwinding state */
     UnwInitState(&state, cb, data, frame->pc, frame->sp);
 
     /* Check the Thumb bit */

Marlin/src/feature/I2CPositionEncoder.cpp

   encoderAxis = axis;
   i2cAddress = address;
 
-  initialised++;
+  initialized++;
 
   SERIAL_ECHOPAIR("Setting up encoder on ", axis_codes[encoderAxis]);
   SERIAL_ECHOLNPAIR(" axis, addr = ", address);
 }
 
 void I2CPositionEncoder::update() {
-  if (!initialised || !homed || !active) return; //check encoder is set up and active
+  if (!initialized || !homed || !active) return; //check encoder is set up and active
 
   position = get_position();
 
         SERIAL_ECHOLNPGM(" 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
-        //idea of where it the axis is to re-initialise
+        //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();
 
   SERIAL_ECHOLNPGM("Address change successful!");
 
   // Now, if this module is configured, find which encoder instance it's supposed to correspond to
-  // and enable it (it will likely have failed initialisation on power-up, before the address change).
+  // and enable it (it will likely have failed initialization on power-up, before the address change).
   const int8_t idx = idx_from_addr(newaddr);
   if (idx >= 0 && !encoders[idx].get_active()) {
     SERIAL_ECHO(axis_codes[encoders[idx].get_axis()]);

Marlin/src/feature/I2CPositionEncoder.h

 
     bool      homed               = false,
               trusted             = false,
-              initialised         = false,
+              initialized         = false,
               active              = false,
               invert              = false,
               ec                  = true;

frameworks/CMSIS/LPC1768/include/core_cm3.h

 
 /** \brief  System Tick Configuration
 
-    This function initialises the system tick timer and its interrupt and start the system tick timer.
+    This function initializes the system tick timer and its interrupt and start the system tick timer.
     Counter is in free running mode to generate periodical interrupts.
 
     \param [in]  ticks  Number of ticks between two interrupts

frameworks/CMSIS/LPC1768/lib/usb/cdcuser.cpp

 /* end Buffer handling */
 
 /*----------------------------------------------------------------------------
- CDC Initialisation
+ CDC Initialization
  Initializes the data structures and serial port
  Parameters:   None
  Return Value: None