josh
/
Prusa-Firmware
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Add DEBUG_EEPROM_CHANGES

This commit is contained in:
3d-gussner 2024-02-27 08:56:18 +01:00
parent c7b5fd59ed
commit f9bdb8b8aa
29 changed files with 431 additions and 234 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Firmware/ConfigurationStore.cpp
View File

@ -181,7 +181,7 @@ static const M500_conf default_conf PROGMEM =
void Config_StoreSettings() void Config_StoreSettings()
{ {
strcpy_P(cs.version, default_conf.version); 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 #ifdef THERMAL_MODEL
thermal_model_save_settings(); thermal_model_save_settings();
#endif #endif

16
Firmware/Dcodes.cpp
View File

@ -120,7 +120,7 @@ void write_mem(uint16_t address, uint16_t count, const uint8_t* data, const dcod
switch (type) switch (type)
{ {
case dcode_mem_t::sram: *((uint8_t*)address) = data[i]; break; 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::progmem: break;
case dcode_mem_t::xflash: break; case dcode_mem_t::xflash: break;
} }
@ -255,7 +255,7 @@ void dcode_1()
LOG("D1 - Clear EEPROM and RESET\n"); LOG("D1 - Clear EEPROM and RESET\n");
cli(); cli();
for (int i = 0; i < 8192; i++) 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(); softReset();
} }
#endif #endif
@ -487,12 +487,12 @@ void dcode_8()
else if (strchr_pointer[1+1] == '!') else if (strchr_pointer[1+1] == '!')
{ {
cal_status = 1; cal_status = 1;
eeprom_write_byte((uint8_t*)EEPROM_CALIBRATION_STATUS_PINDA, cal_status); eeprom_write_byte_notify((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_notify(((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_notify(((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_notify(((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_notify(((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_word_notify(((uint16_t*)EEPROM_PROBE_TEMP_SHIFT) + 4, 120); //60C - 300um - 120usteps
} }
else else
{ {

12
Firmware/Filament_sensor.cpp
View File

@ -41,7 +41,7 @@ FSensorBlockRunout::~FSensorBlockRunout() { }
#endif // FILAMENT_SENSOR #endif // FILAMENT_SENSOR
void Filament_sensor::setEnabled(bool enabled) { 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) { if (enabled) {
fsensor.init(); fsensor.init();
} else { } else {
@ -52,21 +52,21 @@ void Filament_sensor::setEnabled(bool enabled) {
void Filament_sensor::setAutoLoadEnabled(bool state, bool updateEEPROM) { void Filament_sensor::setAutoLoadEnabled(bool state, bool updateEEPROM) {
autoLoadEnabled = state; autoLoadEnabled = state;
if (updateEEPROM) { 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) { void Filament_sensor::setRunoutEnabled(bool state, bool updateEEPROM) {
runoutEnabled = state; runoutEnabled = state;
if (updateEEPROM) { 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) { void Filament_sensor::setActionOnError(SensorActionOnError state, bool updateEEPROM) {
sensorActionOnError = state; sensorActionOnError = state;
if (updateEEPROM) { 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) { void IR_sensor_analog::setSensorRevision(SensorRevision rev, bool updateEEPROM) {
sensorRevision = rev; sensorRevision = rev;
if (updateEEPROM) { 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(); resetStepCount();
jamErrCnt = 0; jamErrCnt = 0;
if (updateEEPROM) { if (updateEEPROM) {
eeprom_update_byte((uint8_t *)EEPROM_FSENSOR_JAM_DETECTION, state); eeprom_update_byte_notify((uint8_t *)EEPROM_FSENSOR_JAM_DETECTION, state);
} }
} }

138
Firmware/Marlin_main.cpp
View File

@ -655,12 +655,12 @@ void crashdet_cancel() {
void failstats_reset_print() void failstats_reset_print()
{ {
eeprom_update_byte((uint8_t *)EEPROM_CRASH_COUNT_X, 0); eeprom_update_byte_notify((uint8_t *)EEPROM_CRASH_COUNT_X, 0);
eeprom_update_byte((uint8_t *)EEPROM_CRASH_COUNT_Y, 0); eeprom_update_byte_notify((uint8_t *)EEPROM_CRASH_COUNT_Y, 0);
eeprom_update_byte((uint8_t *)EEPROM_FERROR_COUNT, 0); eeprom_update_byte_notify((uint8_t *)EEPROM_FERROR_COUNT, 0);
eeprom_update_byte((uint8_t *)EEPROM_POWER_COUNT, 0); eeprom_update_byte_notify((uint8_t *)EEPROM_POWER_COUNT, 0);
eeprom_update_byte((uint8_t *)EEPROM_MMU_FAIL, 0); eeprom_update_byte_notify((uint8_t *)EEPROM_MMU_FAIL, 0);
eeprom_update_byte((uint8_t *)EEPROM_MMU_LOAD_FAIL, 0); eeprom_update_byte_notify((uint8_t *)EEPROM_MMU_LOAD_FAIL, 0);
} }
void watchdogEarlyDisable(void) { void watchdogEarlyDisable(void) {
@ -707,19 +707,19 @@ void softReset(void) {
static void factory_reset_stats(){ static void factory_reset_stats(){
eeprom_update_dword((uint32_t *)EEPROM_TOTALTIME, 0); eeprom_update_dword_notify((uint32_t *)EEPROM_TOTALTIME, 0);
eeprom_update_dword((uint32_t *)EEPROM_FILAMENTUSED, 0); eeprom_update_dword_notify((uint32_t *)EEPROM_FILAMENTUSED, 0);
failstats_reset_print(); failstats_reset_print();
eeprom_update_word((uint16_t *)EEPROM_CRASH_COUNT_X_TOT, 0); eeprom_update_word_notify((uint16_t *)EEPROM_CRASH_COUNT_X_TOT, 0);
eeprom_update_word((uint16_t *)EEPROM_CRASH_COUNT_Y_TOT, 0); eeprom_update_word_notify((uint16_t *)EEPROM_CRASH_COUNT_Y_TOT, 0);
eeprom_update_word((uint16_t *)EEPROM_FERROR_COUNT_TOT, 0); eeprom_update_word_notify((uint16_t *)EEPROM_FERROR_COUNT_TOT, 0);
eeprom_update_word((uint16_t *)EEPROM_POWER_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_notify((uint16_t *)EEPROM_MMU_FAIL_TOT, 0);
eeprom_update_word((uint16_t *)EEPROM_MMU_LOAD_FAIL_TOT, 0); eeprom_update_word_notify((uint16_t *)EEPROM_MMU_LOAD_FAIL_TOT, 0);
eeprom_update_dword((uint32_t *)EEPROM_MMU_MATERIAL_CHANGES, 0); eeprom_update_dword_notify((uint32_t *)EEPROM_MMU_MATERIAL_CHANGES, 0);
} }
// Factory reset function // 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 // Force the wizard in "Follow calibration flow" mode at the next boot up
calibration_status_clear(CALIBRATION_FORCE_PREP); 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(); farm_disable();
#ifdef FILAMENT_SENSOR #ifdef FILAMENT_SENSOR
@ -767,7 +767,7 @@ static void factory_reset(char level)
menu_progressbar_init(EEPROM_TOP, PSTR("ERASING all data")); menu_progressbar_init(EEPROM_TOP, PSTR("ERASING all data"));
// Erase EEPROM // Erase EEPROM
for (uint16_t i = 0; i < EEPROM_TOP; i++) { 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_update(i);
} }
menu_progressbar_finish(); menu_progressbar_finish();
@ -921,7 +921,7 @@ void update_sec_lang_from_external_flash()
else else
{ {
//TODO - check sec lang data integrity //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 #endif //XFLASH_DUMP
// prevent crash prompts to reappear once acknowledged // 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 #define KILL_PENDING_FLAG 0x42
@ -1031,7 +1031,7 @@ static void fw_crash_init()
static void fw_kill_init() { static void fw_kill_init() {
if (eeprom_read_byte((uint8_t*)EEPROM_KILL_PENDING_FLAG) == KILL_PENDING_FLAG) { if (eeprom_read_byte((uint8_t*)EEPROM_KILL_PENDING_FLAG) == KILL_PENDING_FLAG) {
// clear pending message event // 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 // display the kill message
PGM_P kill_msg = (PGM_P)eeprom_read_word((uint16_t*)EEPROM_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)) 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")); puts_P(PSTR("SN updated"));
} }
else else
@ -1452,13 +1452,13 @@ void setup()
eeprom_init_default_byte((uint8_t*)EEPROM_TEMP_CAL_ACTIVE, 0); eeprom_init_default_byte((uint8_t*)EEPROM_TEMP_CAL_ACTIVE, 0);
if (eeprom_read_byte((uint8_t*)EEPROM_CALIBRATION_STATUS_PINDA) == 255) { if (eeprom_read_byte((uint8_t*)EEPROM_CALIBRATION_STATUS_PINDA) == 255) {
//eeprom_write_byte((uint8_t*)EEPROM_CALIBRATION_STATUS_PINDA, 0); //eeprom_write_byte_notify((uint8_t*)EEPROM_CALIBRATION_STATUS_PINDA, 0);
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; int16_t z_shift = 0;
for (uint8_t i = 0; i < 5; i++) { 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_UVLO, PowerPanic::NO_PENDING_RECOVERY);
eeprom_init_default_byte((uint8_t*)EEPROM_SD_SORT, 0); 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 //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): case(0b01):
lcd_show_fullscreen_message_and_wait_P(_i("Warning: motherboard type changed.")); ////MSG_CHANGED_MOTHERBOARD c=20 r=4 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; break;
case(0b10): case(0b10):
lcd_show_fullscreen_message_and_wait_P(_i("Warning: printer type changed.")); ////MSG_CHANGED_PRINTER c=20 r=4 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; break;
case(0b11): 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 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_notify((uint16_t*)EEPROM_PRINTER_TYPE, PRINTER_TYPE);
eeprom_write_word((uint16_t*)EEPROM_BOARD_TYPE, MOTHERBOARD); eeprom_write_word_notify((uint16_t*)EEPROM_BOARD_TYPE, MOTHERBOARD);
break; break;
default: break; //no change, show no message default: break; //no change, show no message
} }
@ -1522,7 +1522,7 @@ void setup()
calibration_status &= ~CALIBRATION_STATUS_SELFTEST; 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 (eeprom_fw_version_older_than_p(FW_VERSION_NR)) {
if (!calibration_status_get(CALIBRATION_WIZARD_STEPS)) { if (!calibration_status_get(CALIBRATION_WIZARD_STEPS)) {
@ -1604,7 +1604,7 @@ void setup()
if ( btn == LCD_LEFT_BUTTON_CHOICE) { if ( btn == LCD_LEFT_BUTTON_CHOICE) {
recover_print(0); recover_print(0);
} else { // LCD_MIDDLE_BUTTON_CHOICE } 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) static inline void crash_and_burn(dump_crash_reason reason)
{ {
WRITE(BEEPER, HIGH); 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 #ifdef EMERGENCY_DUMP
xfdump_full_dump_and_reset(reason); xfdump_full_dump_and_reset(reason);
#elif defined(EMERGENCY_SERIAL_DUMP) #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. // Reset the baby step value and the baby step applied flag.
calibration_status_clear(CALIBRATION_STATUS_LIVE_ADJUST); 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. // Complete XYZ calibration.
uint8_t point_too_far_mask = 0; uint8_t point_too_far_mask = 0;
@ -4129,7 +4129,7 @@ void process_commands()
enquecommand_P(MSG_M24); enquecommand_P(MSG_M24);
// Print is recovered, clear the recovery flag // 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) else if (eeprom_read_byte((uint8_t*)EEPROM_UVLO_PRINT_TYPE) == PowerPanic::PRINT_TYPE_HOST)
{ {
@ -4173,7 +4173,7 @@ void process_commands()
lang_reset(); lang_reset();
} else if(code_seen_P(PSTR("Lz"))) { // PRUSA Lz } 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 } else if(code_seen_P(PSTR("FR"))) { // PRUSA FR
// Factory full reset // Factory full reset
@ -4201,8 +4201,8 @@ void process_commands()
strchr_pointer++; // skip 1st char (~ 's') strchr_pointer++; // skip 1st char (~ 's')
strchr_pointer++; // skip 2nd char (~ 'e') strchr_pointer++; // skip 2nd char (~ 'e')
nDiameter=(uint16_t)(code_value()*1000.0+0.5); // [,um] 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_byte_notify((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_word_notify((uint16_t*)EEPROM_NOZZLE_DIAMETER_uM,nDiameter);
} }
else SERIAL_PROTOCOLLN((float)eeprom_read_word((uint16_t*)EEPROM_NOZZLE_DIAMETER_uM)/1000.0); else SERIAL_PROTOCOLLN((float)eeprom_read_word((uint16_t*)EEPROM_NOZZLE_DIAMETER_uM)/1000.0);
} }
@ -4759,7 +4759,7 @@ void process_commands()
serialecho_temperatures(); 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; current_position[Z_AXIS] = MESH_HOME_Z_SEARCH;
plan_buffer_line_curposXYZE(3000 / 60); plan_buffer_line_curposXYZE(3000 / 60);
@ -4783,7 +4783,7 @@ void process_commands()
float temp = (40 + i * 5); 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)); printf_P(_N("\nStep: %d/6 (skipped)\nPINDA temperature: %d Z shift (mm):0\n"), i + 2, (40 + i*5));
if (i >= 0) { 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; 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); 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); lcd_temp_cal_show_result(true);
homing_flag = false; homing_flag = false;
@ -4862,7 +4862,7 @@ void process_commands()
delay_keep_alive(1000); delay_keep_alive(1000);
serialecho_temperatures(); 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; current_position[Z_AXIS] = 5;
plan_buffer_line_curposXYZE(3000 / 60); 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); 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; 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.")); puts_P(_N("Temperature calibration done."));
disable_x(); disable_x();
disable_y(); disable_y();
@ -4921,7 +4921,7 @@ void process_commands()
disable_e0(); disable_e0();
setTargetBed(0); //set bed target temperature back to 0 setTargetBed(0); //set bed target temperature back to 0
lcd_show_fullscreen_message_and_wait_P(_T(MSG_PINDA_CALIBRATION_DONE)); 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_enable(true);
lcd_update(2); lcd_update(2);
@ -5005,7 +5005,7 @@ void process_commands()
}else{ }else{
// Save it to the eeprom // Save it to the eeprom
babystepLoadZ = babystepz; 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 // adjust the Z
babystepsTodoZadd(babystepLoadZ); babystepsTodoZadd(babystepLoadZ);
} }
@ -5494,7 +5494,7 @@ void process_commands()
// Reset the baby step value and the baby step applied flag. // Reset the baby step value and the baby step applied flag.
calibration_status_clear(CALIBRATION_STATUS_LIVE_ADJUST); 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. // Reset the skew and offset in both RAM and EEPROM.
calibration_status_clear(CALIBRATION_STATUS_XYZ); calibration_status_clear(CALIBRATION_STATUS_XYZ);
@ -7940,7 +7940,7 @@ Sigma_Exit:
SERIAL_PROTOCOLLNPGM(" Z VALUE OUT OF RANGE"); SERIAL_PROTOCOLLNPGM(" Z VALUE OUT OF RANGE");
break; 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 else
{ {
@ -7956,7 +7956,7 @@ Sigma_Exit:
{ {
strncpy(strLabel,src,7); 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 else
{ {
@ -7966,7 +7966,7 @@ Sigma_Exit:
if (code_seen('B')) if (code_seen('B'))
{ {
iBedC = code_value_uint8(); 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 else
{ {
@ -7976,7 +7976,7 @@ Sigma_Exit:
if (code_seen('P')) if (code_seen('P'))
{ {
iPindaC = code_value_uint8(); 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 else
{ {
@ -7987,7 +7987,7 @@ Sigma_Exit:
{ {
bIsActive |= code_value_uint8() || (eeprom_read_byte(&(EEPROM_Sheets_base->active_sheet)) == iSel); bIsActive |= code_value_uint8() || (eeprom_read_byte(&(EEPROM_Sheets_base->active_sheet)) == iSel);
if(bIsActive && eeprom_is_sheet_initialized(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 { } else {
bIsActive = 0; bIsActive = 0;
} }
@ -8092,24 +8092,24 @@ Sigma_Exit:
gcode_M861_print_pinda_cal_eeprom(); gcode_M861_print_pinda_cal_eeprom();
} }
else if (code_seen('!')) { // ! - Set factory default values 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 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 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 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 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 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"); SERIAL_PROTOCOLLNPGM("factory restored");
} }
else if (code_seen('Z')) { // Z - Set all values to 0 (effectively disabling PINDA temperature compensation) 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; int16_t z_shift = 0;
for (uint8_t i = 0; i < 5; i++) { 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"); SERIAL_PROTOCOLLNPGM("zerorized");
} }
@ -8118,7 +8118,7 @@ Sigma_Exit:
if (code_seen('I')) { if (code_seen('I')) {
uint8_t index = code_value_uint8(); uint8_t index = code_value_uint8();
if (index < 5) { 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(MSG_OK);
SERIAL_PROTOCOLLNRPGM(_header); SERIAL_PROTOCOLLNRPGM(_header);
gcode_M861_print_pinda_cal_eeprom(); gcode_M861_print_pinda_cal_eeprom();
@ -8439,7 +8439,7 @@ Sigma_Exit:
else if (code_seen('P')) else if (code_seen('P'))
{ {
uint8_t newMenuMode = (mcode_in_progress==914) ? SILENT_MODE_NORMAL : SILENT_MODE_STEALTH; 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; SilentModeMenu = newMenuMode;
//printf_P(_n("tmc2130mode/smm/eep: %d %d %d %d"),tmc2130_mode,SilentModeMenu,eeprom_read_byte((uint8_t*)EEPROM_SILENT), bEnableForce_z); //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()) switch (code_value_uint8())
{ {
case 0: case 0:
eeprom_update_byte((uint8_t *)EEPROM_MMU_ENABLED, false); eeprom_update_byte_notify((uint8_t *)EEPROM_MMU_ENABLED, false);
MMU2::mmu2.Stop(); MMU2::mmu2.Stop();
break; break;
case 1: case 1:
eeprom_update_byte((uint8_t *)EEPROM_MMU_ENABLED, true); eeprom_update_byte_notify((uint8_t *)EEPROM_MMU_ENABLED, true);
MMU2::mmu2.Start(); MMU2::mmu2.Start();
break; break;
default: default:
@ -9736,8 +9736,8 @@ void kill(const char *full_screen_message) {
} }
// update eeprom with the correct kill message to be shown on startup // 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_word_notify((uint16_t*)EEPROM_KILL_MESSAGE, (uint16_t)full_screen_message);
eeprom_write_byte((uint8_t*)EEPROM_KILL_PENDING_FLAG, KILL_PENDING_FLAG); eeprom_write_byte_notify((uint8_t*)EEPROM_KILL_PENDING_FLAG, KILL_PENDING_FLAG);
softReset(); 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 _previous_time = eeprom_init_default_dword((uint32_t *)EEPROM_TOTALTIME, 0); //_previous_time unit: min
uint32_t time_minutes = print_job_timer.duration() / 60; 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_notify((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_FILAMENTUSED, _previous_filament + (total_filament_used / 1000));
print_job_timer.reset(); print_job_timer.reset();
total_filament_used = 0; total_filament_used = 0;
@ -10070,7 +10070,7 @@ void check_babystep()
if ((babystep_z < Z_BABYSTEP_MIN) || (babystep_z > Z_BABYSTEP_MAX)) { 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 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"); 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)), s[(eeprom_read_byte(&(EEPROM_Sheets_base->active_sheet)))].z_offset)),
babystep_z); babystep_z);
lcd_show_fullscreen_message_and_wait_P(PSTR("Z live adjust out of range. Setting to 0. Click to continue.")); 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 // Cancel the state related to a currently saved print
void cancel_saved_printing() 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_start_position[0] = SAVED_START_POSITION_UNSET;
saved_printing_type = PowerPanic::PRINT_TYPE_NONE; saved_printing_type = PowerPanic::PRINT_TYPE_NONE;
saved_printing = false; saved_printing = false;

8
Firmware/Prusa_farm.cpp
View File

@ -403,7 +403,7 @@ void farm_mode_init() {
fsensor.setAutoLoadEnabled(false); fsensor.setAutoLoadEnabled(false);
#endif //FILAMENT_SENSOR #endif //FILAMENT_SENSOR
// ~ FanCheck -> on // ~ 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() { void farm_gcode_g98() {
farm_mode = 1; 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; 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 fCheckModeInit(); // alternatively invoke printer reset
} }
@ -461,7 +461,7 @@ void farm_gcode_g99() {
void farm_disable() { void farm_disable() {
farm_mode = false; 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 #else //PRUSA_FARM

4
Firmware/SpoolJoin.cpp
View File

@ -30,9 +30,9 @@ void SpoolJoin::toggleSpoolJoin()
{ {
if (eeprom_read_byte((uint8_t*)EEPROM_SPOOL_JOIN) == (uint8_t)EEPROM::Disabled) 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 { } 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);
} }
} }

8
Firmware/backlight.cpp
View File

@ -62,10 +62,10 @@ void backlight_wake(const uint8_t flashNo)
void backlight_save() //saves all backlight data to eeprom. void backlight_save() //saves all backlight data to eeprom.
{ {
eeprom_update_byte((uint8_t *)EEPROM_BACKLIGHT_LEVEL_HIGH, backlightLevel_HIGH); eeprom_update_byte_notify((uint8_t *)EEPROM_BACKLIGHT_LEVEL_HIGH, backlightLevel_HIGH);
eeprom_update_byte((uint8_t *)EEPROM_BACKLIGHT_LEVEL_LOW, backlightLevel_LOW); eeprom_update_byte_notify((uint8_t *)EEPROM_BACKLIGHT_LEVEL_LOW, backlightLevel_LOW);
eeprom_update_byte((uint8_t *)EEPROM_BACKLIGHT_MODE, backlightMode); eeprom_update_byte_notify((uint8_t *)EEPROM_BACKLIGHT_MODE, backlightMode);
eeprom_update_word((uint16_t *)EEPROM_BACKLIGHT_TIMEOUT, backlightTimer_period); eeprom_update_word_notify((uint16_t *)EEPROM_BACKLIGHT_TIMEOUT, backlightTimer_period);
} }
void backlight_update() void backlight_update()

2
Firmware/cmdqueue.cpp
View File

@ -484,7 +484,7 @@ void get_command()
if ((*cmd_start == 'G') && (GetPrinterState() != PrinterState::IsSDPrinting)) { if ((*cmd_start == 'G') && (GetPrinterState() != PrinterState::IsSDPrinting)) {
usb_timer.start(); usb_timer.start();
SetPrinterState(PrinterState::IsHostPrinting); //set printer state busy printing to hide LCD menu while USB printing 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) { if (allow_when_stopped == false && Stopped == true) {
// Stopped can be set either during error states (thermal error: cannot continue), or // Stopped can be set either during error states (thermal error: cannot continue), or

205
Firmware/eeprom.cpp
View File

@ -26,7 +26,7 @@ void eeprom_init()
eeprom_init_default_dword((uint32_t*)EEPROM_MMU_MATERIAL_CHANGES, 0); eeprom_init_default_dword((uint32_t*)EEPROM_MMU_MATERIAL_CHANGES, 0);
if (eeprom_read_byte(&(EEPROM_Sheets_base->active_sheet)) == EEPROM_EMPTY_VALUE) 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) // 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) // Sheet 1 uses the previous Live adjust Z (@EEPROM_BABYSTEP_Z)
int last_babystep = eeprom_read_word((uint16_t *)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 // initialize custom mendel name in eeprom
if (eeprom_read_byte((uint8_t*)EEPROM_CUSTOM_MENDEL_NAME) == EEPROM_EMPTY_VALUE) { if (eeprom_read_byte((uint8_t*)EEPROM_CUSTOM_MENDEL_NAME) == EEPROM_EMPTY_VALUE) {
//SERIAL_ECHOLN("Init Custom Mendel Name"); //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"); } //else SERIAL_ECHOLN("Found Custom Mendel Name");
#ifdef PINDA_TEMP_COMP #ifdef PINDA_TEMP_COMP
@ -66,11 +66,11 @@ void eeprom_init()
} }
void eeprom_adjust_bed_reset() { void eeprom_adjust_bed_reset() {
eeprom_update_byte((uint8_t*)EEPROM_BED_CORRECTION_VALID, 1); eeprom_update_byte_notify((uint8_t*)EEPROM_BED_CORRECTION_VALID, 1);
eeprom_update_byte((uint8_t*)EEPROM_BED_CORRECTION_LEFT, 0); eeprom_update_byte_notify((uint8_t*)EEPROM_BED_CORRECTION_LEFT, 0);
eeprom_update_byte((uint8_t*)EEPROM_BED_CORRECTION_RIGHT, 0); eeprom_update_byte_notify((uint8_t*)EEPROM_BED_CORRECTION_RIGHT, 0);
eeprom_update_byte((uint8_t*)EEPROM_BED_CORRECTION_FRONT, 0); eeprom_update_byte_notify((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_REAR, 0);
} }
//! @brief Get default sheet name for index //! @brief Get default sheet name for index
@ -137,12 +137,175 @@ int8_t eeprom_next_initialized_sheet(int8_t sheet)
return -1; 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() void eeprom_switch_to_next_sheet()
{ {
int8_t sheet = eeprom_read_byte(&(EEPROM_Sheets_base->active_sheet)); int8_t sheet = eeprom_read_byte(&(EEPROM_Sheets_base->active_sheet));
sheet = eeprom_next_initialized_sheet(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) { 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; const uint8_t *src = (const uint8_t*)__src;
uint8_t *dst = (uint8_t*)__dst; uint8_t *dst = (uint8_t*)__dst;
while (__n--) { 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) { 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) { 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) { 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) { 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) { 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) { 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) { 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 __attribute__((noinline)) eeprom_init_default_byte(uint8_t *__p, uint8_t def) {
uint8_t val = eeprom_read_byte(__p); uint8_t val = eeprom_read_byte(__p);
if (val == EEPROM_EMPTY_VALUE) { if (val == EEPROM_EMPTY_VALUE) {
eeprom_write_byte(__p, def); eeprom_write_byte_notify(__p, def);
return def; return def;
} }
return val; 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 __attribute__((noinline)) eeprom_init_default_word(uint16_t *__p, uint16_t def) {
uint16_t val = eeprom_read_word(__p); uint16_t val = eeprom_read_word(__p);
if (val == EEPROM_EMPTY_VALUE16) { if (val == EEPROM_EMPTY_VALUE16) {
eeprom_write_word(__p, def); eeprom_write_word_notify(__p, def);
return def; return def;
} }
return val; 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 __attribute__((noinline)) eeprom_init_default_dword(uint32_t *__p, uint32_t def) {
uint32_t val = eeprom_read_dword(__p); uint32_t val = eeprom_read_dword(__p);
if (val == EEPROM_EMPTY_VALUE32) { if (val == EEPROM_EMPTY_VALUE32) {
eeprom_write_dword(__p, def); eeprom_write_dword_notify(__p, def);
return def; return def;
} }
return val; 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) { void __attribute__((noinline)) eeprom_init_default_float(float *__p, float def) {
if (eeprom_read_dword((uint32_t*)__p) == EEPROM_EMPTY_VALUE32) 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) { void __attribute__((noinline)) eeprom_init_default_block(void *__p, size_t __n, const void *def) {
if (!eeprom_is_initialized_block(__p, __n)) 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) { void __attribute__((noinline)) eeprom_init_default_block_P(void *__p, size_t __n, const void *def) {

24
Firmware/eeprom.h
View File

@ -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_float(float *__p, float def);
void eeprom_init_default_block(void *__p, size_t __n, const void *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); 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
#endif // EEPROM_H #endif // EEPROM_H

2
Firmware/fancheck.cpp
View File

@ -238,7 +238,7 @@ bool extruder_altfan_detect()
void altfanOverride_toggle() void altfanOverride_toggle()
{ {
altfanStatus.altfanOverride = !altfanStatus.altfanOverride; 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() bool altfanOverride_get()

30
Firmware/mesh_bed_calibration.cpp
View File

@ -373,7 +373,7 @@ BedSkewOffsetDetectionResultType calculate_machine_skew_and_offset_LS(
angleDiff = fabs(a2 - a1); angleDiff = fabs(a2 - a1);
/// XY skew and Y-bed skew /// XY skew and Y-bed skew
DBG(_n("Measured skews: %f %f\n"), degrees(a2 - a1), degrees(a2)); 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) if (angleDiff > bed_skew_angle_mild)
result = (angleDiff > bed_skew_angle_extreme) ? result = (angleDiff > bed_skew_angle_extreme) ?
BED_SKEW_OFFSET_DETECTION_SKEW_EXTREME : BED_SKEW_OFFSET_DETECTION_SKEW_EXTREME :
@ -669,16 +669,16 @@ BedSkewOffsetDetectionResultType calculate_machine_skew_and_offset_LS(
*/ */
void reset_bed_offset_and_skew() void reset_bed_offset_and_skew()
{ {
eeprom_update_dword((uint32_t*)(EEPROM_BED_CALIBRATION_CENTER+0), 0x0FFFFFFFF); eeprom_update_dword_notify((uint32_t*)(EEPROM_BED_CALIBRATION_CENTER+0), 0x0FFFFFFFF);
eeprom_update_dword((uint32_t*)(EEPROM_BED_CALIBRATION_CENTER+4), 0x0FFFFFFFF); eeprom_update_dword_notify((uint32_t*)(EEPROM_BED_CALIBRATION_CENTER+4), 0x0FFFFFFFF);
eeprom_update_dword((uint32_t*)(EEPROM_BED_CALIBRATION_VEC_X +0), 0x0FFFFFFFF); eeprom_update_dword_notify((uint32_t*)(EEPROM_BED_CALIBRATION_VEC_X +0), 0x0FFFFFFFF);
eeprom_update_dword((uint32_t*)(EEPROM_BED_CALIBRATION_VEC_X +4), 0x0FFFFFFFF); eeprom_update_dword_notify((uint32_t*)(EEPROM_BED_CALIBRATION_VEC_X +4), 0x0FFFFFFFF);
eeprom_update_dword((uint32_t*)(EEPROM_BED_CALIBRATION_VEC_Y +0), 0x0FFFFFFFF); eeprom_update_dword_notify((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_VEC_Y +4), 0x0FFFFFFFF);
// Reset the 8 16bit offsets. // Reset the 8 16bit offsets.
for (int8_t i = 0; i < 4; ++ i) 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() 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); world2machine_update(vec_x, vec_y, cntr);
// Fearlessly store the calibration values into the eeprom. // Fearlessly store the calibration values into the eeprom.
eeprom_update_block(&cntr[0], (float*)(EEPROM_BED_CALIBRATION_CENTER), 8); eeprom_update_block_notify(&cntr[0], (float*)(EEPROM_BED_CALIBRATION_CENTER), 8);
eeprom_update_block(&vec_x[0], (float*)(EEPROM_BED_CALIBRATION_VEC_X), 8); eeprom_update_block_notify(&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(&vec_y[0], (float*)(EEPROM_BED_CALIBRATION_VEC_Y), 8);
#ifdef SUPPORT_VERBOSITY #ifdef SUPPORT_VERBOSITY
if (verbosity_level >= 10) { 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); world2machine_update(vec_x, vec_y, cntr);
// Fearlessly store the calibration values into the eeprom. // Fearlessly store the calibration values into the eeprom.
eeprom_update_block(&cntr[0], (float*)(EEPROM_BED_CALIBRATION_CENTER), 8); eeprom_update_block_notify(&cntr[0], (float*)(EEPROM_BED_CALIBRATION_CENTER), 8);
eeprom_update_block(&vec_x[0], (float*)(EEPROM_BED_CALIBRATION_VEC_X), 8); eeprom_update_block_notify(&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(&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. // Correct the current_position to match the transformed coordinate system after world2machine_rotation_and_skew and world2machine_shift were set.
world2machine_update_current(); world2machine_update_current();
@ -2934,7 +2934,7 @@ bool sample_mesh_and_store_reference()
continue; continue;
float dif = mbl.z_values[j][i] - mbl.z_values[0][0]; float dif = mbl.z_values[j][i] - mbl.z_values[0][0];
int16_t dif_quantized = int16_t(floor(dif * 100.f + 0.5f)); 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 #if 0
{ {
uint16_t z_offset_u = eeprom_read_word((uint16_t*)addr); uint16_t z_offset_u = eeprom_read_word((uint16_t*)addr);

2
Firmware/mmu2_reporting.cpp
View File

@ -346,7 +346,7 @@ void TryLoadUnloadReporter::DumpToSerial(){
/// Disables MMU in EEPROM /// Disables MMU in EEPROM
void DisableMMUInSettings() { void DisableMMUInSettings() {
eeprom_update_byte((uint8_t *)EEPROM_MMU_ENABLED, false); eeprom_update_byte_notify((uint8_t *)EEPROM_MMU_ENABLED, false);
mmu2.Status(); mmu2.Status();
} }

50
Firmware/power_panic.cpp
View File

@ -113,11 +113,11 @@ void uvlo_() {
// mesh bed leveling offset value. // mesh bed leveling offset value.
logical_z -= mbl.get_z(saved_pos[X_AXIS], saved_pos[Y_AXIS]); 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 // Store the print E position before we lose track
eeprom_update_float((float*)(EEPROM_UVLO_CURRENT_POSITION_E), saved_pos[E_AXIS]); eeprom_update_float_notify((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_byte_notify((uint8_t*)EEPROM_UVLO_E_ABS, !saved_extruder_relative_mode);
// Clean the input command queue, inhibit serial processing using saved_printing // Clean the input command queue, inhibit serial processing using saved_printing
cmdqueue_reset(); cmdqueue_reset();
@ -149,7 +149,7 @@ void uvlo_() {
poweroff_z(); poweroff_z();
// Write the file position. // 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. // 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) 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; uint8_t iy = mesh_point / MESH_NUM_X_POINTS;
// Scale the z value to 1u resolution. // 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; 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 // 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. // Store the current position.
eeprom_update_float((float*)(EEPROM_UVLO_CURRENT_POSITION + 0), saved_pos[X_AXIS]); eeprom_update_float_notify((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 + 4), saved_pos[Y_AXIS]);
// Store the current feed rate, temperatures, fan speed and extruder multipliers (flow rates) // 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_notify((uint16_t*)EEPROM_UVLO_FEEDRATE, saved_feedrate2);
eeprom_update_word((uint16_t*)EEPROM_UVLO_FEEDMULTIPLY, feedmultiply); eeprom_update_word_notify((uint16_t*)EEPROM_UVLO_FEEDMULTIPLY, feedmultiply);
eeprom_update_word((uint16_t*)EEPROM_UVLO_TARGET_HOTEND, saved_extruder_temperature); eeprom_update_word_notify((uint16_t*)EEPROM_UVLO_TARGET_HOTEND, saved_extruder_temperature);
eeprom_update_byte((uint8_t*)EEPROM_UVLO_TARGET_BED, saved_bed_temperature); eeprom_update_byte_notify((uint8_t*)EEPROM_UVLO_TARGET_BED, saved_bed_temperature);
eeprom_update_byte((uint8_t*)EEPROM_UVLO_FAN_SPEED, saved_fan_speed); eeprom_update_byte_notify((uint8_t*)EEPROM_UVLO_FAN_SPEED, saved_fan_speed);
eeprom_update_float((float*)(EEPROM_EXTRUDER_MULTIPLIER_0), extruder_multiplier[0]); eeprom_update_float_notify((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_EXTRUDEMULTIPLY), (uint16_t)extrudemultiply);
eeprom_update_float((float*)(EEPROM_UVLO_ACCELL), cs.acceleration); eeprom_update_float_notify((float*)(EEPROM_UVLO_ACCELL), cs.acceleration);
eeprom_update_float((float*)(EEPROM_UVLO_RETRACT_ACCELL), cs.retract_acceleration); eeprom_update_float_notify((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_TRAVEL_ACCELL), cs.travel_acceleration);
// Store the saved target // 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_word_notify((uint16_t*)EEPROM_UVLO_SAVED_SEGMENT_IDX, saved_segment_idx);
eeprom_update_byte((uint8_t*)EEPROM_UVLO_PRINT_TYPE, saved_printing_type); eeprom_update_byte_notify((uint8_t*)EEPROM_UVLO_PRINT_TYPE, saved_printing_type);
#ifdef LIN_ADVANCE #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 #endif
// Finally store the "power outage" flag. // 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 // Increment power failure counter
eeprom_increment_byte((uint8_t*)EEPROM_POWER_COUNT); eeprom_increment_byte((uint8_t*)EEPROM_POWER_COUNT);
@ -260,11 +260,11 @@ static void uvlo_tiny() {
poweroff_z(); poweroff_z();
// Update Z position // 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. // 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 // Increment power failure counter
eeprom_increment_byte((uint8_t*)EEPROM_POWER_COUNT); eeprom_increment_byte((uint8_t*)EEPROM_POWER_COUNT);

2
Firmware/sound.cpp
View File

@ -30,7 +30,7 @@ void Sound_Init(void)
void Sound_SaveMode(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) void Sound_CycleState(void)

22
Firmware/temperature.cpp
View File

@ -2431,17 +2431,17 @@ void thermal_model_load_settings()
void thermal_model_save_settings() void thermal_model_save_settings()
{ {
eeprom_update_byte((uint8_t*)EEPROM_THERMAL_MODEL_ENABLE, thermal_model::enabled); eeprom_update_byte_notify((uint8_t*)EEPROM_THERMAL_MODEL_ENABLE, thermal_model::enabled);
eeprom_update_float((float*)EEPROM_THERMAL_MODEL_P, thermal_model::data.P); eeprom_update_float_notify((float*)EEPROM_THERMAL_MODEL_P, thermal_model::data.P);
eeprom_update_float((float*)EEPROM_THERMAL_MODEL_U, thermal_model::data.U); eeprom_update_float_notify((float*)EEPROM_THERMAL_MODEL_U, thermal_model::data.U);
eeprom_update_float((float*)EEPROM_THERMAL_MODEL_V, thermal_model::data.V); eeprom_update_float_notify((float*)EEPROM_THERMAL_MODEL_V, thermal_model::data.V);
eeprom_update_float((float*)EEPROM_THERMAL_MODEL_C, thermal_model::data.C); eeprom_update_float_notify((float*)EEPROM_THERMAL_MODEL_C, thermal_model::data.C);
eeprom_update_float((float*)EEPROM_THERMAL_MODEL_D, thermal_model::data.fS); eeprom_update_float_notify((float*)EEPROM_THERMAL_MODEL_D, thermal_model::data.fS);
eeprom_update_word((uint16_t*)EEPROM_THERMAL_MODEL_L, thermal_model::data.L); eeprom_update_word_notify((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_block_notify(&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_notify((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_notify((float*)EEPROM_THERMAL_MODEL_W, thermal_model::data.warn);
eeprom_update_float((float*)EEPROM_THERMAL_MODEL_E, thermal_model::data.err); eeprom_update_float_notify((float*)EEPROM_THERMAL_MODEL_E, thermal_model::data.err);
} }
namespace thermal_model_cal { namespace thermal_model_cal {

4
Firmware/tmc2130.cpp
View File

@ -1032,8 +1032,8 @@ bool tmc2130_home_calibrate(uint8_t axis)
bubblesort_uint8(cnt, cl, val); bubblesort_uint8(cnt, cl, val);
tmc2130_home_origin[axis] = val[cl-1]; tmc2130_home_origin[axis] = val[cl-1];
printf_P(PSTR("result value: %d\n"), tmc2130_home_origin[axis]); 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]); 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((uint8_t*)EEPROM_TMC2130_HOME_Y_ORIGIN, tmc2130_home_origin[Y_AXIS]); else if (axis == Y_AXIS) eeprom_update_byte_notify((uint8_t*)EEPROM_TMC2130_HOME_Y_ORIGIN, tmc2130_home_origin[Y_AXIS]);
return true; return true;
} }

108
Firmware/ultralcd.cpp
View File

@ -1732,7 +1732,7 @@ static void lcd_support_menu()
void lcd_set_fan_check() { void lcd_set_fan_check() {
fans_check_enabled = !fans_check_enabled; 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 #ifdef FANCHECK
if (fans_check_enabled == false) fan_check_error = EFCE_OK; //reset error if fanCheck is disabled during error. Allows resuming print. if (fans_check_enabled == false) fan_check_error = EFCE_OK; //reset error if fanCheck is disabled during error. Allows resuming print.
#endif //FANCHECK #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)) if (EEPROM_MMU_CUTTER_ENABLED_enabled == eeprom_read_byte((uint8_t*)EEPROM_MMU_CUTTER_ENABLED))
{ {
#ifndef MMU_ALWAYS_CUT #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 #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)) 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 #endif //MMU_ALWAYS_CUT
else 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 #endif //MMU_HAS_CUTTER
@ -2638,12 +2638,12 @@ static void lcd_babystep_z()
{ {
// Only update the EEPROM when leaving the menu. // Only update the EEPROM when leaving the menu.
uint8_t active_sheet=eeprom_read_byte(&(EEPROM_Sheets_base->active_sheet)); 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. // 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 #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 #endif //PINDA_THERMISTOR
calibration_status_set(CALIBRATION_STATUS_LIVE_ADJUST); calibration_status_set(CALIBRATION_STATUS_LIVE_ADJUST);
} }
@ -2699,11 +2699,11 @@ void lcd_adjust_bed(void)
MENU_BEGIN(); MENU_BEGIN();
// leaving menu - this condition must be immediately before MENU_ITEM_BACK_P // leaving menu - this condition must be immediately before MENU_ITEM_BACK_P
ON_MENU_LEAVE( ON_MENU_LEAVE(
eeprom_update_byte((uint8_t*)EEPROM_BED_CORRECTION_LEFT, (uint8_t)_md->left); eeprom_update_byte_notify((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_notify((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_notify((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_notify((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_VALID, 1);
); );
MENU_ITEM_BACK_P(_T(MSG_BACK)); 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 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 setTargetBed(0); //set bed target temperature back to 0
// Store boolean result // Store boolean result
eeprom_update_byte((uint8_t*)EEPROM_CALIBRATION_STATUS_PINDA, result); eeprom_update_byte_notify((uint8_t*)EEPROM_CALIBRATION_STATUS_PINDA, result);
eeprom_update_byte((uint8_t*)EEPROM_TEMP_CAL_ACTIVE, result); eeprom_update_byte_notify((uint8_t*)EEPROM_TEMP_CAL_ACTIVE, result);
if (result) { if (result) {
SERIAL_ECHOLNPGM("PINDA calibration done. Continue with pressing the knob."); 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; case SD_SORT_ALPHA: sdSort = SD_SORT_NONE; break;
default: sdSort = SD_SORT_TIME; 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; card.presort_flag = true;
} }
#endif //SDCARD_SORT_ALPHA #endif //SDCARD_SORT_ALPHA
@ -3406,7 +3406,7 @@ static void lcd_silent_mode_set() {
default: SilentModeMenu = SILENT_MODE_POWER; break; // (probably) not needed default: SilentModeMenu = SILENT_MODE_POWER; break; // (probably) not needed
#endif //TMC2130 #endif //TMC2130
} }
eeprom_update_byte((unsigned char *)EEPROM_SILENT, SilentModeMenu); eeprom_update_byte_notify((unsigned char *)EEPROM_SILENT, SilentModeMenu);
#ifdef TMC2130 #ifdef TMC2130
if (blocks_queued()) if (blocks_queued())
{ {
@ -3534,14 +3534,14 @@ void lcd_mesh_calibration_z()
void lcd_temp_calibration_set() { void lcd_temp_calibration_set() {
bool temp_cal_active = eeprom_read_byte((unsigned char *)EEPROM_TEMP_CAL_ACTIVE); bool temp_cal_active = eeprom_read_byte((unsigned char *)EEPROM_TEMP_CAL_ACTIVE);
temp_cal_active = !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 #ifdef HAS_SECOND_SERIAL_PORT
void lcd_second_serial_set() { void lcd_second_serial_set() {
if(selectedSerialPort == 1) selectedSerialPort = 0; if(selectedSerialPort == 1) selectedSerialPort = 0;
else selectedSerialPort = 1; 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); MYSERIAL.begin(BAUDRATE);
} }
#endif //HAS_SECOND_SERIAL_PORT #endif //HAS_SECOND_SERIAL_PORT
@ -3554,7 +3554,7 @@ void lcd_calibrate_pinda() {
void lcd_toshiba_flash_air_compatibility_toggle() void lcd_toshiba_flash_air_compatibility_toggle()
{ {
card.ToshibaFlashAir_enable(! card.ToshibaFlashAir_isEnabled()); 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? //! @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) 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 // If the knob was clicked, don't produce feedback
@ -3781,7 +3781,7 @@ void lcd_wizard(WizState state)
uint8_t wizard_event; uint8_t wizard_event;
// Make sure EEPROM_WIZARD_ACTIVE is true if entering using different entry point // Make sure EEPROM_WIZARD_ACTIVE is true if entering using different entry point
// other than WizState::Run - it is useful for debugging wizard. // 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; 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); 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) { if (wizard_event == LCD_LEFT_BUTTON_CHOICE) {
state = S::Restore; state = S::Restore;
eeprom_update_byte((uint8_t*)EEPROM_WIZARD_ACTIVE, 1); eeprom_update_byte_notify((uint8_t*)EEPROM_WIZARD_ACTIVE, 1);
} else { } else {
// user interrupted // user interrupted
eeprom_update_byte((uint8_t*)EEPROM_WIZARD_ACTIVE, 0); eeprom_update_byte_notify((uint8_t*)EEPROM_WIZARD_ACTIVE, 0);
end = true; end = true;
} }
} }
@ -3934,7 +3934,7 @@ void lcd_wizard(WizState state)
break; break;
case S::Finish: case S::Finish:
case S::Failed: case S::Failed:
eeprom_update_byte((uint8_t*)EEPROM_WIZARD_ACTIVE, 0); eeprom_update_byte_notify((uint8_t*)EEPROM_WIZARD_ACTIVE, 0);
end = true; end = true;
break; break;
} }
@ -4218,7 +4218,7 @@ switch(oCheckMode)
default: default:
oCheckMode=ClCheckMode::_None; 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 \ #define SETTINGS_MODE \
@ -4264,8 +4264,8 @@ static void lcd_nozzle_diameter_cycle(void) {
oNozzleDiameter=ClNozzleDiameter::_Diameter_400; oNozzleDiameter=ClNozzleDiameter::_Diameter_400;
nDiameter=400; nDiameter=400;
} }
eeprom_update_byte((uint8_t*)EEPROM_NOZZLE_DIAMETER,(uint8_t)oNozzleDiameter); eeprom_update_byte_notify((uint8_t*)EEPROM_NOZZLE_DIAMETER,(uint8_t)oNozzleDiameter);
eeprom_update_word((uint16_t*)EEPROM_NOZZLE_DIAMETER_uM,nDiameter); eeprom_update_word_notify((uint16_t*)EEPROM_NOZZLE_DIAMETER_uM,nDiameter);
} }
#define SETTINGS_NOZZLE \ #define SETTINGS_NOZZLE \
@ -4298,7 +4298,7 @@ switch(oCheckModel)
default: default:
oCheckModel=ClCheckModel::_None; 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 \ #define SETTINGS_MODEL \
@ -4337,7 +4337,7 @@ switch(oCheckVersion)
default: default:
oCheckVersion=ClCheckVersion::_None; 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 \ #define SETTINGS_VERSION \
@ -4541,10 +4541,10 @@ static void lcd_settings_menu()
#ifdef TMC2130 #ifdef TMC2130
static void lcd_ustep_linearity_menu_save() 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_notify((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_notify((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_notify((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_E_FAC, tmc2130_wave_fac[E_AXIS]);
} }
#endif //TMC2130 #endif //TMC2130
@ -5051,7 +5051,7 @@ void lcd_resume_usb_print()
static void change_sheet() 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); menu_back(3);
} }
@ -5096,7 +5096,7 @@ static void lcd_rename_sheet_menu()
} }
else else
{ {
eeprom_update_block(menuData->name, eeprom_update_block_notify(menuData->name,
EEPROM_Sheets_base->s[selected_sheet].name, EEPROM_Sheets_base->s[selected_sheet].name,
sizeof(Sheet::name)); sizeof(Sheet::name));
menu_back(); menu_back();
@ -5108,8 +5108,8 @@ static void lcd_reset_sheet()
{ {
SheetName sheetName; SheetName sheetName;
eeprom_default_sheet_name(selected_sheet, 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_word_notify(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_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))) if (selected_sheet == eeprom_read_byte(&(EEPROM_Sheets_base->active_sheet)))
{ {
eeprom_switch_to_next_sheet(); eeprom_switch_to_next_sheet();
@ -5123,7 +5123,7 @@ static void lcd_reset_sheet()
//! @brief Activate selected_sheet and run first layer calibration //! @brief Activate selected_sheet and run first layer calibration
static void activate_calibrate_sheet() 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(); lcd_first_layer_calibration_reset();
} }
@ -5544,14 +5544,14 @@ static void lcd_tune_menu()
static void mbl_magnets_elimination_toggle() { static void mbl_magnets_elimination_toggle() {
bool magnet_elimination = (eeprom_read_byte((uint8_t*)EEPROM_MBL_MAGNET_ELIMINATION) > 0); bool magnet_elimination = (eeprom_read_byte((uint8_t*)EEPROM_MBL_MAGNET_ELIMINATION) > 0);
magnet_elimination = !magnet_elimination; 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() { static void mbl_mesh_toggle() {
uint8_t mesh_nr = eeprom_read_byte((uint8_t*)EEPROM_MBL_POINTS_NR); uint8_t mesh_nr = eeprom_read_byte((uint8_t*)EEPROM_MBL_POINTS_NR);
if(mesh_nr == 3) mesh_nr = 7; if(mesh_nr == 3) mesh_nr = 7;
else mesh_nr = 3; 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() { static void mbl_probe_nr_toggle() {
@ -5562,7 +5562,7 @@ static void mbl_probe_nr_toggle() {
case 5: mbl_z_probe_nr = 1; break; case 5: mbl_z_probe_nr = 1; break;
default: mbl_z_probe_nr = 3; 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() static void lcd_mesh_bed_leveling_settings()
@ -6202,7 +6202,7 @@ bool lcd_selftest()
bres &= tmc2130_home_calibrate(Y_AXIS); bres &= tmc2130_home_calibrate(Y_AXIS);
_progress = lcd_selftest_screen(TestScreen::Home, 2, 2, true, 0); _progress = lcd_selftest_screen(TestScreen::Home, 2, 2, true, 0);
if (bres) 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; _result = bres;
} }
#endif //TMC2130 #endif //TMC2130
@ -6332,7 +6332,7 @@ static bool lcd_selfcheck_axis_sg(uint8_t axis) {
uint16_t sg1 = tmc2130_sg_measure_stop(); uint16_t sg1 = tmc2130_sg_measure_stop();
printf_P(PSTR("%c AXIS SG1=%d\n"), 'X'+axis, sg1); 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); current_position_final = st_get_position_mm(axis);
measured_axis_length[0] = fabs(current_position_final - current_position_init); 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++) { for (uint_least8_t i = 0; i < 8; i++) {
if (selected_filename[i] == '\0' || selected_filename[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 //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; break;
} }
else { 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++) for (uint_least8_t i = 0; i < 3; i++)
{ {
if (extension_ptr == NULL || extension_ptr[i] == '\0') { 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 { } 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(); 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++) { 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)) { 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) // 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(); 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 // @@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. // 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() { void WorkaroundPrusaSN() {
const char *SN = PSTR("CZPXInvalidSerialNr"); const char *SN = PSTR("CZPXInvalidSerialNr");
for (uint8_t i = 0; i < 20; i++) { 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 #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" pinda_temp_compensation = 1; // But for MK3/S it should be 1 so SuperPINDA is "active"
else else
pinda_temp_compensation = !pinda_temp_compensation; 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_ECHOLNPGM("SuperPINDA:");
SERIAL_ECHOLN(pinda_temp_compensation); SERIAL_ECHOLN(pinda_temp_compensation);
} }
@ -7514,7 +7514,7 @@ void lcd_heat_bed_on_load_toggle()
value = 1; value = 1;
else else
value = !value; 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() { void lcd_reprint_from_eeprom() {

16
Firmware/util.cpp
View File

@ -227,13 +227,13 @@ bool show_upgrade_dialog_if_version_newer(const char *version_string)
void update_current_firmware_version_to_eeprom() void update_current_firmware_version_to_eeprom()
{ {
for (int8_t i = 0; i < FW_PRUSA3D_MAGIC_LEN; ++ i){ 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_notify((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_notify((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_REVISION, (uint16_t)pgm_read_word(&FW_VERSION_NR[2]));
// See FirmwareRevisionFlavorType for the definition of firmware flavors. // 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; ClNozzleDiameter oNozzleDiameter;
@ -247,7 +247,7 @@ void fCheckModeInit() {
if (farm_mode) { if (farm_mode) {
oCheckMode = ClCheckMode::_Strict; 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); 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); CalibrationStatus status = eeprom_read_byte((uint8_t*)EEPROM_CALIBRATION_STATUS_V2);
status |= components; 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) void calibration_status_clear(CalibrationStatus components)
{ {
CalibrationStatus status = eeprom_read_byte((uint8_t*)EEPROM_CALIBRATION_STATUS_V2); CalibrationStatus status = eeprom_read_byte((uint8_t*)EEPROM_CALIBRATION_STATUS_V2);
status &= ~components; status &= ~components;
eeprom_update_byte((uint8_t*)EEPROM_CALIBRATION_STATUS_V2, status); eeprom_update_byte_notify((uint8_t*)EEPROM_CALIBRATION_STATUS_V2, status);
} }

1
Firmware/variants/MK25-RAMBo10a.h
View File

@ -126,6 +126,7 @@
#define DEBUG_DCODE2 #define DEBUG_DCODE2
#define DEBUG_DCODE3 #define DEBUG_DCODE3
//#define DEBUG_EEPROM_CHANGES //Uses +1188 bytes Flash +6 bytes SRAM
//#define DEBUG_BUILD //#define DEBUG_BUILD
#ifdef DEBUG_BUILD #ifdef DEBUG_BUILD
//#define _NO_ASM //#define _NO_ASM

1
Firmware/variants/MK25-RAMBo13a.h
View File

@ -127,6 +127,7 @@
#define DEBUG_DCODE2 #define DEBUG_DCODE2
#define DEBUG_DCODE3 #define DEBUG_DCODE3
//#define DEBUG_EEPROM_CHANGES //Uses +1188 bytes Flash +6 bytes SRAM
//#define DEBUG_BUILD //#define DEBUG_BUILD
#ifdef DEBUG_BUILD #ifdef DEBUG_BUILD
//#define _NO_ASM //#define _NO_ASM

1
Firmware/variants/MK25S-RAMBo10a.h
View File

@ -126,6 +126,7 @@
#define DEBUG_DCODE2 #define DEBUG_DCODE2
#define DEBUG_DCODE3 #define DEBUG_DCODE3
//#define DEBUG_EEPROM_CHANGES //Uses +1188 bytes Flash +6 bytes SRAM
//#define DEBUG_BUILD //#define DEBUG_BUILD
#ifdef DEBUG_BUILD #ifdef DEBUG_BUILD
//#define _NO_ASM //#define _NO_ASM

1
Firmware/variants/MK25S-RAMBo13a.h
View File

@ -127,6 +127,7 @@
#define DEBUG_DCODE2 #define DEBUG_DCODE2
#define DEBUG_DCODE3 #define DEBUG_DCODE3
//#define DEBUG_EEPROM_CHANGES //Uses +1188 bytes Flash +6 bytes SRAM
//#define DEBUG_BUILD //#define DEBUG_BUILD
#ifdef DEBUG_BUILD #ifdef DEBUG_BUILD
//#define _NO_ASM //#define _NO_ASM

1
Firmware/variants/MK3-E3DREVO.h
View File

@ -165,6 +165,7 @@
//#define DEBUG_PULLUP_CRASH //Test Pullup crash //#define DEBUG_PULLUP_CRASH //Test Pullup crash
//#define DEBUG_EEPROM_CHANGES //Uses +1188 bytes Flash +6 bytes SRAM
//#define DEBUG_BUILD //#define DEBUG_BUILD
//#define DEBUG_SEC_LANG //secondary language debug output at startup //#define DEBUG_SEC_LANG //secondary language debug output at startup
//#define DEBUG_XFLASH //debug external spi flash //#define DEBUG_XFLASH //debug external spi flash

1
Firmware/variants/MK3-E3DREVO_HF_60W.h
View File

@ -165,6 +165,7 @@
//#define DEBUG_PULLUP_CRASH //Test Pullup crash //#define DEBUG_PULLUP_CRASH //Test Pullup crash
//#define DEBUG_EEPROM_CHANGES //Uses +1188 bytes Flash +6 bytes SRAM
//#define DEBUG_BUILD //#define DEBUG_BUILD
//#define DEBUG_SEC_LANG //secondary language debug output at startup //#define DEBUG_SEC_LANG //secondary language debug output at startup
//#define DEBUG_XFLASH //debug external spi flash //#define DEBUG_XFLASH //debug external spi flash

1
Firmware/variants/MK3.h
View File

@ -165,6 +165,7 @@
//#define DEBUG_PULLUP_CRASH //Test Pullup crash //#define DEBUG_PULLUP_CRASH //Test Pullup crash
//#define DEBUG_EEPROM_CHANGES //Uses +1188 bytes Flash +6 bytes SRAM
//#define DEBUG_BUILD //#define DEBUG_BUILD
//#define DEBUG_SEC_LANG //secondary language debug output at startup //#define DEBUG_SEC_LANG //secondary language debug output at startup
//#define DEBUG_XFLASH //debug external spi flash //#define DEBUG_XFLASH //debug external spi flash

1
Firmware/variants/MK3S-E3DREVO.h
View File

@ -167,6 +167,7 @@
//#define DEBUG_PULLUP_CRASH //Test Pullup crash //#define DEBUG_PULLUP_CRASH //Test Pullup crash
//#define DEBUG_EEPROM_CHANGES //Uses +1188 bytes Flash +6 bytes SRAM
//#define DEBUG_BUILD //#define DEBUG_BUILD
//#define DEBUG_SEC_LANG //secondary language debug output at startup //#define DEBUG_SEC_LANG //secondary language debug output at startup
//#define DEBUG_XFLASH //debug external spi flash //#define DEBUG_XFLASH //debug external spi flash

1
Firmware/variants/MK3S-E3DREVO_HF_60W.h
View File

@ -167,6 +167,7 @@
//#define DEBUG_PULLUP_CRASH //Test Pullup crash //#define DEBUG_PULLUP_CRASH //Test Pullup crash
//#define DEBUG_EEPROM_CHANGES //Uses +1188 bytes Flash +6 bytes SRAM
//#define DEBUG_BUILD //#define DEBUG_BUILD
//#define DEBUG_SEC_LANG //secondary language debug output at startup //#define DEBUG_SEC_LANG //secondary language debug output at startup
//#define DEBUG_XFLASH //debug external spi flash //#define DEBUG_XFLASH //debug external spi flash

1
Firmware/variants/MK3S.h
View File

@ -167,6 +167,7 @@
//#define DEBUG_PULLUP_CRASH //Test Pullup crash //#define DEBUG_PULLUP_CRASH //Test Pullup crash
//#define DEBUG_EEPROM_CHANGES //Uses +1188 bytes Flash +6 bytes SRAM
//#define DEBUG_BUILD //#define DEBUG_BUILD
//#define DEBUG_SEC_LANG //secondary language debug output at startup //#define DEBUG_SEC_LANG //secondary language debug output at startup
//#define DEBUG_XFLASH //debug external spi flash //#define DEBUG_XFLASH //debug external spi flash