diff --git a/Firmware/ConfigurationStore.cpp b/Firmware/ConfigurationStore.cpp
index aaa2089b2..d5bdce121 100644
--- a/Firmware/ConfigurationStore.cpp
+++ b/Firmware/ConfigurationStore.cpp
@@ -181,7 +181,7 @@ static const M500_conf default_conf PROGMEM =
 void Config_StoreSettings()
 {
   strcpy_P(cs.version, default_conf.version);
-  eeprom_update_block(reinterpret_cast<uint8_t*>(&cs), reinterpret_cast<uint8_t*>(EEPROM_M500_base), sizeof(cs));
+  eeprom_update_block_notify(reinterpret_cast<uint8_t*>(&cs), reinterpret_cast<uint8_t*>(EEPROM_M500_base), sizeof(cs));
 #ifdef THERMAL_MODEL
   thermal_model_save_settings();
 #endif
diff --git a/Firmware/Dcodes.cpp b/Firmware/Dcodes.cpp
index 755a9a212..432e86f9b 100644
--- a/Firmware/Dcodes.cpp
+++ b/Firmware/Dcodes.cpp
@@ -120,7 +120,7 @@ void write_mem(uint16_t address, uint16_t count, const uint8_t* data, const dcod
         switch (type)
         {
         case dcode_mem_t::sram: *((uint8_t*)address) = data[i]; break;
-        case dcode_mem_t::eeprom: eeprom_write_byte((uint8_t*)address, data[i]); break;
+        case dcode_mem_t::eeprom: eeprom_write_byte_notify((uint8_t*)address, data[i]); break;
         case dcode_mem_t::progmem: break;
         case dcode_mem_t::xflash: break;
         }
@@ -255,7 +255,7 @@ void dcode_1()
 	LOG("D1 - Clear EEPROM and RESET\n");
 	cli();
 	for (int i = 0; i < 8192; i++)
-		eeprom_write_byte((unsigned char*)i, (unsigned char)0xff);
+		eeprom_write_byte_notify((unsigned char*)i, (unsigned char)0xff);
 	softReset();
 }
 #endif
@@ -487,12 +487,12 @@ void dcode_8()
 	else if (strchr_pointer[1+1] == '!')
 	{
 		cal_status = 1;
-		eeprom_write_byte((uint8_t*)EEPROM_CALIBRATION_STATUS_PINDA, cal_status);
-		eeprom_write_word(((uint16_t*)EEPROM_PROBE_TEMP_SHIFT) + 0,   8); //40C -  20um -   8usteps
-		eeprom_write_word(((uint16_t*)EEPROM_PROBE_TEMP_SHIFT) + 1,  24); //45C -  60um -  24usteps
-		eeprom_write_word(((uint16_t*)EEPROM_PROBE_TEMP_SHIFT) + 2,  48); //50C - 120um -  48usteps
-		eeprom_write_word(((uint16_t*)EEPROM_PROBE_TEMP_SHIFT) + 3,  80); //55C - 200um -  80usteps
-		eeprom_write_word(((uint16_t*)EEPROM_PROBE_TEMP_SHIFT) + 4, 120); //60C - 300um - 120usteps
+		eeprom_write_byte_notify((uint8_t*)EEPROM_CALIBRATION_STATUS_PINDA, cal_status);
+		eeprom_write_word_notify(((uint16_t*)EEPROM_PROBE_TEMP_SHIFT) + 0,   8); //40C -  20um -   8usteps
+		eeprom_write_word_notify(((uint16_t*)EEPROM_PROBE_TEMP_SHIFT) + 1,  24); //45C -  60um -  24usteps
+		eeprom_write_word_notify(((uint16_t*)EEPROM_PROBE_TEMP_SHIFT) + 2,  48); //50C - 120um -  48usteps
+		eeprom_write_word_notify(((uint16_t*)EEPROM_PROBE_TEMP_SHIFT) + 3,  80); //55C - 200um -  80usteps
+		eeprom_write_word_notify(((uint16_t*)EEPROM_PROBE_TEMP_SHIFT) + 4, 120); //60C - 300um - 120usteps
 	}
 	else
 	{
diff --git a/Firmware/Filament_sensor.cpp b/Firmware/Filament_sensor.cpp
index 02a82cf56..86c298795 100644
--- a/Firmware/Filament_sensor.cpp
+++ b/Firmware/Filament_sensor.cpp
@@ -41,7 +41,7 @@ FSensorBlockRunout::~FSensorBlockRunout() { }
 #endif // FILAMENT_SENSOR
 
 void Filament_sensor::setEnabled(bool enabled) {
-    eeprom_update_byte((uint8_t *)EEPROM_FSENSOR, enabled);
+    eeprom_update_byte_notify((uint8_t *)EEPROM_FSENSOR, enabled);
     if (enabled) {
         fsensor.init();
     } else {
@@ -52,21 +52,21 @@ void Filament_sensor::setEnabled(bool enabled) {
 void Filament_sensor::setAutoLoadEnabled(bool state, bool updateEEPROM) {
     autoLoadEnabled = state;
     if (updateEEPROM) {
-        eeprom_update_byte((uint8_t *)EEPROM_FSENS_AUTOLOAD_ENABLED, state);
+        eeprom_update_byte_notify((uint8_t *)EEPROM_FSENS_AUTOLOAD_ENABLED, state);
     }
 }
 
 void Filament_sensor::setRunoutEnabled(bool state, bool updateEEPROM) {
     runoutEnabled = state;
     if (updateEEPROM) {
-        eeprom_update_byte((uint8_t *)EEPROM_FSENS_RUNOUT_ENABLED, state);
+        eeprom_update_byte_notify((uint8_t *)EEPROM_FSENS_RUNOUT_ENABLED, state);
     }
 }
 
 void Filament_sensor::setActionOnError(SensorActionOnError state, bool updateEEPROM) {
     sensorActionOnError = state;
     if (updateEEPROM) {
-        eeprom_update_byte((uint8_t *)EEPROM_FSENSOR_ACTION_NA, (uint8_t)state);
+        eeprom_update_byte_notify((uint8_t *)EEPROM_FSENSOR_ACTION_NA, (uint8_t)state);
     }
 }
 
@@ -288,7 +288,7 @@ const char *IR_sensor_analog::getIRVersionText() {
 void IR_sensor_analog::setSensorRevision(SensorRevision rev, bool updateEEPROM) {
     sensorRevision = rev;
     if (updateEEPROM) {
-        eeprom_update_byte((uint8_t *)EEPROM_FSENSOR_PCB, (uint8_t)rev);
+        eeprom_update_byte_notify((uint8_t *)EEPROM_FSENSOR_PCB, (uint8_t)rev);
     }
 }
 
@@ -446,7 +446,7 @@ void PAT9125_sensor::setJamDetectionEnabled(bool state, bool updateEEPROM) {
     resetStepCount();
     jamErrCnt = 0;
     if (updateEEPROM) {
-        eeprom_update_byte((uint8_t *)EEPROM_FSENSOR_JAM_DETECTION, state);
+        eeprom_update_byte_notify((uint8_t *)EEPROM_FSENSOR_JAM_DETECTION, state);
     }
 }
 
diff --git a/Firmware/Marlin_main.cpp b/Firmware/Marlin_main.cpp
index 157b97ab7..07490a5df 100644
--- a/Firmware/Marlin_main.cpp
+++ b/Firmware/Marlin_main.cpp
@@ -655,12 +655,12 @@ void crashdet_cancel() {
 
 void failstats_reset_print()
 {
-	eeprom_update_byte((uint8_t *)EEPROM_CRASH_COUNT_X, 0);
-	eeprom_update_byte((uint8_t *)EEPROM_CRASH_COUNT_Y, 0);
-	eeprom_update_byte((uint8_t *)EEPROM_FERROR_COUNT, 0);
-	eeprom_update_byte((uint8_t *)EEPROM_POWER_COUNT, 0);
-	eeprom_update_byte((uint8_t *)EEPROM_MMU_FAIL, 0);
-	eeprom_update_byte((uint8_t *)EEPROM_MMU_LOAD_FAIL, 0);
+	eeprom_update_byte_notify((uint8_t *)EEPROM_CRASH_COUNT_X, 0);
+	eeprom_update_byte_notify((uint8_t *)EEPROM_CRASH_COUNT_Y, 0);
+	eeprom_update_byte_notify((uint8_t *)EEPROM_FERROR_COUNT, 0);
+	eeprom_update_byte_notify((uint8_t *)EEPROM_POWER_COUNT, 0);
+	eeprom_update_byte_notify((uint8_t *)EEPROM_MMU_FAIL, 0);
+	eeprom_update_byte_notify((uint8_t *)EEPROM_MMU_LOAD_FAIL, 0);
 }
 
 void watchdogEarlyDisable(void) {
@@ -707,19 +707,19 @@ void softReset(void) {
 
 
 static void factory_reset_stats(){
-    eeprom_update_dword((uint32_t *)EEPROM_TOTALTIME, 0);
-    eeprom_update_dword((uint32_t *)EEPROM_FILAMENTUSED, 0);
+    eeprom_update_dword_notify((uint32_t *)EEPROM_TOTALTIME, 0);
+    eeprom_update_dword_notify((uint32_t *)EEPROM_FILAMENTUSED, 0);
 
     failstats_reset_print();
 
-    eeprom_update_word((uint16_t *)EEPROM_CRASH_COUNT_X_TOT, 0);
-    eeprom_update_word((uint16_t *)EEPROM_CRASH_COUNT_Y_TOT, 0);
-    eeprom_update_word((uint16_t *)EEPROM_FERROR_COUNT_TOT, 0);
-    eeprom_update_word((uint16_t *)EEPROM_POWER_COUNT_TOT, 0);
+    eeprom_update_word_notify((uint16_t *)EEPROM_CRASH_COUNT_X_TOT, 0);
+    eeprom_update_word_notify((uint16_t *)EEPROM_CRASH_COUNT_Y_TOT, 0);
+    eeprom_update_word_notify((uint16_t *)EEPROM_FERROR_COUNT_TOT, 0);
+    eeprom_update_word_notify((uint16_t *)EEPROM_POWER_COUNT_TOT, 0);
 
-    eeprom_update_word((uint16_t *)EEPROM_MMU_FAIL_TOT, 0);
-    eeprom_update_word((uint16_t *)EEPROM_MMU_LOAD_FAIL_TOT, 0);
-    eeprom_update_dword((uint32_t *)EEPROM_MMU_MATERIAL_CHANGES, 0);
+    eeprom_update_word_notify((uint16_t *)EEPROM_MMU_FAIL_TOT, 0);
+    eeprom_update_word_notify((uint16_t *)EEPROM_MMU_LOAD_FAIL_TOT, 0);
+    eeprom_update_dword_notify((uint32_t *)EEPROM_MMU_MATERIAL_CHANGES, 0);
 }
 
 // Factory reset function
@@ -750,7 +750,7 @@ static void factory_reset(char level)
 
 		// Force the wizard in "Follow calibration flow" mode at the next boot up
 		calibration_status_clear(CALIBRATION_FORCE_PREP);
-		eeprom_write_byte((uint8_t*)EEPROM_WIZARD_ACTIVE, 2);
+		eeprom_write_byte_notify((uint8_t*)EEPROM_WIZARD_ACTIVE, 2);
 		farm_disable();
 
 #ifdef FILAMENT_SENSOR
@@ -767,7 +767,7 @@ static void factory_reset(char level)
 		menu_progressbar_init(EEPROM_TOP, PSTR("ERASING all data"));
 		// Erase EEPROM
 		for (uint16_t i = 0; i < EEPROM_TOP; i++) {
-			eeprom_update_byte((uint8_t*)i, 0xFF);
+			eeprom_update_byte_notify((uint8_t*)i, 0xFF);
 			menu_progressbar_update(i);
 		}
 		menu_progressbar_finish();
@@ -921,7 +921,7 @@ void update_sec_lang_from_external_flash()
 			else
 			{
 				//TODO - check sec lang data integrity
-				eeprom_update_byte((unsigned char *)EEPROM_LANG, LANG_ID_SEC);
+				eeprom_update_byte_notify((unsigned char *)EEPROM_LANG, LANG_ID_SEC);
 			}
 		}
 	}
@@ -1023,7 +1023,7 @@ static void fw_crash_init()
 #endif //XFLASH_DUMP
 
     // prevent crash prompts to reappear once acknowledged
-    eeprom_update_byte((uint8_t*)EEPROM_FW_CRASH_FLAG, 0xFF);
+    eeprom_update_byte_notify((uint8_t*)EEPROM_FW_CRASH_FLAG, 0xFF);
 }
 
 #define KILL_PENDING_FLAG 0x42
@@ -1031,7 +1031,7 @@ static void fw_crash_init()
 static void fw_kill_init() {
     if (eeprom_read_byte((uint8_t*)EEPROM_KILL_PENDING_FLAG) == KILL_PENDING_FLAG) {
         // clear pending message event
-        eeprom_write_byte((uint8_t*)EEPROM_KILL_PENDING_FLAG, EEPROM_EMPTY_VALUE);
+        eeprom_write_byte_notify((uint8_t*)EEPROM_KILL_PENDING_FLAG, EEPROM_EMPTY_VALUE);
 
         // display the kill message
         PGM_P kill_msg = (PGM_P)eeprom_read_word((uint16_t*)EEPROM_KILL_MESSAGE);
@@ -1106,7 +1106,7 @@ void setup()
         {
             if (!get_PRUSA_SN(SN))
             {
-                eeprom_update_block(SN, (uint8_t*)EEPROM_PRUSA_SN, 20);
+                eeprom_update_block_notify(SN, (uint8_t*)EEPROM_PRUSA_SN, 20);
                 puts_P(PSTR("SN updated"));
             }
             else
@@ -1452,13 +1452,13 @@ void setup()
 	eeprom_init_default_byte((uint8_t*)EEPROM_TEMP_CAL_ACTIVE, 0);
 
 	if (eeprom_read_byte((uint8_t*)EEPROM_CALIBRATION_STATUS_PINDA) == 255) {
-		//eeprom_write_byte((uint8_t*)EEPROM_CALIBRATION_STATUS_PINDA, 0);
-		eeprom_write_byte((uint8_t*)EEPROM_CALIBRATION_STATUS_PINDA, 1);
+		//eeprom_write_byte_notify((uint8_t*)EEPROM_CALIBRATION_STATUS_PINDA, 0);
+		eeprom_update_byte_notify((uint8_t*)EEPROM_CALIBRATION_STATUS_PINDA, 1);
 		int16_t z_shift = 0;
 		for (uint8_t i = 0; i < 5; i++) {
-			eeprom_update_word((uint16_t*)EEPROM_PROBE_TEMP_SHIFT + i, z_shift);
+			eeprom_update_word_notify((uint16_t*)EEPROM_PROBE_TEMP_SHIFT + i, z_shift);
 		}
-		eeprom_write_byte((uint8_t*)EEPROM_TEMP_CAL_ACTIVE, 0);
+		eeprom_update_byte_notify((uint8_t*)EEPROM_TEMP_CAL_ACTIVE, 0);
 	}
 	eeprom_init_default_byte((uint8_t*)EEPROM_UVLO, PowerPanic::NO_PENDING_RECOVERY);
 	eeprom_init_default_byte((uint8_t*)EEPROM_SD_SORT, 0);
@@ -1488,16 +1488,16 @@ void setup()
 	  //if user confirms with knob, new hw version (printer and/or motherboard) is written to eeprom and message will be not shown next time
 	case(0b01): 
 		lcd_show_fullscreen_message_and_wait_P(_i("Warning: motherboard type changed.")); ////MSG_CHANGED_MOTHERBOARD c=20 r=4
-		eeprom_write_word((uint16_t*)EEPROM_BOARD_TYPE, MOTHERBOARD); 
+		eeprom_write_word_notify((uint16_t*)EEPROM_BOARD_TYPE, MOTHERBOARD);
 		break;
 	case(0b10): 
 		lcd_show_fullscreen_message_and_wait_P(_i("Warning: printer type changed.")); ////MSG_CHANGED_PRINTER c=20 r=4
-		eeprom_write_word((uint16_t*)EEPROM_PRINTER_TYPE, PRINTER_TYPE); 
+		eeprom_write_word_notify((uint16_t*)EEPROM_PRINTER_TYPE, PRINTER_TYPE);
 		break;
 	case(0b11): 
 		lcd_show_fullscreen_message_and_wait_P(_i("Warning: both printer type and motherboard type changed.")); ////MSG_CHANGED_BOTH c=20 r=4
-		eeprom_write_word((uint16_t*)EEPROM_PRINTER_TYPE, PRINTER_TYPE);
-		eeprom_write_word((uint16_t*)EEPROM_BOARD_TYPE, MOTHERBOARD); 
+		eeprom_write_word_notify((uint16_t*)EEPROM_PRINTER_TYPE, PRINTER_TYPE);
+		eeprom_write_word_notify((uint16_t*)EEPROM_BOARD_TYPE, MOTHERBOARD);
 		break;
 	default: break; //no change, show no message
   }
@@ -1522,7 +1522,7 @@ void setup()
               calibration_status &= ~CALIBRATION_STATUS_SELFTEST;
           }
       }
-      eeprom_update_byte((uint8_t*)EEPROM_CALIBRATION_STATUS_V2, calibration_status);
+      eeprom_update_byte_notify((uint8_t*)EEPROM_CALIBRATION_STATUS_V2, calibration_status);
   }
   if (eeprom_fw_version_older_than_p(FW_VERSION_NR)) {
       if (!calibration_status_get(CALIBRATION_WIZARD_STEPS)) {
@@ -1604,7 +1604,7 @@ void setup()
               if ( btn == LCD_LEFT_BUTTON_CHOICE) {
                   recover_print(0);
             } else { // LCD_MIDDLE_BUTTON_CHOICE
-                  eeprom_update_byte((uint8_t*)EEPROM_UVLO, PowerPanic::NO_PENDING_RECOVERY);
+                  eeprom_update_byte_notify((uint8_t*)EEPROM_UVLO, PowerPanic::NO_PENDING_RECOVERY);
             }
           }
       }
@@ -1628,7 +1628,7 @@ void setup()
 static inline void crash_and_burn(dump_crash_reason reason)
 {
     WRITE(BEEPER, HIGH);
-    eeprom_update_byte((uint8_t*)EEPROM_FW_CRASH_FLAG, (uint8_t)reason);
+    eeprom_update_byte_notify((uint8_t*)EEPROM_FW_CRASH_FLAG, (uint8_t)reason);
 #ifdef EMERGENCY_DUMP
     xfdump_full_dump_and_reset(reason);
 #elif defined(EMERGENCY_SERIAL_DUMP)
@@ -3231,7 +3231,7 @@ bool gcode_M45(bool onlyZ, int8_t verbosity_level)
 			{
 				// Reset the baby step value and the baby step applied flag.
 				calibration_status_clear(CALIBRATION_STATUS_LIVE_ADJUST);
-				eeprom_update_word(reinterpret_cast<uint16_t *>(&(EEPROM_Sheets_base->s[(eeprom_read_byte(&(EEPROM_Sheets_base->active_sheet)))].z_offset)),0);
+				eeprom_update_word_notify(reinterpret_cast<uint16_t *>(&(EEPROM_Sheets_base->s[(eeprom_read_byte(&(EEPROM_Sheets_base->active_sheet)))].z_offset)),0);
 
 				// Complete XYZ calibration.
 				uint8_t point_too_far_mask = 0;
@@ -4129,7 +4129,7 @@ void process_commands()
                 enquecommand_P(MSG_M24);
 
                 // Print is recovered, clear the recovery flag
-                eeprom_update_byte((uint8_t*)EEPROM_UVLO, PowerPanic::NO_PENDING_RECOVERY);
+                eeprom_update_byte_notify((uint8_t*)EEPROM_UVLO, PowerPanic::NO_PENDING_RECOVERY);
             }
             else if (eeprom_read_byte((uint8_t*)EEPROM_UVLO_PRINT_TYPE) == PowerPanic::PRINT_TYPE_HOST)
             {
@@ -4173,7 +4173,7 @@ void process_commands()
 	  lang_reset();
 
 	} else if(code_seen_P(PSTR("Lz"))) { // PRUSA Lz
-      eeprom_update_word(reinterpret_cast<uint16_t *>(&(EEPROM_Sheets_base->s[(eeprom_read_byte(&(EEPROM_Sheets_base->active_sheet)))].z_offset)),0);
+      eeprom_update_word_notify(reinterpret_cast<uint16_t *>(&(EEPROM_Sheets_base->s[(eeprom_read_byte(&(EEPROM_Sheets_base->active_sheet)))].z_offset)),0);
 
     } else if(code_seen_P(PSTR("FR"))) { // PRUSA FR
         // Factory full reset
@@ -4201,8 +4201,8 @@ void process_commands()
                strchr_pointer++;                  // skip 1st char (~ 's')
                strchr_pointer++;                  // skip 2nd char (~ 'e')
                nDiameter=(uint16_t)(code_value()*1000.0+0.5); // [,um]
-               eeprom_update_byte((uint8_t*)EEPROM_NOZZLE_DIAMETER,(uint8_t)ClNozzleDiameter::_Diameter_Undef); // for correct synchronization after farm-mode exiting
-               eeprom_update_word((uint16_t*)EEPROM_NOZZLE_DIAMETER_uM,nDiameter);
+               eeprom_update_byte_notify((uint8_t*)EEPROM_NOZZLE_DIAMETER,(uint8_t)ClNozzleDiameter::_Diameter_Undef); // for correct synchronization after farm-mode exiting
+               eeprom_update_word_notify((uint16_t*)EEPROM_NOZZLE_DIAMETER_uM,nDiameter);
                }
           else SERIAL_PROTOCOLLN((float)eeprom_read_word((uint16_t*)EEPROM_NOZZLE_DIAMETER_uM)/1000.0);
     }
@@ -4759,7 +4759,7 @@ void process_commands()
             serialecho_temperatures();
         }
 
-        eeprom_update_byte((uint8_t*)EEPROM_CALIBRATION_STATUS_PINDA, 0); //invalidate temp. calibration in case that in will be aborted during the calibration process
+        eeprom_update_byte_notify((uint8_t*)EEPROM_CALIBRATION_STATUS_PINDA, 0); //invalidate temp. calibration in case that in will be aborted during the calibration process
 
         current_position[Z_AXIS] = MESH_HOME_Z_SEARCH;
         plan_buffer_line_curposXYZE(3000 / 60);
@@ -4783,7 +4783,7 @@ void process_commands()
             float temp = (40 + i * 5);
             printf_P(_N("\nStep: %d/6 (skipped)\nPINDA temperature: %d Z shift (mm):0\n"), i + 2, (40 + i*5));
             if (i >= 0) {
-                eeprom_update_word((uint16_t*)EEPROM_PROBE_TEMP_SHIFT + i, z_shift);
+                eeprom_update_word_notify((uint16_t*)EEPROM_PROBE_TEMP_SHIFT + i, z_shift);
             }
             if (start_temp <= temp) break;
         }
@@ -4822,7 +4822,7 @@ void process_commands()
 
             printf_P(_N("\nPINDA temperature: %.1f Z shift (mm): %.3f"), current_temperature_pinda, current_position[Z_AXIS] - zero_z);
 
-            eeprom_update_word((uint16_t*)EEPROM_PROBE_TEMP_SHIFT + i, z_shift);
+            eeprom_update_word_notify((uint16_t*)EEPROM_PROBE_TEMP_SHIFT + i, z_shift);
         }
         lcd_temp_cal_show_result(true);
         homing_flag = false;
@@ -4862,7 +4862,7 @@ void process_commands()
 			delay_keep_alive(1000);
 			serialecho_temperatures();
 		}
-		eeprom_update_byte((uint8_t*)EEPROM_CALIBRATION_STATUS_PINDA, 0); //invalidate temp. calibration in case that in will be aborted during the calibration process 
+		eeprom_update_byte_notify((uint8_t*)EEPROM_CALIBRATION_STATUS_PINDA, 0); //invalidate temp. calibration in case that in will be aborted during the calibration process
 
 		current_position[Z_AXIS] = 5;
 		plan_buffer_line_curposXYZE(3000 / 60);
@@ -4907,13 +4907,13 @@ void process_commands()
 
 			printf_P(_N("\nTemperature: %d  Z shift (mm): %.3f\n"), t_c, current_position[Z_AXIS] - zero_z);
 
-			eeprom_update_word((uint16_t*)EEPROM_PROBE_TEMP_SHIFT + i, z_shift);
+			eeprom_update_word_notify((uint16_t*)EEPROM_PROBE_TEMP_SHIFT + i, z_shift);
 			
 		
 		}
 		custom_message_type = CustomMsg::Status;
 
-		eeprom_update_byte((uint8_t*)EEPROM_CALIBRATION_STATUS_PINDA, 1);
+		eeprom_update_byte_notify((uint8_t*)EEPROM_CALIBRATION_STATUS_PINDA, 1);
 		puts_P(_N("Temperature calibration done."));
 			disable_x();
 			disable_y();
@@ -4921,7 +4921,7 @@ void process_commands()
 			disable_e0();
 			setTargetBed(0); //set bed target temperature back to 0
 		lcd_show_fullscreen_message_and_wait_P(_T(MSG_PINDA_CALIBRATION_DONE));
-		eeprom_update_byte((unsigned char *)EEPROM_TEMP_CAL_ACTIVE, 1);
+		eeprom_update_byte_notify((unsigned char *)EEPROM_TEMP_CAL_ACTIVE, 1);
 		lcd_update_enable(true);
 		lcd_update(2);		
 
@@ -5005,7 +5005,7 @@ void process_commands()
                 }else{
                     // Save it to the eeprom
                     babystepLoadZ = babystepz;
-                    eeprom_update_word((uint16_t*)EEPROM_BABYSTEP_Z0 + BabyPosition, babystepLoadZ);
+                    eeprom_update_word_notify((uint16_t*)EEPROM_BABYSTEP_Z0 + BabyPosition, babystepLoadZ);
                     // adjust the Z
                     babystepsTodoZadd(babystepLoadZ);
                 }
@@ -5494,7 +5494,7 @@ void process_commands()
 
         // Reset the baby step value and the baby step applied flag.
         calibration_status_clear(CALIBRATION_STATUS_LIVE_ADJUST);
-        eeprom_update_word(reinterpret_cast<uint16_t *>(&(EEPROM_Sheets_base->s[(eeprom_read_byte(&(EEPROM_Sheets_base->active_sheet)))].z_offset)),0);
+        eeprom_update_word_notify(reinterpret_cast<uint16_t *>(&(EEPROM_Sheets_base->s[(eeprom_read_byte(&(EEPROM_Sheets_base->active_sheet)))].z_offset)),0);
 
         // Reset the skew and offset in both RAM and EEPROM.
         calibration_status_clear(CALIBRATION_STATUS_XYZ);
@@ -7940,7 +7940,7 @@ Sigma_Exit:
 			SERIAL_PROTOCOLLNPGM(" Z VALUE OUT OF RANGE");
 			break;
 		}	
-		eeprom_update_word(reinterpret_cast<uint16_t *>(&(EEPROM_Sheets_base->s[iSel].z_offset)),zraw);
+		eeprom_update_word_notify(reinterpret_cast<uint16_t *>(&(EEPROM_Sheets_base->s[iSel].z_offset)),zraw);
 	}
 	else
 	{
@@ -7956,7 +7956,7 @@ Sigma_Exit:
 		{
 			strncpy(strLabel,src,7);	
 		}
-		eeprom_update_block(strLabel,EEPROM_Sheets_base->s[iSel].name,sizeof(Sheet::name));
+		eeprom_update_block_notify(strLabel,EEPROM_Sheets_base->s[iSel].name,sizeof(Sheet::name));
 	}
 	else
 	{
@@ -7966,7 +7966,7 @@ Sigma_Exit:
 	if (code_seen('B'))
 	{
 		iBedC = code_value_uint8();
-		eeprom_update_byte(&EEPROM_Sheets_base->s[iSel].bed_temp, iBedC);
+		eeprom_update_byte_notify(&EEPROM_Sheets_base->s[iSel].bed_temp, iBedC);
 	}
 	else
 	{
@@ -7976,7 +7976,7 @@ Sigma_Exit:
 	if (code_seen('P'))
 	{
 		iPindaC = code_value_uint8();
-		eeprom_update_byte(&EEPROM_Sheets_base->s[iSel].pinda_temp, iPindaC);
+		eeprom_update_byte_notify(&EEPROM_Sheets_base->s[iSel].pinda_temp, iPindaC);
 	}
 	else
 	{
@@ -7987,7 +7987,7 @@ Sigma_Exit:
 	{
 		bIsActive |= code_value_uint8() || (eeprom_read_byte(&(EEPROM_Sheets_base->active_sheet)) == iSel);
 		if(bIsActive && eeprom_is_sheet_initialized(iSel)) {
-            eeprom_update_byte(&EEPROM_Sheets_base->active_sheet, iSel);
+            eeprom_update_byte_notify(&EEPROM_Sheets_base->active_sheet, iSel);
         } else {
             bIsActive = 0;
         }
@@ -8092,24 +8092,24 @@ Sigma_Exit:
 			gcode_M861_print_pinda_cal_eeprom();
 		}
 		else if (code_seen('!')) { // ! - Set factory default values
-			eeprom_write_byte((uint8_t*)EEPROM_CALIBRATION_STATUS_PINDA, 1);
+			eeprom_update_byte_notify((uint8_t*)EEPROM_CALIBRATION_STATUS_PINDA, 1);
 			int16_t z_shift = 8;    //40C -  20um -   8usteps
-			eeprom_update_word((uint16_t*)EEPROM_PROBE_TEMP_SHIFT, z_shift);
+			eeprom_update_word_notify((uint16_t*)EEPROM_PROBE_TEMP_SHIFT, z_shift);
 			z_shift = 24;   //45C -  60um -  24usteps
-			eeprom_update_word((uint16_t*)EEPROM_PROBE_TEMP_SHIFT + 1, z_shift);
+			eeprom_update_word_notify((uint16_t*)EEPROM_PROBE_TEMP_SHIFT + 1, z_shift);
 			z_shift = 48;   //50C - 120um -  48usteps
-			eeprom_update_word((uint16_t*)EEPROM_PROBE_TEMP_SHIFT + 2, z_shift);
+			eeprom_update_word_notify((uint16_t*)EEPROM_PROBE_TEMP_SHIFT + 2, z_shift);
 			z_shift = 80;   //55C - 200um -  80usteps
-			eeprom_update_word((uint16_t*)EEPROM_PROBE_TEMP_SHIFT + 3, z_shift);
+			eeprom_update_word_notify((uint16_t*)EEPROM_PROBE_TEMP_SHIFT + 3, z_shift);
 			z_shift = 120;  //60C - 300um - 120usteps
-			eeprom_update_word((uint16_t*)EEPROM_PROBE_TEMP_SHIFT + 4, z_shift);
+			eeprom_update_word_notify((uint16_t*)EEPROM_PROBE_TEMP_SHIFT + 4, z_shift);
 			SERIAL_PROTOCOLLNPGM("factory restored");
 		}
 		else if (code_seen('Z')) { // Z - Set all values to 0 (effectively disabling PINDA temperature compensation)
-			eeprom_write_byte((uint8_t*)EEPROM_CALIBRATION_STATUS_PINDA, 1);
+			eeprom_update_byte_notify((uint8_t*)EEPROM_CALIBRATION_STATUS_PINDA, 1);
 			int16_t z_shift = 0;
 			for (uint8_t i = 0; i < 5; i++) {
-				eeprom_update_word((uint16_t*)EEPROM_PROBE_TEMP_SHIFT + i, z_shift);
+				eeprom_update_word_notify((uint16_t*)EEPROM_PROBE_TEMP_SHIFT + i, z_shift);
 			}
 			SERIAL_PROTOCOLLNPGM("zerorized");
 		}
@@ -8118,7 +8118,7 @@ Sigma_Exit:
 			if (code_seen('I')) {
 			    uint8_t index = code_value_uint8();
 				if (index < 5) {
-					eeprom_update_word((uint16_t*)EEPROM_PROBE_TEMP_SHIFT + index, usteps);
+					eeprom_update_word_notify((uint16_t*)EEPROM_PROBE_TEMP_SHIFT + index, usteps);
 					SERIAL_PROTOCOLLNRPGM(MSG_OK);
 					SERIAL_PROTOCOLLNRPGM(_header);
 					gcode_M861_print_pinda_cal_eeprom();
@@ -8439,7 +8439,7 @@ Sigma_Exit:
     else if (code_seen('P'))
     {
         uint8_t newMenuMode = (mcode_in_progress==914) ? SILENT_MODE_NORMAL : SILENT_MODE_STEALTH;
-        eeprom_update_byte((unsigned char *)EEPROM_SILENT, newMenuMode);
+        eeprom_update_byte_notify((unsigned char *)EEPROM_SILENT, newMenuMode);
         SilentModeMenu = newMenuMode;
         //printf_P(_n("tmc2130mode/smm/eep: %d %d %d %d"),tmc2130_mode,SilentModeMenu,eeprom_read_byte((uint8_t*)EEPROM_SILENT), bEnableForce_z);
     }
@@ -8854,11 +8854,11 @@ Sigma_Exit:
             switch (code_value_uint8())
             {
             case 0:
-                eeprom_update_byte((uint8_t *)EEPROM_MMU_ENABLED, false);
+                eeprom_update_byte_notify((uint8_t *)EEPROM_MMU_ENABLED, false);
                 MMU2::mmu2.Stop();
                 break;
             case 1:
-                eeprom_update_byte((uint8_t *)EEPROM_MMU_ENABLED, true);
+                eeprom_update_byte_notify((uint8_t *)EEPROM_MMU_ENABLED, true);
                 MMU2::mmu2.Start();
                 break;
             default:
@@ -9736,8 +9736,8 @@ void kill(const char *full_screen_message) {
     }
 
     // update eeprom with the correct kill message to be shown on startup
-    eeprom_write_word((uint16_t*)EEPROM_KILL_MESSAGE, (uint16_t)full_screen_message);
-    eeprom_write_byte((uint8_t*)EEPROM_KILL_PENDING_FLAG, KILL_PENDING_FLAG);
+    eeprom_write_word_notify((uint16_t*)EEPROM_KILL_MESSAGE, (uint16_t)full_screen_message);
+    eeprom_write_byte_notify((uint8_t*)EEPROM_KILL_PENDING_FLAG, KILL_PENDING_FLAG);
 
     softReset();
 }
@@ -9949,8 +9949,8 @@ void save_statistics() {
     uint32_t _previous_time = eeprom_init_default_dword((uint32_t *)EEPROM_TOTALTIME, 0);        //_previous_time unit: min
 
     uint32_t time_minutes = print_job_timer.duration() / 60;
-    eeprom_update_dword((uint32_t *)EEPROM_TOTALTIME, _previous_time + time_minutes); // EEPROM_TOTALTIME unit: min
-    eeprom_update_dword((uint32_t *)EEPROM_FILAMENTUSED, _previous_filament + (total_filament_used / 1000));
+    eeprom_update_dword_notify((uint32_t *)EEPROM_TOTALTIME, _previous_time + time_minutes); // EEPROM_TOTALTIME unit: min
+    eeprom_update_dword_notify((uint32_t *)EEPROM_FILAMENTUSED, _previous_filament + (total_filament_used / 1000));
 
     print_job_timer.reset();
     total_filament_used = 0;
@@ -10070,7 +10070,7 @@ void check_babystep()
 	if ((babystep_z < Z_BABYSTEP_MIN) || (babystep_z > Z_BABYSTEP_MAX)) {
 		babystep_z = 0; //if babystep value is out of min max range, set it to 0
 		SERIAL_ECHOLNPGM("Z live adjust out of range. Setting to 0");
-		eeprom_write_word(reinterpret_cast<uint16_t *>(&(EEPROM_Sheets_base->
+		eeprom_write_word_notify(reinterpret_cast<uint16_t *>(&(EEPROM_Sheets_base->
             s[(eeprom_read_byte(&(EEPROM_Sheets_base->active_sheet)))].z_offset)),
                     babystep_z);
 		lcd_show_fullscreen_message_and_wait_P(PSTR("Z live adjust out of range. Setting to 0. Click to continue."));
@@ -11034,7 +11034,7 @@ void restore_print_from_ram_and_continue(float e_move)
 // Cancel the state related to a currently saved print
 void cancel_saved_printing()
 {
-    eeprom_update_byte((uint8_t*)EEPROM_UVLO, PowerPanic::NO_PENDING_RECOVERY);
+    eeprom_update_byte_notify((uint8_t*)EEPROM_UVLO, PowerPanic::NO_PENDING_RECOVERY);
     saved_start_position[0] = SAVED_START_POSITION_UNSET;
     saved_printing_type = PowerPanic::PRINT_TYPE_NONE;
     saved_printing = false;
diff --git a/Firmware/Prusa_farm.cpp b/Firmware/Prusa_farm.cpp
index d1641b351..b037724f6 100644
--- a/Firmware/Prusa_farm.cpp
+++ b/Firmware/Prusa_farm.cpp
@@ -403,7 +403,7 @@ void farm_mode_init() {
         fsensor.setAutoLoadEnabled(false);
 #endif //FILAMENT_SENSOR
         // ~ FanCheck -> on
-        eeprom_update_byte((uint8_t*)EEPROM_FAN_CHECK_ENABLED, true);
+        eeprom_update_byte_notify((uint8_t*)EEPROM_FAN_CHECK_ENABLED, true);
     }
 }
 
@@ -447,9 +447,9 @@ bool farm_prusa_code_seen() {
 
 void farm_gcode_g98() {
     farm_mode = 1;
-    eeprom_update_byte((unsigned char *)EEPROM_FARM_MODE, farm_mode);
+    eeprom_update_byte_notify((unsigned char *)EEPROM_FARM_MODE, farm_mode);
     SilentModeMenu = SILENT_MODE_OFF;
-    eeprom_update_byte((unsigned char *)EEPROM_SILENT, SilentModeMenu);
+    eeprom_update_byte_notify((unsigned char *)EEPROM_SILENT, SilentModeMenu);
     fCheckModeInit(); // alternatively invoke printer reset
 }
 
@@ -461,7 +461,7 @@ void farm_gcode_g99() {
 
 void farm_disable() {
     farm_mode = false;
-    eeprom_update_byte((uint8_t*)EEPROM_FARM_MODE, farm_mode);
+    eeprom_update_byte_notify((uint8_t*)EEPROM_FARM_MODE, farm_mode);
 }
 
 #else //PRUSA_FARM
diff --git a/Firmware/SpoolJoin.cpp b/Firmware/SpoolJoin.cpp
index 3944af9e3..e22595d15 100644
--- a/Firmware/SpoolJoin.cpp
+++ b/Firmware/SpoolJoin.cpp
@@ -30,9 +30,9 @@ void SpoolJoin::toggleSpoolJoin()
 {
     if (eeprom_read_byte((uint8_t*)EEPROM_SPOOL_JOIN) == (uint8_t)EEPROM::Disabled)
     {
-        eeprom_write_byte((uint8_t*)EEPROM_SPOOL_JOIN, (uint8_t)EEPROM::Enabled);
+        eeprom_update_byte_notify((uint8_t*)EEPROM_SPOOL_JOIN, (uint8_t)EEPROM::Enabled);
     } else {
-        eeprom_write_byte((uint8_t*)EEPROM_SPOOL_JOIN, (uint8_t)EEPROM::Disabled);
+        eeprom_update_byte_notify((uint8_t*)EEPROM_SPOOL_JOIN, (uint8_t)EEPROM::Disabled);
     }
 }
 
diff --git a/Firmware/backlight.cpp b/Firmware/backlight.cpp
index f5fccf046..ad8271ee0 100644
--- a/Firmware/backlight.cpp
+++ b/Firmware/backlight.cpp
@@ -62,10 +62,10 @@ void backlight_wake(const uint8_t flashNo)
 
 void backlight_save() //saves all backlight data to eeprom.
 {
-    eeprom_update_byte((uint8_t *)EEPROM_BACKLIGHT_LEVEL_HIGH, backlightLevel_HIGH);
-    eeprom_update_byte((uint8_t *)EEPROM_BACKLIGHT_LEVEL_LOW, backlightLevel_LOW);
-    eeprom_update_byte((uint8_t *)EEPROM_BACKLIGHT_MODE, backlightMode);
-    eeprom_update_word((uint16_t *)EEPROM_BACKLIGHT_TIMEOUT, backlightTimer_period);
+    eeprom_update_byte_notify((uint8_t *)EEPROM_BACKLIGHT_LEVEL_HIGH, backlightLevel_HIGH);
+    eeprom_update_byte_notify((uint8_t *)EEPROM_BACKLIGHT_LEVEL_LOW, backlightLevel_LOW);
+    eeprom_update_byte_notify((uint8_t *)EEPROM_BACKLIGHT_MODE, backlightMode);
+    eeprom_update_word_notify((uint16_t *)EEPROM_BACKLIGHT_TIMEOUT, backlightTimer_period);
 }
 
 void backlight_update()
diff --git a/Firmware/cmdqueue.cpp b/Firmware/cmdqueue.cpp
index b7877721e..016ae0267 100755
--- a/Firmware/cmdqueue.cpp
+++ b/Firmware/cmdqueue.cpp
@@ -484,7 +484,7 @@ void get_command()
         if ((*cmd_start == 'G') && (GetPrinterState() != PrinterState::IsSDPrinting)) {
             usb_timer.start();
             SetPrinterState(PrinterState::IsHostPrinting); //set printer state busy printing to hide LCD menu while USB printing
-            eeprom_update_byte((uint8_t*)EEPROM_UVLO, PowerPanic::NO_PENDING_RECOVERY);
+            eeprom_update_byte_notify((uint8_t*)EEPROM_UVLO, PowerPanic::NO_PENDING_RECOVERY);
         }
         if (allow_when_stopped == false && Stopped == true) {
             // Stopped can be set either during error states (thermal error: cannot continue), or
diff --git a/Firmware/eeprom.cpp b/Firmware/eeprom.cpp
index 4625c2503..30a8b88ea 100644
--- a/Firmware/eeprom.cpp
+++ b/Firmware/eeprom.cpp
@@ -26,7 +26,7 @@ void eeprom_init()
     eeprom_init_default_dword((uint32_t*)EEPROM_MMU_MATERIAL_CHANGES, 0);
     if (eeprom_read_byte(&(EEPROM_Sheets_base->active_sheet)) == EEPROM_EMPTY_VALUE)
     {
-        eeprom_update_byte(&(EEPROM_Sheets_base->active_sheet), 0);
+        eeprom_update_byte_notify(&(EEPROM_Sheets_base->active_sheet), 0);
         // When upgrading from version older version (before multiple sheets were implemented in v3.8.0)
         // Sheet 1 uses the previous Live adjust Z (@EEPROM_BABYSTEP_Z)
         int last_babystep = eeprom_read_word((uint16_t *)EEPROM_BABYSTEP_Z);
@@ -49,7 +49,7 @@ void eeprom_init()
     // initialize custom mendel name in eeprom
     if (eeprom_read_byte((uint8_t*)EEPROM_CUSTOM_MENDEL_NAME) == EEPROM_EMPTY_VALUE) {
         //SERIAL_ECHOLN("Init Custom Mendel Name");
-        eeprom_update_block(CUSTOM_MENDEL_NAME, (uint8_t*)EEPROM_CUSTOM_MENDEL_NAME, sizeof(CUSTOM_MENDEL_NAME));
+        eeprom_update_block_notify(CUSTOM_MENDEL_NAME, (uint8_t*)EEPROM_CUSTOM_MENDEL_NAME, sizeof(CUSTOM_MENDEL_NAME));
     } //else SERIAL_ECHOLN("Found Custom Mendel Name");
 
 #ifdef PINDA_TEMP_COMP
@@ -66,11 +66,11 @@ void eeprom_init()
 }
 
 void eeprom_adjust_bed_reset() {
-    eeprom_update_byte((uint8_t*)EEPROM_BED_CORRECTION_VALID, 1);
-    eeprom_update_byte((uint8_t*)EEPROM_BED_CORRECTION_LEFT, 0);
-    eeprom_update_byte((uint8_t*)EEPROM_BED_CORRECTION_RIGHT, 0);
-    eeprom_update_byte((uint8_t*)EEPROM_BED_CORRECTION_FRONT, 0);
-    eeprom_update_byte((uint8_t*)EEPROM_BED_CORRECTION_REAR, 0);
+    eeprom_update_byte_notify((uint8_t*)EEPROM_BED_CORRECTION_VALID, 1);
+    eeprom_update_byte_notify((uint8_t*)EEPROM_BED_CORRECTION_LEFT, 0);
+    eeprom_update_byte_notify((uint8_t*)EEPROM_BED_CORRECTION_RIGHT, 0);
+    eeprom_update_byte_notify((uint8_t*)EEPROM_BED_CORRECTION_FRONT, 0);
+    eeprom_update_byte_notify((uint8_t*)EEPROM_BED_CORRECTION_REAR, 0);
 }
 
 //! @brief Get default sheet name for index
@@ -137,12 +137,175 @@ int8_t eeprom_next_initialized_sheet(int8_t sheet)
     return -1;
 }
 
+#ifdef DEBUG_EEPROM_CHANGES
+static void eeprom_byte_notify(uint8_t *dst, uint8_t previous_value, uint8_t value, bool write) {
+    printf_P(PSTR("EEPROMChng b %s %u %d -> %d\n"), write ? "write":"", dst , previous_value, value);
+}
+
+static void eeprom_word_notify(uint16_t *dst, uint16_t previous_value, uint16_t value, bool write) {
+    printf_P(PSTR("EEPROMChng w %s %u %u -> %u\n"), write ? "write":"", dst , previous_value, value);
+}
+
+static void eeprom_dword_notify(uint32_t *dst, uint32_t previous_value, uint32_t value, bool write) {
+    printf_P(PSTR("EEPROMChng d %s %u %x -> %x\n"), write ? "write":"", reinterpret_cast<const uint16_t>(dst) , previous_value, value);
+}
+
+static void eeprom_float_notify(float *dst, float previous_value, float value, bool write) {
+    printf_P(PSTR("EEPROMChng f %s %u %f -> %f\n"), write ? "write":"", reinterpret_cast<const uint16_t>(dst) , previous_value, value);
+}
+
+static void eeprom_block_notify(void *dst, const uint8_t *previous_values, const uint8_t *values, size_t size, bool write) {
+    for(size_t i = 0; i < size; ++i){
+        if (previous_values[i] != values[i] || write) {
+            printf_P(PSTR("EEPROMChng bl %s %u %x -> %x\n"), write ? "write":"", reinterpret_cast<const uint16_t>(dst) + i, previous_values[i], values[i]);
+        }
+    }
+}
+#endif //DEBUG_EEPROM_CHANGES
+
+#ifndef DEBUG_EEPROM_CHANGES
+void eeprom_write_byte_notify(uint8_t *dst, uint8_t value){
+#else
+void eeprom_write_byte_notify(uint8_t *dst, uint8_t value, bool active){
+    if (active) {
+        uint8_t previous_value = eeprom_read_byte(dst);
+        eeprom_byte_notify(dst, previous_value, value, true);
+    }
+#endif //DEBUG_EEPROM_CHANGES
+    eeprom_write_byte(dst, value);
+}
+
+#ifndef DEBUG_EEPROM_CHANGES
+void eeprom_update_byte_notify(uint8_t *dst, uint8_t value){
+#else
+void eeprom_update_byte_notify(uint8_t *dst, uint8_t value, bool active){
+
+    if (active) {
+        uint8_t previous_value = eeprom_read_byte(dst);
+        if (previous_value != value) {
+            eeprom_byte_notify(dst, previous_value, value, false);
+        }
+    }
+#endif //DEBUG_EEPROM_CHANGES
+    eeprom_update_byte(dst, value);
+}
+
+#ifndef DEBUG_EEPROM_CHANGES
+void eeprom_write_word_notify(uint16_t *dst, uint16_t value){
+#else
+void eeprom_write_word_notify(uint16_t *dst, uint16_t value, bool active){
+    if (active) {
+        uint16_t previous_value = eeprom_read_word(dst);
+        eeprom_word_notify(dst, previous_value, value, true);
+    }
+#endif //DEBUG_EEPROM_CHANGES
+    eeprom_write_word(dst, value);
+}
+
+#ifndef DEBUG_EEPROM_CHANGES
+void eeprom_update_word_notify(uint16_t *dst, uint16_t value){
+#else
+void eeprom_update_word_notify(uint16_t *dst, uint16_t value, bool active){
+    if (active) {
+        uint16_t previous_value = eeprom_read_word(dst);
+        if (previous_value != value) {
+            eeprom_word_notify(dst, previous_value, value, false);
+        }
+    }
+#endif //DEBUG_EEPROM_CHANGES
+    eeprom_update_word(dst, value);
+}
+
+#ifndef DEBUG_EEPROM_CHANGES
+void eeprom_write_dword_notify(uint32_t *dst, uint32_t value){
+#else
+void eeprom_write_dword_notify(uint32_t *dst, uint32_t value, bool active){
+    if (active) {
+        uint32_t previous_value = eeprom_read_dword(dst);
+        eeprom_dword_notify(dst, previous_value, value, true);
+    }
+#endif //DEBUG_EEPROM_CHANGES
+    eeprom_write_dword(dst, value);
+}
+
+#ifndef DEBUG_EEPROM_CHANGES
+void eeprom_update_dword_notify(uint32_t *dst, uint32_t value){
+#else
+void eeprom_update_dword_notify(uint32_t *dst, uint32_t value, bool active){
+    if (active) {
+        uint32_t previous_value = eeprom_read_dword(dst);
+        if (previous_value != value) {
+            eeprom_dword_notify(dst, previous_value, value, false);
+        }
+    }
+#endif //DEBUG_EEPROM_CHANGES
+    eeprom_update_dword(dst, value);
+}
+
+#ifndef DEBUG_EEPROM_CHANGES
+void eeprom_write_float_notify(float *dst, float value){
+#else
+void eeprom_write_float_notify(float *dst, float value, bool active){
+    if (active) {
+        float previous_value = eeprom_read_float(dst);
+        eeprom_float_notify(dst, previous_value, value, true);
+    }
+#endif //DEBUG_EEPROM_CHANGES
+    eeprom_write_float(dst, value);
+}
+
+#ifndef DEBUG_EEPROM_CHANGES
+void eeprom_update_float_notify(float *dst, float value){
+#else
+void eeprom_update_float_notify(float *dst, float value, bool active){
+    if (active) {
+        float previous_value = eeprom_read_float(dst);
+        if (previous_value != value) {
+            eeprom_float_notify(dst, previous_value, value, false);
+        }
+    }
+#endif //DEBUG_EEPROM_CHANGES
+    eeprom_update_float(dst, value);
+}
+
+#ifndef DEBUG_EEPROM_CHANGES
+void eeprom_write_block_notify(const void *__src, void *__dst, size_t __n){
+    eeprom_write_block(__src, __dst, __n);
+#else
+void eeprom_write_block_notify(const void *__src, void *__dst, size_t __n, bool active){
+    if (active) {
+        uint8_t previous_values[__n];
+        uint8_t new_values[__n];
+        eeprom_read_block(previous_values, __dst, __n);
+        eeprom_write_block(__src, __dst, __n);
+        eeprom_read_block(new_values, __dst, __n);
+        eeprom_block_notify(__dst, previous_values, new_values, __n, true);
+    }
+#endif //DEBUG_EEPROM_CHANGES
+}
+
+#ifndef DEBUG_EEPROM_CHANGES
+void eeprom_update_block_notify(const void *__src, void *__dst, size_t __n){
+    eeprom_update_block(__src, __dst, __n);
+#else
+void eeprom_update_block_notify(const void *__src, void *__dst, size_t __n, bool active){
+    if (active) {
+        uint8_t previous_values[__n];
+        uint8_t new_values[__n];
+        eeprom_read_block(previous_values, __dst, __n);
+        eeprom_update_block(__src, __dst, __n);
+        eeprom_read_block(new_values, __dst, __n);
+        eeprom_block_notify(__dst, previous_values, new_values, __n, false);
+    }
+#endif //DEBUG_EEPROM_CHANGES
+}
+
 void eeprom_switch_to_next_sheet()
 {
     int8_t sheet = eeprom_read_byte(&(EEPROM_Sheets_base->active_sheet));
 
     sheet = eeprom_next_initialized_sheet(sheet);
-    if (sheet >= 0) eeprom_update_byte(&(EEPROM_Sheets_base->active_sheet), sheet);
+    if (sheet >= 0) eeprom_update_byte_notify(&(EEPROM_Sheets_base->active_sheet), sheet);
 }
 
 bool __attribute__((noinline)) eeprom_is_sheet_initialized(uint8_t sheet_num) {
@@ -163,44 +326,44 @@ void eeprom_update_block_P(const void *__src, void *__dst, size_t __n) {
     const uint8_t *src = (const uint8_t*)__src;
     uint8_t *dst = (uint8_t*)__dst;
     while (__n--) {
-        eeprom_update_byte(dst++, pgm_read_byte(src++));
+        eeprom_update_byte_notify(dst++, pgm_read_byte(src++));
     }
 }
 
 void eeprom_toggle(uint8_t *__p) {
-    eeprom_write_byte(__p, !eeprom_read_byte(__p));
+    eeprom_write_byte_notify(__p, !eeprom_read_byte(__p));
 }
 
 void __attribute__((noinline)) eeprom_increment_byte(uint8_t *__p) {
-    eeprom_write_byte(__p, eeprom_read_byte(__p) + 1);
+    eeprom_write_byte_notify(__p, eeprom_read_byte(__p) + 1);
 }
 
 void __attribute__((noinline)) eeprom_increment_word(uint16_t *__p) {
-    eeprom_write_word(__p, eeprom_read_word(__p) + 1);
+    eeprom_write_word_notify(__p, eeprom_read_word(__p) + 1);
 }
 
 void __attribute__((noinline)) eeprom_increment_dword(uint32_t *__p) {
-    eeprom_write_dword(__p, eeprom_read_dword(__p) + 1);
+    eeprom_write_dword_notify(__p, eeprom_read_dword(__p) + 1);
 }
 
 
 void __attribute__((noinline)) eeprom_add_byte(uint8_t *__p, uint8_t add) {
-    eeprom_write_byte(__p, eeprom_read_byte(__p) + add);
+    eeprom_write_byte_notify(__p, eeprom_read_byte(__p) + add);
 }
 
 void __attribute__((noinline)) eeprom_add_word(uint16_t *__p, uint16_t add) {
-    eeprom_write_word(__p, eeprom_read_word(__p) + add);
+    eeprom_write_word_notify(__p, eeprom_read_word(__p) + add);
 }
 
 void __attribute__((noinline)) eeprom_add_dword(uint32_t *__p, uint32_t add) {
-    eeprom_write_dword(__p, eeprom_read_dword(__p) + add);
+    eeprom_write_dword_notify(__p, eeprom_read_dword(__p) + add);
 }
 
 
 uint8_t __attribute__((noinline)) eeprom_init_default_byte(uint8_t *__p, uint8_t def) {
     uint8_t val = eeprom_read_byte(__p);
     if (val == EEPROM_EMPTY_VALUE) {
-        eeprom_write_byte(__p, def);
+        eeprom_write_byte_notify(__p, def);
         return def;
     }
     return val;
@@ -209,7 +372,7 @@ uint8_t __attribute__((noinline)) eeprom_init_default_byte(uint8_t *__p, uint8_t
 uint16_t __attribute__((noinline)) eeprom_init_default_word(uint16_t *__p, uint16_t def) {
     uint16_t val = eeprom_read_word(__p);
     if (val == EEPROM_EMPTY_VALUE16) {
-        eeprom_write_word(__p, def);
+        eeprom_write_word_notify(__p, def);
         return def;
     }
     return val;
@@ -218,7 +381,7 @@ uint16_t __attribute__((noinline)) eeprom_init_default_word(uint16_t *__p, uint1
 uint32_t __attribute__((noinline)) eeprom_init_default_dword(uint32_t *__p, uint32_t def) {
     uint32_t val = eeprom_read_dword(__p);
     if (val == EEPROM_EMPTY_VALUE32) {
-        eeprom_write_dword(__p, def);
+        eeprom_write_dword_notify(__p, def);
         return def;
     }
     return val;
@@ -226,12 +389,12 @@ uint32_t __attribute__((noinline)) eeprom_init_default_dword(uint32_t *__p, uint
 
 void __attribute__((noinline)) eeprom_init_default_float(float *__p, float def) {
     if (eeprom_read_dword((uint32_t*)__p) == EEPROM_EMPTY_VALUE32)
-        eeprom_write_float(__p, def);
+        eeprom_write_float_notify(__p, def);
 }
 
 void __attribute__((noinline)) eeprom_init_default_block(void *__p, size_t __n, const void *def) {
     if (!eeprom_is_initialized_block(__p, __n))
-        eeprom_update_block(def, __p, __n);
+        eeprom_update_block_notify(def, __p, __n);
 }
 
 void __attribute__((noinline)) eeprom_init_default_block_P(void *__p, size_t __n, const void *def) {
diff --git a/Firmware/eeprom.h b/Firmware/eeprom.h
index 102213096..d965bcb76 100644
--- a/Firmware/eeprom.h
+++ b/Firmware/eeprom.h
@@ -684,6 +684,30 @@ uint32_t eeprom_init_default_dword(uint32_t *__p, uint32_t def);
 void eeprom_init_default_float(float *__p, float def);
 void eeprom_init_default_block(void *__p, size_t __n, const void *def);
 void eeprom_init_default_block_P(void *__p, size_t __n, const void *def);
+/// Updates eeprom byte and notifies the changed eeprom address (just the address!) onto the serial line
+#ifndef DEBUG_EEPROM_CHANGES
+void eeprom_write_byte_notify(uint8_t *dst, uint8_t value);
+void eeprom_update_byte_notify(uint8_t *dst, uint8_t value);
+void eeprom_write_word_notify(uint16_t *dst, uint16_t value);
+void eeprom_update_word_notify(uint16_t *dst, uint16_t value);
+void eeprom_write_dword_notify(uint32_t *dst, uint32_t value);
+void eeprom_update_dword_notify(uint32_t *dst, uint32_t value);
+void eeprom_write_float_notify(float *dst, float value);
+void eeprom_update_float_notify(float *dst, float value);
+void eeprom_write_block_notify(const void *__src, void *__dst , size_t __size);
+void eeprom_update_block_notify(const void *__src, void *__dst, size_t __size);
+#else
+void eeprom_write_byte_notify(uint8_t *dst, uint8_t value, bool active = true);
+void eeprom_update_byte_notify(uint8_t *dst, uint8_t value, bool active = true);
+void eeprom_write_word_notify(uint16_t *dst, uint16_t value, bool active = true);
+void eeprom_update_word_notify(uint16_t *dst, uint16_t value, bool active = true);
+void eeprom_write_dword_notify(uint32_t *dst, uint32_t value, bool active = true);
+void eeprom_update_dword_notify(uint32_t *dst, uint32_t value, bool active = true);
+void eeprom_write_float_notify(float *dst, float value, bool active = true);
+void eeprom_update_float_notify(float *dst, float value, bool active = true);
+void eeprom_write_block_notify(const void *__src, void *__dst , size_t __size, bool active = true);
+void eeprom_update_block_notify(const void *__src, void *__dst, size_t __size , bool active = true);
+#endif //DEBUG_EEPROM_CHANGES
 #endif
 
 #endif // EEPROM_H
diff --git a/Firmware/fancheck.cpp b/Firmware/fancheck.cpp
index a8b0b3dba..d207eff49 100755
--- a/Firmware/fancheck.cpp
+++ b/Firmware/fancheck.cpp
@@ -238,7 +238,7 @@ bool extruder_altfan_detect()
 void altfanOverride_toggle()
 {
     altfanStatus.altfanOverride = !altfanStatus.altfanOverride;
-    eeprom_update_byte((uint8_t *)EEPROM_ALTFAN_OVERRIDE, altfanStatus.altfanOverride);
+    eeprom_update_byte_notify((uint8_t *)EEPROM_ALTFAN_OVERRIDE, altfanStatus.altfanOverride);
 }
 
 bool altfanOverride_get()
diff --git a/Firmware/mesh_bed_calibration.cpp b/Firmware/mesh_bed_calibration.cpp
index b1ded7247..a0210ccc1 100644
--- a/Firmware/mesh_bed_calibration.cpp
+++ b/Firmware/mesh_bed_calibration.cpp
@@ -373,7 +373,7 @@ BedSkewOffsetDetectionResultType calculate_machine_skew_and_offset_LS(
         angleDiff = fabs(a2 - a1);
         /// XY skew and Y-bed skew
         DBG(_n("Measured skews: %f %f\n"), degrees(a2 - a1), degrees(a2));
-        eeprom_update_float((float *)(EEPROM_XYZ_CAL_SKEW), angleDiff); //storing xyz cal. skew to be able to show in support menu later
+        eeprom_update_float_notify((float *)(EEPROM_XYZ_CAL_SKEW), angleDiff); //storing xyz cal. skew to be able to show in support menu later
         if (angleDiff > bed_skew_angle_mild)
             result = (angleDiff > bed_skew_angle_extreme) ?
                 BED_SKEW_OFFSET_DETECTION_SKEW_EXTREME :
@@ -669,16 +669,16 @@ BedSkewOffsetDetectionResultType calculate_machine_skew_and_offset_LS(
  */
 void reset_bed_offset_and_skew()
 {
-    eeprom_update_dword((uint32_t*)(EEPROM_BED_CALIBRATION_CENTER+0), 0x0FFFFFFFF);
-    eeprom_update_dword((uint32_t*)(EEPROM_BED_CALIBRATION_CENTER+4), 0x0FFFFFFFF);
-    eeprom_update_dword((uint32_t*)(EEPROM_BED_CALIBRATION_VEC_X +0), 0x0FFFFFFFF);
-    eeprom_update_dword((uint32_t*)(EEPROM_BED_CALIBRATION_VEC_X +4), 0x0FFFFFFFF);
-    eeprom_update_dword((uint32_t*)(EEPROM_BED_CALIBRATION_VEC_Y +0), 0x0FFFFFFFF);
-    eeprom_update_dword((uint32_t*)(EEPROM_BED_CALIBRATION_VEC_Y +4), 0x0FFFFFFFF);
+    eeprom_update_dword_notify((uint32_t*)(EEPROM_BED_CALIBRATION_CENTER+0), 0x0FFFFFFFF);
+    eeprom_update_dword_notify((uint32_t*)(EEPROM_BED_CALIBRATION_CENTER+4), 0x0FFFFFFFF);
+    eeprom_update_dword_notify((uint32_t*)(EEPROM_BED_CALIBRATION_VEC_X +0), 0x0FFFFFFFF);
+    eeprom_update_dword_notify((uint32_t*)(EEPROM_BED_CALIBRATION_VEC_X +4), 0x0FFFFFFFF);
+    eeprom_update_dword_notify((uint32_t*)(EEPROM_BED_CALIBRATION_VEC_Y +0), 0x0FFFFFFFF);
+    eeprom_update_dword_notify((uint32_t*)(EEPROM_BED_CALIBRATION_VEC_Y +4), 0x0FFFFFFFF);
 
     // Reset the 8 16bit offsets.
     for (int8_t i = 0; i < 4; ++ i)
-        eeprom_update_dword((uint32_t*)(EEPROM_BED_CALIBRATION_Z_JITTER+i*4), 0x0FFFFFFFF);
+        eeprom_update_dword_notify((uint32_t*)(EEPROM_BED_CALIBRATION_Z_JITTER+i*4), 0x0FFFFFFFF);
 }
 
 bool is_bed_z_jitter_data_valid()
@@ -2443,9 +2443,9 @@ BedSkewOffsetDetectionResultType find_bed_offset_and_skew(int8_t verbosity_level
 			world2machine_update(vec_x, vec_y, cntr);
 
 			// Fearlessly store the calibration values into the eeprom.
-			eeprom_update_block(&cntr[0], (float*)(EEPROM_BED_CALIBRATION_CENTER), 8);
-			eeprom_update_block(&vec_x[0], (float*)(EEPROM_BED_CALIBRATION_VEC_X), 8);
-			eeprom_update_block(&vec_y[0], (float*)(EEPROM_BED_CALIBRATION_VEC_Y), 8);
+			eeprom_update_block_notify(&cntr[0], (float*)(EEPROM_BED_CALIBRATION_CENTER), 8);
+			eeprom_update_block_notify(&vec_x[0], (float*)(EEPROM_BED_CALIBRATION_VEC_X), 8);
+			eeprom_update_block_notify(&vec_y[0], (float*)(EEPROM_BED_CALIBRATION_VEC_Y), 8);
 
 			#ifdef SUPPORT_VERBOSITY
 			if (verbosity_level >= 10) {
@@ -2731,9 +2731,9 @@ BedSkewOffsetDetectionResultType improve_bed_offset_and_skew(int8_t method, int8
     world2machine_update(vec_x, vec_y, cntr);
 
     // Fearlessly store the calibration values into the eeprom.
-    eeprom_update_block(&cntr[0], (float*)(EEPROM_BED_CALIBRATION_CENTER), 8);
-    eeprom_update_block(&vec_x[0], (float*)(EEPROM_BED_CALIBRATION_VEC_X), 8);
-    eeprom_update_block(&vec_y[0], (float*)(EEPROM_BED_CALIBRATION_VEC_Y), 8);
+    eeprom_update_block_notify(&cntr[0], (float*)(EEPROM_BED_CALIBRATION_CENTER), 8);
+    eeprom_update_block_notify(&vec_x[0], (float*)(EEPROM_BED_CALIBRATION_VEC_X), 8);
+    eeprom_update_block_notify(&vec_y[0], (float*)(EEPROM_BED_CALIBRATION_VEC_Y), 8);
 
     // Correct the current_position to match the transformed coordinate system after world2machine_rotation_and_skew and world2machine_shift were set.
 	world2machine_update_current();
@@ -2934,7 +2934,7 @@ bool sample_mesh_and_store_reference()
                     continue;
                 float dif = mbl.z_values[j][i] - mbl.z_values[0][0];
                 int16_t dif_quantized = int16_t(floor(dif * 100.f + 0.5f));
-                eeprom_update_word((uint16_t*)addr, *reinterpret_cast<uint16_t*>(&dif_quantized));
+                eeprom_update_word_notify((uint16_t*)addr, *reinterpret_cast<uint16_t*>(&dif_quantized));
                 #if 0
                 {
                     uint16_t z_offset_u = eeprom_read_word((uint16_t*)addr);
diff --git a/Firmware/mmu2_reporting.cpp b/Firmware/mmu2_reporting.cpp
index 49809d08d..f9d266879 100644
--- a/Firmware/mmu2_reporting.cpp
+++ b/Firmware/mmu2_reporting.cpp
@@ -346,7 +346,7 @@ void TryLoadUnloadReporter::DumpToSerial(){
 
 /// Disables MMU in EEPROM
 void DisableMMUInSettings() {
-    eeprom_update_byte((uint8_t *)EEPROM_MMU_ENABLED, false);
+    eeprom_update_byte_notify((uint8_t *)EEPROM_MMU_ENABLED, false);
     mmu2.Status();
 }
 
diff --git a/Firmware/power_panic.cpp b/Firmware/power_panic.cpp
index 802f9c625..749fafd83 100644
--- a/Firmware/power_panic.cpp
+++ b/Firmware/power_panic.cpp
@@ -113,11 +113,11 @@ void uvlo_() {
         // mesh bed leveling offset value.
         logical_z -= mbl.get_z(saved_pos[X_AXIS], saved_pos[Y_AXIS]);
     }
-    eeprom_update_float((float*)EEPROM_UVLO_CURRENT_POSITION_Z, logical_z);
+    eeprom_update_float_notify((float*)EEPROM_UVLO_CURRENT_POSITION_Z, logical_z);
 
     // Store the print E position before we lose track
-    eeprom_update_float((float*)(EEPROM_UVLO_CURRENT_POSITION_E), saved_pos[E_AXIS]);
-    eeprom_update_byte((uint8_t*)EEPROM_UVLO_E_ABS, !saved_extruder_relative_mode);
+    eeprom_update_float_notify((float*)(EEPROM_UVLO_CURRENT_POSITION_E), saved_pos[E_AXIS]);
+    eeprom_update_byte_notify((uint8_t*)EEPROM_UVLO_E_ABS, !saved_extruder_relative_mode);
 
     // Clean the input command queue, inhibit serial processing using saved_printing
     cmdqueue_reset();
@@ -149,7 +149,7 @@ void uvlo_() {
     poweroff_z();
 
     // Write the file position.
-    eeprom_update_dword((uint32_t*)(EEPROM_FILE_POSITION), saved_sdpos);
+    eeprom_update_dword_notify((uint32_t*)(EEPROM_FILE_POSITION), saved_sdpos);
 
     // Store the mesh bed leveling offsets. This is 2*7*7=98 bytes, which takes 98*3.4us=333us in worst case.
     for (uint8_t mesh_point = 0; mesh_point < MESH_NUM_X_POINTS * MESH_NUM_Y_POINTS; ++ mesh_point)
@@ -158,41 +158,41 @@ void uvlo_() {
         uint8_t iy = mesh_point / MESH_NUM_X_POINTS;
         // Scale the z value to 1u resolution.
         int16_t v = mbl_was_active ? int16_t(floor(mbl.z_values[iy][ix] * 1000.f + 0.5f)) : 0;
-        eeprom_update_word((uint16_t*)(EEPROM_UVLO_MESH_BED_LEVELING_FULL +2*mesh_point), *reinterpret_cast<uint16_t*>(&v));
+        eeprom_update_word_notify((uint16_t*)(EEPROM_UVLO_MESH_BED_LEVELING_FULL +2*mesh_point), *reinterpret_cast<uint16_t*>(&v));
     }
 
     // Write the _final_ Z position
-    eeprom_update_float((float*)EEPROM_UVLO_TINY_CURRENT_POSITION_Z, current_position[Z_AXIS]);
+    eeprom_update_float_notify((float*)EEPROM_UVLO_TINY_CURRENT_POSITION_Z, current_position[Z_AXIS]);
 
     // Store the current position.
-    eeprom_update_float((float*)(EEPROM_UVLO_CURRENT_POSITION + 0), saved_pos[X_AXIS]);
-    eeprom_update_float((float*)(EEPROM_UVLO_CURRENT_POSITION + 4), saved_pos[Y_AXIS]);
+    eeprom_update_float_notify((float*)(EEPROM_UVLO_CURRENT_POSITION + 0), saved_pos[X_AXIS]);
+    eeprom_update_float_notify((float*)(EEPROM_UVLO_CURRENT_POSITION + 4), saved_pos[Y_AXIS]);
 
     // Store the current feed rate, temperatures, fan speed and extruder multipliers (flow rates)
-    eeprom_update_word((uint16_t*)EEPROM_UVLO_FEEDRATE, saved_feedrate2);
-    eeprom_update_word((uint16_t*)EEPROM_UVLO_FEEDMULTIPLY, feedmultiply);
-    eeprom_update_word((uint16_t*)EEPROM_UVLO_TARGET_HOTEND, saved_extruder_temperature);
-    eeprom_update_byte((uint8_t*)EEPROM_UVLO_TARGET_BED, saved_bed_temperature);
-    eeprom_update_byte((uint8_t*)EEPROM_UVLO_FAN_SPEED, saved_fan_speed);
-    eeprom_update_float((float*)(EEPROM_EXTRUDER_MULTIPLIER_0), extruder_multiplier[0]);
-    eeprom_update_word((uint16_t*)(EEPROM_EXTRUDEMULTIPLY), (uint16_t)extrudemultiply);
+    eeprom_update_word_notify((uint16_t*)EEPROM_UVLO_FEEDRATE, saved_feedrate2);
+    eeprom_update_word_notify((uint16_t*)EEPROM_UVLO_FEEDMULTIPLY, feedmultiply);
+    eeprom_update_word_notify((uint16_t*)EEPROM_UVLO_TARGET_HOTEND, saved_extruder_temperature);
+    eeprom_update_byte_notify((uint8_t*)EEPROM_UVLO_TARGET_BED, saved_bed_temperature);
+    eeprom_update_byte_notify((uint8_t*)EEPROM_UVLO_FAN_SPEED, saved_fan_speed);
+    eeprom_update_float_notify((float*)(EEPROM_EXTRUDER_MULTIPLIER_0), extruder_multiplier[0]);
+    eeprom_update_word_notify((uint16_t*)(EEPROM_EXTRUDEMULTIPLY), (uint16_t)extrudemultiply);
 
-    eeprom_update_float((float*)(EEPROM_UVLO_ACCELL), cs.acceleration);
-    eeprom_update_float((float*)(EEPROM_UVLO_RETRACT_ACCELL), cs.retract_acceleration);
-    eeprom_update_float((float*)(EEPROM_UVLO_TRAVEL_ACCELL), cs.travel_acceleration);
+    eeprom_update_float_notify((float*)(EEPROM_UVLO_ACCELL), cs.acceleration);
+    eeprom_update_float_notify((float*)(EEPROM_UVLO_RETRACT_ACCELL), cs.retract_acceleration);
+    eeprom_update_float_notify((float*)(EEPROM_UVLO_TRAVEL_ACCELL), cs.travel_acceleration);
 
     // Store the saved target
-    eeprom_update_block(saved_start_position, (float *)EEPROM_UVLO_SAVED_START_POSITION, sizeof(saved_start_position));
+    eeprom_update_block_notify(saved_start_position, (float *)EEPROM_UVLO_SAVED_START_POSITION, sizeof(saved_start_position));
 
-    eeprom_update_word((uint16_t*)EEPROM_UVLO_SAVED_SEGMENT_IDX, saved_segment_idx);
-    eeprom_update_byte((uint8_t*)EEPROM_UVLO_PRINT_TYPE, saved_printing_type);
+    eeprom_update_word_notify((uint16_t*)EEPROM_UVLO_SAVED_SEGMENT_IDX, saved_segment_idx);
+    eeprom_update_byte_notify((uint8_t*)EEPROM_UVLO_PRINT_TYPE, saved_printing_type);
 
 #ifdef LIN_ADVANCE
-    eeprom_update_float((float*)(EEPROM_UVLO_LA_K), extruder_advance_K);
+    eeprom_update_float_notify((float*)(EEPROM_UVLO_LA_K), extruder_advance_K);
 #endif
 
     // Finally store the "power outage" flag.
-    eeprom_update_byte((uint8_t*)EEPROM_UVLO, PowerPanic::PENDING_RECOVERY);
+    eeprom_update_byte_notify((uint8_t*)EEPROM_UVLO, PowerPanic::PENDING_RECOVERY);
 
     // Increment power failure counter
     eeprom_increment_byte((uint8_t*)EEPROM_POWER_COUNT);
@@ -260,11 +260,11 @@ static void uvlo_tiny() {
         poweroff_z();
 
         // Update Z position
-        eeprom_update_float((float*)(EEPROM_UVLO_TINY_CURRENT_POSITION_Z), current_position[Z_AXIS]);
+        eeprom_update_float_notify((float*)(EEPROM_UVLO_TINY_CURRENT_POSITION_Z), current_position[Z_AXIS]);
     }
 
     // Update the the "power outage" flag.
-    eeprom_update_byte((uint8_t*)EEPROM_UVLO, PowerPanic::PENDING_RECOVERY_RETRY);
+    eeprom_update_byte_notify((uint8_t*)EEPROM_UVLO, PowerPanic::PENDING_RECOVERY_RETRY);
 
     // Increment power failure counter
     eeprom_increment_byte((uint8_t*)EEPROM_POWER_COUNT);
diff --git a/Firmware/sound.cpp b/Firmware/sound.cpp
index 5e1f00f36..a3825183a 100644
--- a/Firmware/sound.cpp
+++ b/Firmware/sound.cpp
@@ -30,7 +30,7 @@ void Sound_Init(void)
 
 void Sound_SaveMode(void)
 {
-eeprom_update_byte((uint8_t*)EEPROM_SOUND_MODE,(uint8_t)eSoundMode);
+eeprom_update_byte_notify((uint8_t*)EEPROM_SOUND_MODE,(uint8_t)eSoundMode);
 }
 
 void Sound_CycleState(void)
diff --git a/Firmware/temperature.cpp b/Firmware/temperature.cpp
index cc052ce04..547d0709e 100755
--- a/Firmware/temperature.cpp
+++ b/Firmware/temperature.cpp
@@ -2431,17 +2431,17 @@ void thermal_model_load_settings()
 
 void thermal_model_save_settings()
 {
-    eeprom_update_byte((uint8_t*)EEPROM_THERMAL_MODEL_ENABLE, thermal_model::enabled);
-    eeprom_update_float((float*)EEPROM_THERMAL_MODEL_P, thermal_model::data.P);
-    eeprom_update_float((float*)EEPROM_THERMAL_MODEL_U, thermal_model::data.U);
-    eeprom_update_float((float*)EEPROM_THERMAL_MODEL_V, thermal_model::data.V);
-    eeprom_update_float((float*)EEPROM_THERMAL_MODEL_C, thermal_model::data.C);
-    eeprom_update_float((float*)EEPROM_THERMAL_MODEL_D, thermal_model::data.fS);
-    eeprom_update_word((uint16_t*)EEPROM_THERMAL_MODEL_L, thermal_model::data.L);
-    eeprom_update_block(&thermal_model::data.R[0], (float*)EEPROM_THERMAL_MODEL_R, THERMAL_MODEL_R_SIZE * sizeof(float));
-    eeprom_update_float((float*)EEPROM_THERMAL_MODEL_Ta_corr, thermal_model::data.Ta_corr);
-    eeprom_update_float((float*)EEPROM_THERMAL_MODEL_W, thermal_model::data.warn);
-    eeprom_update_float((float*)EEPROM_THERMAL_MODEL_E, thermal_model::data.err);
+    eeprom_update_byte_notify((uint8_t*)EEPROM_THERMAL_MODEL_ENABLE, thermal_model::enabled);
+    eeprom_update_float_notify((float*)EEPROM_THERMAL_MODEL_P, thermal_model::data.P);
+    eeprom_update_float_notify((float*)EEPROM_THERMAL_MODEL_U, thermal_model::data.U);
+    eeprom_update_float_notify((float*)EEPROM_THERMAL_MODEL_V, thermal_model::data.V);
+    eeprom_update_float_notify((float*)EEPROM_THERMAL_MODEL_C, thermal_model::data.C);
+    eeprom_update_float_notify((float*)EEPROM_THERMAL_MODEL_D, thermal_model::data.fS);
+    eeprom_update_word_notify((uint16_t*)EEPROM_THERMAL_MODEL_L, thermal_model::data.L);
+    eeprom_update_block_notify(&thermal_model::data.R[0], (float*)EEPROM_THERMAL_MODEL_R, THERMAL_MODEL_R_SIZE * sizeof(float));
+    eeprom_update_float_notify((float*)EEPROM_THERMAL_MODEL_Ta_corr, thermal_model::data.Ta_corr);
+    eeprom_update_float_notify((float*)EEPROM_THERMAL_MODEL_W, thermal_model::data.warn);
+    eeprom_update_float_notify((float*)EEPROM_THERMAL_MODEL_E, thermal_model::data.err);
 }
 
 namespace thermal_model_cal {
diff --git a/Firmware/tmc2130.cpp b/Firmware/tmc2130.cpp
index 30b2a4389..30f4724bc 100755
--- a/Firmware/tmc2130.cpp
+++ b/Firmware/tmc2130.cpp
@@ -1032,8 +1032,8 @@ bool tmc2130_home_calibrate(uint8_t axis)
 	bubblesort_uint8(cnt, cl, val);
 	tmc2130_home_origin[axis] = val[cl-1];
 	printf_P(PSTR("result value: %d\n"), tmc2130_home_origin[axis]);
-	if (axis == X_AXIS) eeprom_update_byte((uint8_t*)EEPROM_TMC2130_HOME_X_ORIGIN, tmc2130_home_origin[X_AXIS]);
-	else if (axis == Y_AXIS) eeprom_update_byte((uint8_t*)EEPROM_TMC2130_HOME_Y_ORIGIN, tmc2130_home_origin[Y_AXIS]);
+	if (axis == X_AXIS) eeprom_update_byte_notify((uint8_t*)EEPROM_TMC2130_HOME_X_ORIGIN, tmc2130_home_origin[X_AXIS]);
+	else if (axis == Y_AXIS) eeprom_update_byte_notify((uint8_t*)EEPROM_TMC2130_HOME_Y_ORIGIN, tmc2130_home_origin[Y_AXIS]);
 	return true;
 }
 
diff --git a/Firmware/ultralcd.cpp b/Firmware/ultralcd.cpp
index ba3b17fc5..63edc35d1 100644
--- a/Firmware/ultralcd.cpp
+++ b/Firmware/ultralcd.cpp
@@ -1732,7 +1732,7 @@ static void lcd_support_menu()
 
 void lcd_set_fan_check() {
 	fans_check_enabled = !fans_check_enabled;
-	eeprom_update_byte((unsigned char *)EEPROM_FAN_CHECK_ENABLED, fans_check_enabled);
+	eeprom_update_byte_notify((unsigned char *)EEPROM_FAN_CHECK_ENABLED, fans_check_enabled);
 #ifdef FANCHECK
 	if (fans_check_enabled == false) fan_check_error = EFCE_OK; //reset error if fanCheck is disabled during error. Allows resuming print.
 #endif //FANCHECK
@@ -1744,19 +1744,19 @@ void lcd_cutter_enabled()
     if (EEPROM_MMU_CUTTER_ENABLED_enabled == eeprom_read_byte((uint8_t*)EEPROM_MMU_CUTTER_ENABLED))
     {
 #ifndef MMU_ALWAYS_CUT
-        eeprom_update_byte((uint8_t*)EEPROM_MMU_CUTTER_ENABLED, 0);
+        eeprom_update_byte_notify((uint8_t*)EEPROM_MMU_CUTTER_ENABLED, 0);
     }
 #else //MMU_ALWAYS_CUT
-        eeprom_update_byte((uint8_t*)EEPROM_MMU_CUTTER_ENABLED, EEPROM_MMU_CUTTER_ENABLED_always);
+        eeprom_update_byte_notify((uint8_t*)EEPROM_MMU_CUTTER_ENABLED, EEPROM_MMU_CUTTER_ENABLED_always);
     }
     else if (EEPROM_MMU_CUTTER_ENABLED_always == eeprom_read_byte((uint8_t*)EEPROM_MMU_CUTTER_ENABLED))
     {
-        eeprom_update_byte((uint8_t*)EEPROM_MMU_CUTTER_ENABLED, 0);
+        eeprom_update_byte_notify((uint8_t*)EEPROM_MMU_CUTTER_ENABLED, 0);
     }
 #endif //MMU_ALWAYS_CUT
     else
     {
-        eeprom_update_byte((uint8_t*)EEPROM_MMU_CUTTER_ENABLED, EEPROM_MMU_CUTTER_ENABLED_enabled);
+        eeprom_update_byte_notify((uint8_t*)EEPROM_MMU_CUTTER_ENABLED, EEPROM_MMU_CUTTER_ENABLED_enabled);
     }
 }
 #endif //MMU_HAS_CUTTER
@@ -2638,12 +2638,12 @@ static void lcd_babystep_z()
 	{
 		// Only update the EEPROM when leaving the menu.
           uint8_t active_sheet=eeprom_read_byte(&(EEPROM_Sheets_base->active_sheet));
-		eeprom_update_word(reinterpret_cast<uint16_t *>(&(EEPROM_Sheets_base->s[active_sheet].z_offset)),_md->babystepMemZ);
+		eeprom_update_word_notify(reinterpret_cast<uint16_t *>(&(EEPROM_Sheets_base->s[active_sheet].z_offset)),_md->babystepMemZ);
 
         // NOTE: bed_temp and pinda_temp are not currently read/used anywhere.
-		eeprom_update_byte(&(EEPROM_Sheets_base->s[active_sheet].bed_temp),target_temperature_bed);
+		eeprom_update_byte_notify(&(EEPROM_Sheets_base->s[active_sheet].bed_temp),target_temperature_bed);
 #ifdef PINDA_THERMISTOR
-		eeprom_update_byte(&(EEPROM_Sheets_base->s[active_sheet].pinda_temp),current_temperature_pinda);
+		eeprom_update_byte_notify(&(EEPROM_Sheets_base->s[active_sheet].pinda_temp),current_temperature_pinda);
 #endif //PINDA_THERMISTOR
 		calibration_status_set(CALIBRATION_STATUS_LIVE_ADJUST);
 	}
@@ -2699,11 +2699,11 @@ void lcd_adjust_bed(void)
     MENU_BEGIN();
 	// leaving menu - this condition must be immediately before MENU_ITEM_BACK_P
     ON_MENU_LEAVE(
-        eeprom_update_byte((uint8_t*)EEPROM_BED_CORRECTION_LEFT, (uint8_t)_md->left);
-        eeprom_update_byte((uint8_t*)EEPROM_BED_CORRECTION_FRONT, (uint8_t)_md->front);
-        eeprom_update_byte((uint8_t*)EEPROM_BED_CORRECTION_REAR, (uint8_t)_md->rear);
-        eeprom_update_byte((uint8_t*)EEPROM_BED_CORRECTION_RIGHT, (uint8_t)_md->right);
-        eeprom_update_byte((uint8_t*)EEPROM_BED_CORRECTION_VALID, 1);
+        eeprom_update_byte_notify((uint8_t*)EEPROM_BED_CORRECTION_LEFT, (uint8_t)_md->left);
+        eeprom_update_byte_notify((uint8_t*)EEPROM_BED_CORRECTION_FRONT, (uint8_t)_md->front);
+        eeprom_update_byte_notify((uint8_t*)EEPROM_BED_CORRECTION_REAR, (uint8_t)_md->rear);
+        eeprom_update_byte_notify((uint8_t*)EEPROM_BED_CORRECTION_RIGHT, (uint8_t)_md->right);
+        eeprom_update_byte_notify((uint8_t*)EEPROM_BED_CORRECTION_VALID, 1);
     );
     MENU_ITEM_BACK_P(_T(MSG_BACK));
 	MENU_ITEM_EDIT_int3_P(_i("Left side [\xe4m]"),  &_md->left,  -BED_ADJUSTMENT_UM_MAX, BED_ADJUSTMENT_UM_MAX);////MSG_BED_CORRECTION_LEFT c=14
@@ -3222,8 +3222,8 @@ void lcd_temp_cal_show_result(bool result) {
 	setTargetBed(0); //set bed target temperature back to 0
 
 	// Store boolean result
-	eeprom_update_byte((uint8_t*)EEPROM_CALIBRATION_STATUS_PINDA, result);
-	eeprom_update_byte((uint8_t*)EEPROM_TEMP_CAL_ACTIVE, result);
+	eeprom_update_byte_notify((uint8_t*)EEPROM_CALIBRATION_STATUS_PINDA, result);
+	eeprom_update_byte_notify((uint8_t*)EEPROM_TEMP_CAL_ACTIVE, result);
 
 	if (result) {
 		SERIAL_ECHOLNPGM("PINDA calibration done. Continue with pressing the knob.");
@@ -3362,7 +3362,7 @@ static void lcd_sort_type_set() {
 		case SD_SORT_ALPHA: sdSort = SD_SORT_NONE; break;
 		default: sdSort = SD_SORT_TIME;
 	}
-	eeprom_update_byte((uint8_t*)EEPROM_SD_SORT, sdSort);
+	eeprom_update_byte_notify((uint8_t*)EEPROM_SD_SORT, sdSort);
 	card.presort_flag = true;
 }
 #endif //SDCARD_SORT_ALPHA
@@ -3406,7 +3406,7 @@ static void lcd_silent_mode_set() {
 	default: SilentModeMenu = SILENT_MODE_POWER; break; // (probably) not needed
 #endif //TMC2130
 	}
-  eeprom_update_byte((unsigned char *)EEPROM_SILENT, SilentModeMenu);
+  eeprom_update_byte_notify((unsigned char *)EEPROM_SILENT, SilentModeMenu);
 #ifdef TMC2130
   if (blocks_queued())
   {
@@ -3534,14 +3534,14 @@ void lcd_mesh_calibration_z()
 void lcd_temp_calibration_set() {
 	bool temp_cal_active = eeprom_read_byte((unsigned char *)EEPROM_TEMP_CAL_ACTIVE);
 	temp_cal_active = !temp_cal_active;
-	eeprom_update_byte((unsigned char *)EEPROM_TEMP_CAL_ACTIVE, temp_cal_active);
+	eeprom_update_byte_notify((unsigned char *)EEPROM_TEMP_CAL_ACTIVE, temp_cal_active);
 }
 
 #ifdef HAS_SECOND_SERIAL_PORT
 void lcd_second_serial_set() {
 	if(selectedSerialPort == 1) selectedSerialPort = 0;
 	else selectedSerialPort = 1;
-	eeprom_update_byte((unsigned char *)EEPROM_SECOND_SERIAL_ACTIVE, selectedSerialPort);
+	eeprom_update_byte_notify((unsigned char *)EEPROM_SECOND_SERIAL_ACTIVE, selectedSerialPort);
 	MYSERIAL.begin(BAUDRATE);
 }
 #endif //HAS_SECOND_SERIAL_PORT
@@ -3554,7 +3554,7 @@ void lcd_calibrate_pinda() {
 void lcd_toshiba_flash_air_compatibility_toggle()
 {
    card.ToshibaFlashAir_enable(! card.ToshibaFlashAir_isEnabled());
-   eeprom_update_byte((uint8_t*)EEPROM_TOSHIBA_FLASH_AIR_COMPATIBLITY, card.ToshibaFlashAir_isEnabled());
+   eeprom_update_byte_notify((uint8_t*)EEPROM_TOSHIBA_FLASH_AIR_COMPATIBLITY, card.ToshibaFlashAir_isEnabled());
 }
 
 //! @brief Continue first layer calibration with previous value or start from zero?
@@ -3583,7 +3583,7 @@ void lcd_first_layer_calibration_reset()
     {
         if (menuData->reset)
         {
-            eeprom_update_word(reinterpret_cast<uint16_t*>(&EEPROM_Sheets_base->s[(eeprom_read_byte(&(EEPROM_Sheets_base->active_sheet)))].z_offset), 0xffff);
+            eeprom_update_word_notify(reinterpret_cast<uint16_t*>(&EEPROM_Sheets_base->s[(eeprom_read_byte(&(EEPROM_Sheets_base->active_sheet)))].z_offset), 0xffff);
         }
 
         // If the knob was clicked, don't produce feedback
@@ -3781,7 +3781,7 @@ void lcd_wizard(WizState state)
 	uint8_t wizard_event;
 	// Make sure EEPROM_WIZARD_ACTIVE is true if entering using different entry point
 	// other than WizState::Run - it is useful for debugging wizard.
-	if (state != S::Run) eeprom_update_byte((uint8_t*)EEPROM_WIZARD_ACTIVE, 1);
+	if (state != S::Run) eeprom_update_byte_notify((uint8_t*)EEPROM_WIZARD_ACTIVE, 1);
 
     FORCE_BL_ON_START;
 
@@ -3810,10 +3810,10 @@ void lcd_wizard(WizState state)
 				wizard_event = lcd_show_multiscreen_message_yes_no_and_wait_P(_T(MSG_WIZARD_WELCOME), false, LCD_LEFT_BUTTON_CHOICE);
 				if (wizard_event == LCD_LEFT_BUTTON_CHOICE) {
 					state = S::Restore;
-					eeprom_update_byte((uint8_t*)EEPROM_WIZARD_ACTIVE, 1);
+					eeprom_update_byte_notify((uint8_t*)EEPROM_WIZARD_ACTIVE, 1);
 				} else {
 					// user interrupted
-					eeprom_update_byte((uint8_t*)EEPROM_WIZARD_ACTIVE, 0);
+					eeprom_update_byte_notify((uint8_t*)EEPROM_WIZARD_ACTIVE, 0);
 					end = true;
 				}
 			}
@@ -3934,7 +3934,7 @@ void lcd_wizard(WizState state)
 			break;
 		case S::Finish:
 		case S::Failed:
-			eeprom_update_byte((uint8_t*)EEPROM_WIZARD_ACTIVE, 0);
+			eeprom_update_byte_notify((uint8_t*)EEPROM_WIZARD_ACTIVE, 0);
 			end = true;
 			break;
 		}
@@ -4218,7 +4218,7 @@ switch(oCheckMode)
      default:
           oCheckMode=ClCheckMode::_None;
      }
-eeprom_update_byte((uint8_t*)EEPROM_CHECK_MODE,(uint8_t)oCheckMode);
+eeprom_update_byte_notify((uint8_t*)EEPROM_CHECK_MODE,(uint8_t)oCheckMode);
 }
 
 #define SETTINGS_MODE \
@@ -4264,8 +4264,8 @@ static void lcd_nozzle_diameter_cycle(void) {
         oNozzleDiameter=ClNozzleDiameter::_Diameter_400;
         nDiameter=400;
     }
-    eeprom_update_byte((uint8_t*)EEPROM_NOZZLE_DIAMETER,(uint8_t)oNozzleDiameter);
-    eeprom_update_word((uint16_t*)EEPROM_NOZZLE_DIAMETER_uM,nDiameter);
+    eeprom_update_byte_notify((uint8_t*)EEPROM_NOZZLE_DIAMETER,(uint8_t)oNozzleDiameter);
+    eeprom_update_word_notify((uint16_t*)EEPROM_NOZZLE_DIAMETER_uM,nDiameter);
 }
 
 #define SETTINGS_NOZZLE \
@@ -4298,7 +4298,7 @@ switch(oCheckModel)
      default:
           oCheckModel=ClCheckModel::_None;
      }
-eeprom_update_byte((uint8_t*)EEPROM_CHECK_MODEL,(uint8_t)oCheckModel);
+eeprom_update_byte_notify((uint8_t*)EEPROM_CHECK_MODEL,(uint8_t)oCheckModel);
 }
 
 #define SETTINGS_MODEL \
@@ -4337,7 +4337,7 @@ switch(oCheckVersion)
      default:
           oCheckVersion=ClCheckVersion::_None;
      }
-eeprom_update_byte((uint8_t*)EEPROM_CHECK_VERSION,(uint8_t)oCheckVersion);
+eeprom_update_byte_notify((uint8_t*)EEPROM_CHECK_VERSION,(uint8_t)oCheckVersion);
 }
 
 #define SETTINGS_VERSION \
@@ -4541,10 +4541,10 @@ static void lcd_settings_menu()
 #ifdef TMC2130
 static void lcd_ustep_linearity_menu_save()
 {
-    eeprom_update_byte((uint8_t*)EEPROM_TMC2130_WAVE_X_FAC, tmc2130_wave_fac[X_AXIS]);
-    eeprom_update_byte((uint8_t*)EEPROM_TMC2130_WAVE_Y_FAC, tmc2130_wave_fac[Y_AXIS]);
-    eeprom_update_byte((uint8_t*)EEPROM_TMC2130_WAVE_Z_FAC, tmc2130_wave_fac[Z_AXIS]);
-    eeprom_update_byte((uint8_t*)EEPROM_TMC2130_WAVE_E_FAC, tmc2130_wave_fac[E_AXIS]);
+    eeprom_update_byte_notify((uint8_t*)EEPROM_TMC2130_WAVE_X_FAC, tmc2130_wave_fac[X_AXIS]);
+    eeprom_update_byte_notify((uint8_t*)EEPROM_TMC2130_WAVE_Y_FAC, tmc2130_wave_fac[Y_AXIS]);
+    eeprom_update_byte_notify((uint8_t*)EEPROM_TMC2130_WAVE_Z_FAC, tmc2130_wave_fac[Z_AXIS]);
+    eeprom_update_byte_notify((uint8_t*)EEPROM_TMC2130_WAVE_E_FAC, tmc2130_wave_fac[E_AXIS]);
 }
 #endif //TMC2130
 
@@ -5051,7 +5051,7 @@ void lcd_resume_usb_print()
 
 static void change_sheet()
 {
-	eeprom_update_byte(&(EEPROM_Sheets_base->active_sheet), selected_sheet);
+	eeprom_update_byte_notify(&(EEPROM_Sheets_base->active_sheet), selected_sheet);
     menu_back(3);
 }
 
@@ -5096,7 +5096,7 @@ static void lcd_rename_sheet_menu()
         }
         else
         {
-            eeprom_update_block(menuData->name,
+            eeprom_update_block_notify(menuData->name,
                 EEPROM_Sheets_base->s[selected_sheet].name,
                 sizeof(Sheet::name));
             menu_back();
@@ -5108,8 +5108,8 @@ static void lcd_reset_sheet()
 {
     SheetName sheetName;
     eeprom_default_sheet_name(selected_sheet, sheetName);
-	eeprom_update_word(reinterpret_cast<uint16_t *>(&(EEPROM_Sheets_base->s[selected_sheet].z_offset)),EEPROM_EMPTY_VALUE16);
-	eeprom_update_block(sheetName.c,EEPROM_Sheets_base->s[selected_sheet].name,sizeof(Sheet::name));
+	eeprom_update_word_notify(reinterpret_cast<uint16_t *>(&(EEPROM_Sheets_base->s[selected_sheet].z_offset)),EEPROM_EMPTY_VALUE16);
+	eeprom_update_block_notify(sheetName.c,EEPROM_Sheets_base->s[selected_sheet].name,sizeof(Sheet::name));
 	if (selected_sheet == eeprom_read_byte(&(EEPROM_Sheets_base->active_sheet)))
 	{
         eeprom_switch_to_next_sheet();
@@ -5123,7 +5123,7 @@ static void lcd_reset_sheet()
 //! @brief Activate selected_sheet and run first layer calibration
 static void activate_calibrate_sheet()
 {
-    eeprom_update_byte(&(EEPROM_Sheets_base->active_sheet), selected_sheet);
+    eeprom_update_byte_notify(&(EEPROM_Sheets_base->active_sheet), selected_sheet);
     lcd_first_layer_calibration_reset();
 }
 
@@ -5544,14 +5544,14 @@ static void lcd_tune_menu()
 static void mbl_magnets_elimination_toggle() {
 	bool magnet_elimination = (eeprom_read_byte((uint8_t*)EEPROM_MBL_MAGNET_ELIMINATION) > 0);
 	magnet_elimination = !magnet_elimination;
-	eeprom_update_byte((uint8_t*)EEPROM_MBL_MAGNET_ELIMINATION, (uint8_t)magnet_elimination);
+	eeprom_update_byte_notify((uint8_t*)EEPROM_MBL_MAGNET_ELIMINATION, (uint8_t)magnet_elimination);
 }
 
 static void mbl_mesh_toggle() {
 	uint8_t mesh_nr = eeprom_read_byte((uint8_t*)EEPROM_MBL_POINTS_NR);
 	if(mesh_nr == 3) mesh_nr = 7;
 	else mesh_nr = 3;
-	eeprom_update_byte((uint8_t*)EEPROM_MBL_POINTS_NR, mesh_nr);
+	eeprom_update_byte_notify((uint8_t*)EEPROM_MBL_POINTS_NR, mesh_nr);
 }
 
 static void mbl_probe_nr_toggle() {
@@ -5562,7 +5562,7 @@ static void mbl_probe_nr_toggle() {
 		case 5: mbl_z_probe_nr = 1; break;
 		default: mbl_z_probe_nr = 3; break;
 	}
-	eeprom_update_byte((uint8_t*)EEPROM_MBL_PROBE_NR, mbl_z_probe_nr);
+	eeprom_update_byte_notify((uint8_t*)EEPROM_MBL_PROBE_NR, mbl_z_probe_nr);
 }
 
 static void lcd_mesh_bed_leveling_settings()
@@ -6202,7 +6202,7 @@ bool lcd_selftest()
 		bres &= tmc2130_home_calibrate(Y_AXIS);
 		_progress = lcd_selftest_screen(TestScreen::Home, 2, 2, true, 0);
 		if (bres)
-			eeprom_update_byte((uint8_t*)EEPROM_TMC2130_HOME_ENABLED, 1);
+			eeprom_update_byte_notify((uint8_t*)EEPROM_TMC2130_HOME_ENABLED, 1);
 		_result = bres;
 	}
 #endif //TMC2130
@@ -6332,7 +6332,7 @@ static bool lcd_selfcheck_axis_sg(uint8_t axis) {
 
 	uint16_t sg1 = tmc2130_sg_measure_stop();
 	printf_P(PSTR("%c AXIS SG1=%d\n"), 'X'+axis, sg1);
-	eeprom_write_word(((uint16_t*)((axis == X_AXIS)?EEPROM_BELTSTATUS_X:EEPROM_BELTSTATUS_Y)), sg1);
+	eeprom_write_word_notify(((uint16_t*)((axis == X_AXIS)?EEPROM_BELTSTATUS_X:EEPROM_BELTSTATUS_Y)), sg1);
 
 	current_position_final = st_get_position_mm(axis);
 	measured_axis_length[0] = fabs(current_position_final - current_position_init);
@@ -7096,11 +7096,11 @@ static void menu_action_sdfile(const char* filename)
   for (uint_least8_t i = 0; i < 8; i++) {
 	  if (selected_filename[i] == '\0' || selected_filename[i] == '.') {
 		  //filename is shorter then 8.3, store '\0' character on position where ".gco" string was found to terminate stored string properly
- 		  eeprom_write_byte((uint8_t*)EEPROM_FILENAME + i, '\0');
+		  eeprom_update_byte_notify((uint8_t*)EEPROM_FILENAME + i, '\0');
 		  break;
 	  }
 	  else {
-		  eeprom_write_byte((uint8_t*)EEPROM_FILENAME + i, selected_filename[i]);
+		  eeprom_update_byte_notify((uint8_t*)EEPROM_FILENAME + i, selected_filename[i]);
 	  }
   }
 
@@ -7114,17 +7114,17 @@ static void menu_action_sdfile(const char* filename)
     for (uint_least8_t i = 0; i < 3; i++)
     {
         if (extension_ptr == NULL || extension_ptr[i] == '\0') {
-            eeprom_update_byte((uint8_t*)EEPROM_FILENAME_EXTENSION + i, '\0');
+            eeprom_update_byte_notify((uint8_t*)EEPROM_FILENAME_EXTENSION + i, '\0');
         } else {
-            eeprom_update_byte((uint8_t*)EEPROM_FILENAME_EXTENSION + i, extension_ptr[i]);
+            eeprom_update_byte_notify((uint8_t*)EEPROM_FILENAME_EXTENSION + i, extension_ptr[i]);
         }
     }
 
     const uint8_t depth = card.getWorkDirDepth();
-    eeprom_write_byte((uint8_t*)EEPROM_DIR_DEPTH, depth);
+    eeprom_update_byte_notify((uint8_t*)EEPROM_DIR_DEPTH, depth);
 
     for (uint_least8_t i = 0; i < depth; i++) {
-        eeprom_update_block(card.dir_names[i], (uint8_t*)EEPROM_DIRS + 8 * i, 8);
+        eeprom_update_block_notify(card.dir_names[i], (uint8_t*)EEPROM_DIRS + 8 * i, 8);
     }
 
   if (!check_file(selected_filename)) {
@@ -7436,7 +7436,7 @@ void UserECool_toggle(){
     // The condition is intentionally inverted as we are toggling the state (i.e. if it was enabled, we are disabling the feature and vice versa)
     bool enable = ! UserECoolEnabled();
 
-    eeprom_update_byte((uint8_t *)EEPROM_ECOOL_ENABLE, enable ? EEPROM_ECOOL_MAGIC_NUMBER : EEPROM_EMPTY_VALUE);
+    eeprom_update_byte_notify((uint8_t *)EEPROM_ECOOL_ENABLE, enable ? EEPROM_ECOOL_MAGIC_NUMBER : EEPROM_EMPTY_VALUE);
 
     // @@TODO I don't like this - disabling the experimental menu shall disable ECool mode, but it will not reinit the TMC
     // and I don't want to add more code for this experimental feature ... ideally do not reinit the TMC here at all and let the user reset the printer.
@@ -7465,7 +7465,7 @@ bool FarmOrUserECool(){
 void WorkaroundPrusaSN() {
     const char *SN = PSTR("CZPXInvalidSerialNr");
     for (uint8_t i = 0; i < 20; i++) {
-        eeprom_update_byte((uint8_t*)EEPROM_PRUSA_SN + i, pgm_read_byte(SN++));
+        eeprom_update_byte_notify((uint8_t*)EEPROM_PRUSA_SN + i, pgm_read_byte(SN++));
     }
 }
 #endif //PRUSA_SN_SUPPORT
@@ -7501,7 +7501,7 @@ void lcd_pinda_temp_compensation_toggle()
 		pinda_temp_compensation = 1;                   // But for MK3/S it should be 1 so SuperPINDA is "active"
 	else
 		pinda_temp_compensation = !pinda_temp_compensation;
-	eeprom_update_byte((uint8_t*)EEPROM_PINDA_TEMP_COMPENSATION, pinda_temp_compensation);
+	eeprom_update_byte_notify((uint8_t*)EEPROM_PINDA_TEMP_COMPENSATION, pinda_temp_compensation);
 	SERIAL_ECHOLNPGM("SuperPINDA:");
 	SERIAL_ECHOLN(pinda_temp_compensation);
 }
@@ -7514,7 +7514,7 @@ void lcd_heat_bed_on_load_toggle()
         value = 1;
     else
         value = !value;
-    eeprom_update_byte((uint8_t*)EEPROM_HEAT_BED_ON_LOAD_FILAMENT, value);
+    eeprom_update_byte_notify((uint8_t*)EEPROM_HEAT_BED_ON_LOAD_FILAMENT, value);
 }
 
 void lcd_reprint_from_eeprom() {
diff --git a/Firmware/util.cpp b/Firmware/util.cpp
index 0e0bdbb7b..c38c9111c 100644
--- a/Firmware/util.cpp
+++ b/Firmware/util.cpp
@@ -227,13 +227,13 @@ bool show_upgrade_dialog_if_version_newer(const char *version_string)
 void update_current_firmware_version_to_eeprom()
 {
     for (int8_t i = 0; i < FW_PRUSA3D_MAGIC_LEN; ++ i){
-        eeprom_update_byte((uint8_t*)(EEPROM_FIRMWARE_PRUSA_MAGIC+i), pgm_read_byte(FW_PRUSA3D_MAGIC_STR+i));
+        eeprom_update_byte_notify((uint8_t*)(EEPROM_FIRMWARE_PRUSA_MAGIC+i), pgm_read_byte(FW_PRUSA3D_MAGIC_STR+i));
     }
-    eeprom_update_word((uint16_t*)EEPROM_FIRMWARE_VERSION_MAJOR,    (uint16_t)pgm_read_word(&FW_VERSION_NR[0]));
-    eeprom_update_word((uint16_t*)EEPROM_FIRMWARE_VERSION_MINOR,    (uint16_t)pgm_read_word(&FW_VERSION_NR[1]));
-    eeprom_update_word((uint16_t*)EEPROM_FIRMWARE_VERSION_REVISION, (uint16_t)pgm_read_word(&FW_VERSION_NR[2]));
+    eeprom_update_word_notify((uint16_t*)EEPROM_FIRMWARE_VERSION_MAJOR,    (uint16_t)pgm_read_word(&FW_VERSION_NR[0]));
+    eeprom_update_word_notify((uint16_t*)EEPROM_FIRMWARE_VERSION_MINOR,    (uint16_t)pgm_read_word(&FW_VERSION_NR[1]));
+    eeprom_update_word_notify((uint16_t*)EEPROM_FIRMWARE_VERSION_REVISION, (uint16_t)pgm_read_word(&FW_VERSION_NR[2]));
     // See FirmwareRevisionFlavorType for the definition of firmware flavors.
-    eeprom_update_word((uint16_t*)EEPROM_FIRMWARE_VERSION_FLAVOR,   (uint16_t)pgm_read_word(&FW_VERSION_NR[3]));
+    eeprom_update_word_notify((uint16_t*)EEPROM_FIRMWARE_VERSION_FLAVOR,   (uint16_t)pgm_read_word(&FW_VERSION_NR[3]));
 }
 
 ClNozzleDiameter oNozzleDiameter;
@@ -247,7 +247,7 @@ void fCheckModeInit() {
 
     if (farm_mode) {
         oCheckMode = ClCheckMode::_Strict;
-        eeprom_update_byte((uint8_t *)EEPROM_CHECK_MODE, (uint8_t)ClCheckMode::_Strict);
+        eeprom_update_byte_notify((uint8_t *)EEPROM_CHECK_MODE, (uint8_t)ClCheckMode::_Strict);
     }
 
     oNozzleDiameter = (ClNozzleDiameter)eeprom_init_default_byte((uint8_t *)EEPROM_NOZZLE_DIAMETER, (uint8_t)ClNozzleDiameter::_Diameter_400);
@@ -438,12 +438,12 @@ void calibration_status_set(CalibrationStatus components)
 {
     CalibrationStatus status = eeprom_read_byte((uint8_t*)EEPROM_CALIBRATION_STATUS_V2);
     status |= components;
-    eeprom_update_byte((uint8_t*)EEPROM_CALIBRATION_STATUS_V2, status);
+    eeprom_update_byte_notify((uint8_t*)EEPROM_CALIBRATION_STATUS_V2, status);
 }
 
 void calibration_status_clear(CalibrationStatus components)
 {
     CalibrationStatus status = eeprom_read_byte((uint8_t*)EEPROM_CALIBRATION_STATUS_V2);
     status &= ~components;
-    eeprom_update_byte((uint8_t*)EEPROM_CALIBRATION_STATUS_V2, status);
+    eeprom_update_byte_notify((uint8_t*)EEPROM_CALIBRATION_STATUS_V2, status);
 }
diff --git a/Firmware/variants/MK25-RAMBo10a.h b/Firmware/variants/MK25-RAMBo10a.h
index 7a2bfcb8d..d9d361863 100644
--- a/Firmware/variants/MK25-RAMBo10a.h
+++ b/Firmware/variants/MK25-RAMBo10a.h
@@ -126,6 +126,7 @@
 #define DEBUG_DCODE2
 #define DEBUG_DCODE3
 
+//#define DEBUG_EEPROM_CHANGES //Uses +1188 bytes Flash +6 bytes SRAM
 //#define DEBUG_BUILD
 #ifdef DEBUG_BUILD
 //#define _NO_ASM
diff --git a/Firmware/variants/MK25-RAMBo13a.h b/Firmware/variants/MK25-RAMBo13a.h
index 7851165bd..0606835f7 100644
--- a/Firmware/variants/MK25-RAMBo13a.h
+++ b/Firmware/variants/MK25-RAMBo13a.h
@@ -127,6 +127,7 @@
 #define DEBUG_DCODE2
 #define DEBUG_DCODE3
 
+//#define DEBUG_EEPROM_CHANGES //Uses +1188 bytes Flash +6 bytes SRAM
 //#define DEBUG_BUILD
 #ifdef DEBUG_BUILD
 //#define _NO_ASM
diff --git a/Firmware/variants/MK25S-RAMBo10a.h b/Firmware/variants/MK25S-RAMBo10a.h
index 7bf8a46a6..6ea9586af 100644
--- a/Firmware/variants/MK25S-RAMBo10a.h
+++ b/Firmware/variants/MK25S-RAMBo10a.h
@@ -126,6 +126,7 @@
 #define DEBUG_DCODE2
 #define DEBUG_DCODE3
 
+//#define DEBUG_EEPROM_CHANGES //Uses +1188 bytes Flash +6 bytes SRAM
 //#define DEBUG_BUILD
 #ifdef DEBUG_BUILD
 //#define _NO_ASM
diff --git a/Firmware/variants/MK25S-RAMBo13a.h b/Firmware/variants/MK25S-RAMBo13a.h
index 309cdb081..05f2137a2 100644
--- a/Firmware/variants/MK25S-RAMBo13a.h
+++ b/Firmware/variants/MK25S-RAMBo13a.h
@@ -127,6 +127,7 @@
 #define DEBUG_DCODE2
 #define DEBUG_DCODE3
 
+//#define DEBUG_EEPROM_CHANGES //Uses +1188 bytes Flash +6 bytes SRAM
 //#define DEBUG_BUILD
 #ifdef DEBUG_BUILD
 //#define _NO_ASM
diff --git a/Firmware/variants/MK3-E3DREVO.h b/Firmware/variants/MK3-E3DREVO.h
index c4f47fec7..bfbf5fc16 100644
--- a/Firmware/variants/MK3-E3DREVO.h
+++ b/Firmware/variants/MK3-E3DREVO.h
@@ -165,6 +165,7 @@
 
 //#define DEBUG_PULLUP_CRASH //Test Pullup crash
 
+//#define DEBUG_EEPROM_CHANGES //Uses +1188 bytes Flash +6 bytes SRAM
 //#define DEBUG_BUILD
 //#define DEBUG_SEC_LANG   //secondary language debug output at startup
 //#define DEBUG_XFLASH   //debug external spi flash
diff --git a/Firmware/variants/MK3-E3DREVO_HF_60W.h b/Firmware/variants/MK3-E3DREVO_HF_60W.h
index 5166dd420..698748980 100644
--- a/Firmware/variants/MK3-E3DREVO_HF_60W.h
+++ b/Firmware/variants/MK3-E3DREVO_HF_60W.h
@@ -165,6 +165,7 @@
 
 //#define DEBUG_PULLUP_CRASH //Test Pullup crash
 
+//#define DEBUG_EEPROM_CHANGES //Uses +1188 bytes Flash +6 bytes SRAM
 //#define DEBUG_BUILD
 //#define DEBUG_SEC_LANG   //secondary language debug output at startup
 //#define DEBUG_XFLASH   //debug external spi flash
diff --git a/Firmware/variants/MK3.h b/Firmware/variants/MK3.h
index f0c74c82f..13d9c220c 100644
--- a/Firmware/variants/MK3.h
+++ b/Firmware/variants/MK3.h
@@ -165,6 +165,7 @@
 
 //#define DEBUG_PULLUP_CRASH //Test Pullup crash
 
+//#define DEBUG_EEPROM_CHANGES //Uses +1188 bytes Flash +6 bytes SRAM
 //#define DEBUG_BUILD
 //#define DEBUG_SEC_LANG   //secondary language debug output at startup
 //#define DEBUG_XFLASH   //debug external spi flash
diff --git a/Firmware/variants/MK3S-E3DREVO.h b/Firmware/variants/MK3S-E3DREVO.h
index f339f04e4..c13631f09 100644
--- a/Firmware/variants/MK3S-E3DREVO.h
+++ b/Firmware/variants/MK3S-E3DREVO.h
@@ -167,6 +167,7 @@
 
 //#define DEBUG_PULLUP_CRASH //Test Pullup crash
 
+//#define DEBUG_EEPROM_CHANGES //Uses +1188 bytes Flash +6 bytes SRAM
 //#define DEBUG_BUILD
 //#define DEBUG_SEC_LANG   //secondary language debug output at startup
 //#define DEBUG_XFLASH   //debug external spi flash
diff --git a/Firmware/variants/MK3S-E3DREVO_HF_60W.h b/Firmware/variants/MK3S-E3DREVO_HF_60W.h
index cce259bf9..24791672d 100644
--- a/Firmware/variants/MK3S-E3DREVO_HF_60W.h
+++ b/Firmware/variants/MK3S-E3DREVO_HF_60W.h
@@ -167,6 +167,7 @@
 
 //#define DEBUG_PULLUP_CRASH //Test Pullup crash
 
+//#define DEBUG_EEPROM_CHANGES //Uses +1188 bytes Flash +6 bytes SRAM
 //#define DEBUG_BUILD
 //#define DEBUG_SEC_LANG   //secondary language debug output at startup
 //#define DEBUG_XFLASH   //debug external spi flash
diff --git a/Firmware/variants/MK3S.h b/Firmware/variants/MK3S.h
index 7dc0ea3b8..22faa70d0 100644
--- a/Firmware/variants/MK3S.h
+++ b/Firmware/variants/MK3S.h
@@ -167,6 +167,7 @@
 
 //#define DEBUG_PULLUP_CRASH //Test Pullup crash
 
+//#define DEBUG_EEPROM_CHANGES //Uses +1188 bytes Flash +6 bytes SRAM
 //#define DEBUG_BUILD
 //#define DEBUG_SEC_LANG   //secondary language debug output at startup
 //#define DEBUG_XFLASH   //debug external spi flash