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

Merge pull request #4619 from 3d-gussner/MK3_DEBUG_EEPROM_CHANGES 

Add DEBUG_EEPROM_CHANGES

I gonna merge this and maybe @gudnimg can improve it later. Need this for 3.14.0 PowerPanic debugging
This commit is contained in:
3d-gussner 2024-02-27 16:16:32 +01:00 committed by GitHub
parent c7b5fd59ed f9bdb8b8aa
commit 2d9dbecd5d
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
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()
{
strcpy_P(cs.version, default_conf.version);
eeprom_update_block(reinterpret_cast<uint8_t*>(&cs), reinterpret_cast<uint8_t*>(EEPROM_M500_base), sizeof(cs));
eeprom_update_block_notify(reinterpret_cast<uint8_t*>(&cs), reinterpret_cast<uint8_t*>(EEPROM_M500_base), sizeof(cs));
#ifdef THERMAL_MODEL
thermal_model_save_settings();
#endif

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)
{
case dcode_mem_t::sram: *((uint8_t*)address) = data[i]; break;
case dcode_mem_t::eeprom: eeprom_write_byte((uint8_t*)address, data[i]); break;
case dcode_mem_t::eeprom: eeprom_write_byte_notify((uint8_t*)address, data[i]); break;
case dcode_mem_t::progmem: break;
case dcode_mem_t::xflash: break;
}
@ -255,7 +255,7 @@ void dcode_1()
LOG("D1 - Clear EEPROM and RESET\n");
cli();
for (int i = 0; i < 8192; i++)
eeprom_write_byte((unsigned char*)i, (unsigned char)0xff);
eeprom_write_byte_notify((unsigned char*)i, (unsigned char)0xff);
softReset();
}
#endif
@ -487,12 +487,12 @@ void dcode_8()
else if (strchr_pointer[1+1] == '!')
{
cal_status = 1;
eeprom_write_byte((uint8_t*)EEPROM_CALIBRATION_STATUS_PINDA, cal_status);
eeprom_write_word(((uint16_t*)EEPROM_PROBE_TEMP_SHIFT) + 0, 8); //40C - 20um - 8usteps
eeprom_write_word(((uint16_t*)EEPROM_PROBE_TEMP_SHIFT) + 1, 24); //45C - 60um - 24usteps
eeprom_write_word(((uint16_t*)EEPROM_PROBE_TEMP_SHIFT) + 2, 48); //50C - 120um - 48usteps
eeprom_write_word(((uint16_t*)EEPROM_PROBE_TEMP_SHIFT) + 3, 80); //55C - 200um - 80usteps
eeprom_write_word(((uint16_t*)EEPROM_PROBE_TEMP_SHIFT) + 4, 120); //60C - 300um - 120usteps
eeprom_write_byte_notify((uint8_t*)EEPROM_CALIBRATION_STATUS_PINDA, cal_status);
eeprom_write_word_notify(((uint16_t*)EEPROM_PROBE_TEMP_SHIFT) + 0, 8); //40C - 20um - 8usteps
eeprom_write_word_notify(((uint16_t*)EEPROM_PROBE_TEMP_SHIFT) + 1, 24); //45C - 60um - 24usteps
eeprom_write_word_notify(((uint16_t*)EEPROM_PROBE_TEMP_SHIFT) + 2, 48); //50C - 120um - 48usteps
eeprom_write_word_notify(((uint16_t*)EEPROM_PROBE_TEMP_SHIFT) + 3, 80); //55C - 200um - 80usteps
eeprom_write_word_notify(((uint16_t*)EEPROM_PROBE_TEMP_SHIFT) + 4, 120); //60C - 300um - 120usteps
}
else
{

12
Firmware/Filament_sensor.cpp
View File

@ -41,7 +41,7 @@ FSensorBlockRunout::~FSensorBlockRunout() { }
#endif // FILAMENT_SENSOR
void Filament_sensor::setEnabled(bool enabled) {
eeprom_update_byte((uint8_t *)EEPROM_FSENSOR, enabled);
eeprom_update_byte_notify((uint8_t *)EEPROM_FSENSOR, enabled);
if (enabled) {
fsensor.init();
} else {
@ -52,21 +52,21 @@ void Filament_sensor::setEnabled(bool enabled) {
void Filament_sensor::setAutoLoadEnabled(bool state, bool updateEEPROM) {
autoLoadEnabled = state;
if (updateEEPROM) {
eeprom_update_byte((uint8_t *)EEPROM_FSENS_AUTOLOAD_ENABLED, state);
eeprom_update_byte_notify((uint8_t *)EEPROM_FSENS_AUTOLOAD_ENABLED, state);
}
}
void Filament_sensor::setRunoutEnabled(bool state, bool updateEEPROM) {
runoutEnabled = state;
if (updateEEPROM) {
eeprom_update_byte((uint8_t *)EEPROM_FSENS_RUNOUT_ENABLED, state);
eeprom_update_byte_notify((uint8_t *)EEPROM_FSENS_RUNOUT_ENABLED, state);
}
}
void Filament_sensor::setActionOnError(SensorActionOnError state, bool updateEEPROM) {
sensorActionOnError = state;
if (updateEEPROM) {
eeprom_update_byte((uint8_t *)EEPROM_FSENSOR_ACTION_NA, (uint8_t)state);
eeprom_update_byte_notify((uint8_t *)EEPROM_FSENSOR_ACTION_NA, (uint8_t)state);
}
}
@ -288,7 +288,7 @@ const char *IR_sensor_analog::getIRVersionText() {
void IR_sensor_analog::setSensorRevision(SensorRevision rev, bool updateEEPROM) {
sensorRevision = rev;
if (updateEEPROM) {
eeprom_update_byte((uint8_t *)EEPROM_FSENSOR_PCB, (uint8_t)rev);
eeprom_update_byte_notify((uint8_t *)EEPROM_FSENSOR_PCB, (uint8_t)rev);
}
}
@ -446,7 +446,7 @@ void PAT9125_sensor::setJamDetectionEnabled(bool state, bool updateEEPROM) {
resetStepCount();
jamErrCnt = 0;
if (updateEEPROM) {
eeprom_update_byte((uint8_t *)EEPROM_FSENSOR_JAM_DETECTION, state);
eeprom_update_byte_notify((uint8_t *)EEPROM_FSENSOR_JAM_DETECTION, state);
}
}

138
Firmware/Marlin_main.cpp
View File

@ -655,12 +655,12 @@ void crashdet_cancel() {
void failstats_reset_print()
{
eeprom_update_byte((uint8_t *)EEPROM_CRASH_COUNT_X, 0);
eeprom_update_byte((uint8_t *)EEPROM_CRASH_COUNT_Y, 0);
eeprom_update_byte((uint8_t *)EEPROM_FERROR_COUNT, 0);
eeprom_update_byte((uint8_t *)EEPROM_POWER_COUNT, 0);
eeprom_update_byte((uint8_t *)EEPROM_MMU_FAIL, 0);
eeprom_update_byte((uint8_t *)EEPROM_MMU_LOAD_FAIL, 0);
eeprom_update_byte_notify((uint8_t *)EEPROM_CRASH_COUNT_X, 0);
eeprom_update_byte_notify((uint8_t *)EEPROM_CRASH_COUNT_Y, 0);
eeprom_update_byte_notify((uint8_t *)EEPROM_FERROR_COUNT, 0);
eeprom_update_byte_notify((uint8_t *)EEPROM_POWER_COUNT, 0);
eeprom_update_byte_notify((uint8_t *)EEPROM_MMU_FAIL, 0);
eeprom_update_byte_notify((uint8_t *)EEPROM_MMU_LOAD_FAIL, 0);
}
void watchdogEarlyDisable(void) {
@ -707,19 +707,19 @@ void softReset(void) {
static void factory_reset_stats(){
eeprom_update_dword((uint32_t *)EEPROM_TOTALTIME, 0);
eeprom_update_dword((uint32_t *)EEPROM_FILAMENTUSED, 0);
eeprom_update_dword_notify((uint32_t *)EEPROM_TOTALTIME, 0);
eeprom_update_dword_notify((uint32_t *)EEPROM_FILAMENTUSED, 0);
failstats_reset_print();
eeprom_update_word((uint16_t *)EEPROM_CRASH_COUNT_X_TOT, 0);
eeprom_update_word((uint16_t *)EEPROM_CRASH_COUNT_Y_TOT, 0);
eeprom_update_word((uint16_t *)EEPROM_FERROR_COUNT_TOT, 0);
eeprom_update_word((uint16_t *)EEPROM_POWER_COUNT_TOT, 0);
eeprom_update_word_notify((uint16_t *)EEPROM_CRASH_COUNT_X_TOT, 0);
eeprom_update_word_notify((uint16_t *)EEPROM_CRASH_COUNT_Y_TOT, 0);
eeprom_update_word_notify((uint16_t *)EEPROM_FERROR_COUNT_TOT, 0);
eeprom_update_word_notify((uint16_t *)EEPROM_POWER_COUNT_TOT, 0);
eeprom_update_word((uint16_t *)EEPROM_MMU_FAIL_TOT, 0);
eeprom_update_word((uint16_t *)EEPROM_MMU_LOAD_FAIL_TOT, 0);
eeprom_update_dword((uint32_t *)EEPROM_MMU_MATERIAL_CHANGES, 0);
eeprom_update_word_notify((uint16_t *)EEPROM_MMU_FAIL_TOT, 0);
eeprom_update_word_notify((uint16_t *)EEPROM_MMU_LOAD_FAIL_TOT, 0);
eeprom_update_dword_notify((uint32_t *)EEPROM_MMU_MATERIAL_CHANGES, 0);
}
// Factory reset function
@ -750,7 +750,7 @@ static void factory_reset(char level)
// Force the wizard in "Follow calibration flow" mode at the next boot up
calibration_status_clear(CALIBRATION_FORCE_PREP);
eeprom_write_byte((uint8_t*)EEPROM_WIZARD_ACTIVE, 2);
eeprom_write_byte_notify((uint8_t*)EEPROM_WIZARD_ACTIVE, 2);
farm_disable();
#ifdef FILAMENT_SENSOR
@ -767,7 +767,7 @@ static void factory_reset(char level)
menu_progressbar_init(EEPROM_TOP, PSTR("ERASING all data"));
// Erase EEPROM
for (uint16_t i = 0; i < EEPROM_TOP; i++) {
eeprom_update_byte((uint8_t*)i, 0xFF);
eeprom_update_byte_notify((uint8_t*)i, 0xFF);
menu_progressbar_update(i);
}
menu_progressbar_finish();
@ -921,7 +921,7 @@ void update_sec_lang_from_external_flash()
else
{
//TODO - check sec lang data integrity
eeprom_update_byte((unsigned char *)EEPROM_LANG, LANG_ID_SEC);
eeprom_update_byte_notify((unsigned char *)EEPROM_LANG, LANG_ID_SEC);
}
}
}
@ -1023,7 +1023,7 @@ static void fw_crash_init()
#endif //XFLASH_DUMP
// prevent crash prompts to reappear once acknowledged
eeprom_update_byte((uint8_t*)EEPROM_FW_CRASH_FLAG, 0xFF);
eeprom_update_byte_notify((uint8_t*)EEPROM_FW_CRASH_FLAG, 0xFF);
}
#define KILL_PENDING_FLAG 0x42
@ -1031,7 +1031,7 @@ static void fw_crash_init()
static void fw_kill_init() {
if (eeprom_read_byte((uint8_t*)EEPROM_KILL_PENDING_FLAG) == KILL_PENDING_FLAG) {
// clear pending message event
eeprom_write_byte((uint8_t*)EEPROM_KILL_PENDING_FLAG, EEPROM_EMPTY_VALUE);
eeprom_write_byte_notify((uint8_t*)EEPROM_KILL_PENDING_FLAG, EEPROM_EMPTY_VALUE);
// display the kill message
PGM_P kill_msg = (PGM_P)eeprom_read_word((uint16_t*)EEPROM_KILL_MESSAGE);
@ -1106,7 +1106,7 @@ void setup()
{
if (!get_PRUSA_SN(SN))
{
eeprom_update_block(SN, (uint8_t*)EEPROM_PRUSA_SN, 20);
eeprom_update_block_notify(SN, (uint8_t*)EEPROM_PRUSA_SN, 20);
puts_P(PSTR("SN updated"));
}
else
@ -1452,13 +1452,13 @@ void setup()
eeprom_init_default_byte((uint8_t*)EEPROM_TEMP_CAL_ACTIVE, 0);
if (eeprom_read_byte((uint8_t*)EEPROM_CALIBRATION_STATUS_PINDA) == 255) {
//eeprom_write_byte((uint8_t*)EEPROM_CALIBRATION_STATUS_PINDA, 0);
eeprom_write_byte((uint8_t*)EEPROM_CALIBRATION_STATUS_PINDA, 1);
//eeprom_write_byte_notify((uint8_t*)EEPROM_CALIBRATION_STATUS_PINDA, 0);
eeprom_update_byte_notify((uint8_t*)EEPROM_CALIBRATION_STATUS_PINDA, 1);
int16_t z_shift = 0;
for (uint8_t i = 0; i < 5; i++) {
eeprom_update_word((uint16_t*)EEPROM_PROBE_TEMP_SHIFT + i, z_shift);
eeprom_update_word_notify((uint16_t*)EEPROM_PROBE_TEMP_SHIFT + i, z_shift);
}
eeprom_write_byte((uint8_t*)EEPROM_TEMP_CAL_ACTIVE, 0);
eeprom_update_byte_notify((uint8_t*)EEPROM_TEMP_CAL_ACTIVE, 0);
}
eeprom_init_default_byte((uint8_t*)EEPROM_UVLO, PowerPanic::NO_PENDING_RECOVERY);
eeprom_init_default_byte((uint8_t*)EEPROM_SD_SORT, 0);
@ -1488,16 +1488,16 @@ void setup()
//if user confirms with knob, new hw version (printer and/or motherboard) is written to eeprom and message will be not shown next time
case(0b01):
lcd_show_fullscreen_message_and_wait_P(_i("Warning: motherboard type changed.")); ////MSG_CHANGED_MOTHERBOARD c=20 r=4
eeprom_write_word((uint16_t*)EEPROM_BOARD_TYPE, MOTHERBOARD);
eeprom_write_word_notify((uint16_t*)EEPROM_BOARD_TYPE, MOTHERBOARD);
break;
case(0b10):
lcd_show_fullscreen_message_and_wait_P(_i("Warning: printer type changed.")); ////MSG_CHANGED_PRINTER c=20 r=4
eeprom_write_word((uint16_t*)EEPROM_PRINTER_TYPE, PRINTER_TYPE);
eeprom_write_word_notify((uint16_t*)EEPROM_PRINTER_TYPE, PRINTER_TYPE);
break;
case(0b11):
lcd_show_fullscreen_message_and_wait_P(_i("Warning: both printer type and motherboard type changed.")); ////MSG_CHANGED_BOTH c=20 r=4
eeprom_write_word((uint16_t*)EEPROM_PRINTER_TYPE, PRINTER_TYPE);
eeprom_write_word((uint16_t*)EEPROM_BOARD_TYPE, MOTHERBOARD);
eeprom_write_word_notify((uint16_t*)EEPROM_PRINTER_TYPE, PRINTER_TYPE);
eeprom_write_word_notify((uint16_t*)EEPROM_BOARD_TYPE, MOTHERBOARD);
break;
default: break; //no change, show no message
}
@ -1522,7 +1522,7 @@ void setup()
calibration_status &= ~CALIBRATION_STATUS_SELFTEST;
}
}
eeprom_update_byte((uint8_t*)EEPROM_CALIBRATION_STATUS_V2, calibration_status);
eeprom_update_byte_notify((uint8_t*)EEPROM_CALIBRATION_STATUS_V2, calibration_status);
}
if (eeprom_fw_version_older_than_p(FW_VERSION_NR)) {
if (!calibration_status_get(CALIBRATION_WIZARD_STEPS)) {
@ -1604,7 +1604,7 @@ void setup()
if ( btn == LCD_LEFT_BUTTON_CHOICE) {
recover_print(0);
} else { // LCD_MIDDLE_BUTTON_CHOICE
eeprom_update_byte((uint8_t*)EEPROM_UVLO, PowerPanic::NO_PENDING_RECOVERY);
eeprom_update_byte_notify((uint8_t*)EEPROM_UVLO, PowerPanic::NO_PENDING_RECOVERY);
}
}
}
@ -1628,7 +1628,7 @@ void setup()
static inline void crash_and_burn(dump_crash_reason reason)
{
WRITE(BEEPER, HIGH);
eeprom_update_byte((uint8_t*)EEPROM_FW_CRASH_FLAG, (uint8_t)reason);
eeprom_update_byte_notify((uint8_t*)EEPROM_FW_CRASH_FLAG, (uint8_t)reason);
#ifdef EMERGENCY_DUMP
xfdump_full_dump_and_reset(reason);
#elif defined(EMERGENCY_SERIAL_DUMP)
@ -3231,7 +3231,7 @@ bool gcode_M45(bool onlyZ, int8_t verbosity_level)
{
// Reset the baby step value and the baby step applied flag.
calibration_status_clear(CALIBRATION_STATUS_LIVE_ADJUST);
eeprom_update_word(reinterpret_cast<uint16_t *>(&(EEPROM_Sheets_base->s[(eeprom_read_byte(&(EEPROM_Sheets_base->active_sheet)))].z_offset)),0);
eeprom_update_word_notify(reinterpret_cast<uint16_t *>(&(EEPROM_Sheets_base->s[(eeprom_read_byte(&(EEPROM_Sheets_base->active_sheet)))].z_offset)),0);
// Complete XYZ calibration.
uint8_t point_too_far_mask = 0;
@ -4129,7 +4129,7 @@ void process_commands()
enquecommand_P(MSG_M24);
// Print is recovered, clear the recovery flag
eeprom_update_byte((uint8_t*)EEPROM_UVLO, PowerPanic::NO_PENDING_RECOVERY);
eeprom_update_byte_notify((uint8_t*)EEPROM_UVLO, PowerPanic::NO_PENDING_RECOVERY);
}
else if (eeprom_read_byte((uint8_t*)EEPROM_UVLO_PRINT_TYPE) == PowerPanic::PRINT_TYPE_HOST)
{
@ -4173,7 +4173,7 @@ void process_commands()
lang_reset();
} else if(code_seen_P(PSTR("Lz"))) { // PRUSA Lz
eeprom_update_word(reinterpret_cast<uint16_t *>(&(EEPROM_Sheets_base->s[(eeprom_read_byte(&(EEPROM_Sheets_base->active_sheet)))].z_offset)),0);
eeprom_update_word_notify(reinterpret_cast<uint16_t *>(&(EEPROM_Sheets_base->s[(eeprom_read_byte(&(EEPROM_Sheets_base->active_sheet)))].z_offset)),0);
} else if(code_seen_P(PSTR("FR"))) { // PRUSA FR
// Factory full reset
@ -4201,8 +4201,8 @@ void process_commands()
strchr_pointer++; // skip 1st char (~ 's')
strchr_pointer++; // skip 2nd char (~ 'e')
nDiameter=(uint16_t)(code_value()*1000.0+0.5); // [,um]
eeprom_update_byte((uint8_t*)EEPROM_NOZZLE_DIAMETER,(uint8_t)ClNozzleDiameter::_Diameter_Undef); // for correct synchronization after farm-mode exiting
eeprom_update_word((uint16_t*)EEPROM_NOZZLE_DIAMETER_uM,nDiameter);
eeprom_update_byte_notify((uint8_t*)EEPROM_NOZZLE_DIAMETER,(uint8_t)ClNozzleDiameter::_Diameter_Undef); // for correct synchronization after farm-mode exiting
eeprom_update_word_notify((uint16_t*)EEPROM_NOZZLE_DIAMETER_uM,nDiameter);
}
else SERIAL_PROTOCOLLN((float)eeprom_read_word((uint16_t*)EEPROM_NOZZLE_DIAMETER_uM)/1000.0);
}
@ -4759,7 +4759,7 @@ void process_commands()
serialecho_temperatures();
}
eeprom_update_byte((uint8_t*)EEPROM_CALIBRATION_STATUS_PINDA, 0); //invalidate temp. calibration in case that in will be aborted during the calibration process
eeprom_update_byte_notify((uint8_t*)EEPROM_CALIBRATION_STATUS_PINDA, 0); //invalidate temp. calibration in case that in will be aborted during the calibration process
current_position[Z_AXIS] = MESH_HOME_Z_SEARCH;
plan_buffer_line_curposXYZE(3000 / 60);
@ -4783,7 +4783,7 @@ void process_commands()
float temp = (40 + i * 5);
printf_P(_N("\nStep: %d/6 (skipped)\nPINDA temperature: %d Z shift (mm):0\n"), i + 2, (40 + i*5));
if (i >= 0) {
eeprom_update_word((uint16_t*)EEPROM_PROBE_TEMP_SHIFT + i, z_shift);
eeprom_update_word_notify((uint16_t*)EEPROM_PROBE_TEMP_SHIFT + i, z_shift);
}
if (start_temp <= temp) break;
}
@ -4822,7 +4822,7 @@ void process_commands()
printf_P(_N("\nPINDA temperature: %.1f Z shift (mm): %.3f"), current_temperature_pinda, current_position[Z_AXIS] - zero_z);
eeprom_update_word((uint16_t*)EEPROM_PROBE_TEMP_SHIFT + i, z_shift);
eeprom_update_word_notify((uint16_t*)EEPROM_PROBE_TEMP_SHIFT + i, z_shift);
}
lcd_temp_cal_show_result(true);
homing_flag = false;
@ -4862,7 +4862,7 @@ void process_commands()
delay_keep_alive(1000);
serialecho_temperatures();
}
eeprom_update_byte((uint8_t*)EEPROM_CALIBRATION_STATUS_PINDA, 0); //invalidate temp. calibration in case that in will be aborted during the calibration process
eeprom_update_byte_notify((uint8_t*)EEPROM_CALIBRATION_STATUS_PINDA, 0); //invalidate temp. calibration in case that in will be aborted during the calibration process
current_position[Z_AXIS] = 5;
plan_buffer_line_curposXYZE(3000 / 60);
@ -4907,13 +4907,13 @@ void process_commands()
printf_P(_N("\nTemperature: %d Z shift (mm): %.3f\n"), t_c, current_position[Z_AXIS] - zero_z);
eeprom_update_word((uint16_t*)EEPROM_PROBE_TEMP_SHIFT + i, z_shift);
eeprom_update_word_notify((uint16_t*)EEPROM_PROBE_TEMP_SHIFT + i, z_shift);
}
custom_message_type = CustomMsg::Status;
eeprom_update_byte((uint8_t*)EEPROM_CALIBRATION_STATUS_PINDA, 1);
eeprom_update_byte_notify((uint8_t*)EEPROM_CALIBRATION_STATUS_PINDA, 1);
puts_P(_N("Temperature calibration done."));
disable_x();
disable_y();
@ -4921,7 +4921,7 @@ void process_commands()
disable_e0();
setTargetBed(0); //set bed target temperature back to 0
lcd_show_fullscreen_message_and_wait_P(_T(MSG_PINDA_CALIBRATION_DONE));
eeprom_update_byte((unsigned char *)EEPROM_TEMP_CAL_ACTIVE, 1);
eeprom_update_byte_notify((unsigned char *)EEPROM_TEMP_CAL_ACTIVE, 1);
lcd_update_enable(true);
lcd_update(2);
@ -5005,7 +5005,7 @@ void process_commands()
}else{
// Save it to the eeprom
babystepLoadZ = babystepz;
eeprom_update_word((uint16_t*)EEPROM_BABYSTEP_Z0 + BabyPosition, babystepLoadZ);
eeprom_update_word_notify((uint16_t*)EEPROM_BABYSTEP_Z0 + BabyPosition, babystepLoadZ);
// adjust the Z
babystepsTodoZadd(babystepLoadZ);
}
@ -5494,7 +5494,7 @@ void process_commands()
// Reset the baby step value and the baby step applied flag.
calibration_status_clear(CALIBRATION_STATUS_LIVE_ADJUST);
eeprom_update_word(reinterpret_cast<uint16_t *>(&(EEPROM_Sheets_base->s[(eeprom_read_byte(&(EEPROM_Sheets_base->active_sheet)))].z_offset)),0);
eeprom_update_word_notify(reinterpret_cast<uint16_t *>(&(EEPROM_Sheets_base->s[(eeprom_read_byte(&(EEPROM_Sheets_base->active_sheet)))].z_offset)),0);
// Reset the skew and offset in both RAM and EEPROM.
calibration_status_clear(CALIBRATION_STATUS_XYZ);
@ -7940,7 +7940,7 @@ Sigma_Exit:
SERIAL_PROTOCOLLNPGM(" Z VALUE OUT OF RANGE");
break;
}
eeprom_update_word(reinterpret_cast<uint16_t *>(&(EEPROM_Sheets_base->s[iSel].z_offset)),zraw);
eeprom_update_word_notify(reinterpret_cast<uint16_t *>(&(EEPROM_Sheets_base->s[iSel].z_offset)),zraw);
}
else
{
@ -7956,7 +7956,7 @@ Sigma_Exit:
{
strncpy(strLabel,src,7);
}
eeprom_update_block(strLabel,EEPROM_Sheets_base->s[iSel].name,sizeof(Sheet::name));
eeprom_update_block_notify(strLabel,EEPROM_Sheets_base->s[iSel].name,sizeof(Sheet::name));
}
else
{
@ -7966,7 +7966,7 @@ Sigma_Exit:
if (code_seen('B'))
{
iBedC = code_value_uint8();
eeprom_update_byte(&EEPROM_Sheets_base->s[iSel].bed_temp, iBedC);
eeprom_update_byte_notify(&EEPROM_Sheets_base->s[iSel].bed_temp, iBedC);
}
else
{
@ -7976,7 +7976,7 @@ Sigma_Exit:
if (code_seen('P'))
{
iPindaC = code_value_uint8();
eeprom_update_byte(&EEPROM_Sheets_base->s[iSel].pinda_temp, iPindaC);
eeprom_update_byte_notify(&EEPROM_Sheets_base->s[iSel].pinda_temp, iPindaC);
}
else
{
@ -7987,7 +7987,7 @@ Sigma_Exit:
{
bIsActive |= code_value_uint8() || (eeprom_read_byte(&(EEPROM_Sheets_base->active_sheet)) == iSel);
if(bIsActive && eeprom_is_sheet_initialized(iSel)) {
eeprom_update_byte(&EEPROM_Sheets_base->active_sheet, iSel);
eeprom_update_byte_notify(&EEPROM_Sheets_base->active_sheet, iSel);
} else {
bIsActive = 0;
}
@ -8092,24 +8092,24 @@ Sigma_Exit:
gcode_M861_print_pinda_cal_eeprom();
}
else if (code_seen('!')) { // ! - Set factory default values
eeprom_write_byte((uint8_t*)EEPROM_CALIBRATION_STATUS_PINDA, 1);
eeprom_update_byte_notify((uint8_t*)EEPROM_CALIBRATION_STATUS_PINDA, 1);
int16_t z_shift = 8; //40C - 20um - 8usteps
eeprom_update_word((uint16_t*)EEPROM_PROBE_TEMP_SHIFT, z_shift);
eeprom_update_word_notify((uint16_t*)EEPROM_PROBE_TEMP_SHIFT, z_shift);
z_shift = 24; //45C - 60um - 24usteps
eeprom_update_word((uint16_t*)EEPROM_PROBE_TEMP_SHIFT + 1, z_shift);
eeprom_update_word_notify((uint16_t*)EEPROM_PROBE_TEMP_SHIFT + 1, z_shift);
z_shift = 48; //50C - 120um - 48usteps
eeprom_update_word((uint16_t*)EEPROM_PROBE_TEMP_SHIFT + 2, z_shift);
eeprom_update_word_notify((uint16_t*)EEPROM_PROBE_TEMP_SHIFT + 2, z_shift);
z_shift = 80; //55C - 200um - 80usteps
eeprom_update_word((uint16_t*)EEPROM_PROBE_TEMP_SHIFT + 3, z_shift);
eeprom_update_word_notify((uint16_t*)EEPROM_PROBE_TEMP_SHIFT + 3, z_shift);
z_shift = 120; //60C - 300um - 120usteps
eeprom_update_word((uint16_t*)EEPROM_PROBE_TEMP_SHIFT + 4, z_shift);
eeprom_update_word_notify((uint16_t*)EEPROM_PROBE_TEMP_SHIFT + 4, z_shift);
SERIAL_PROTOCOLLNPGM("factory restored");
}
else if (code_seen('Z')) { // Z - Set all values to 0 (effectively disabling PINDA temperature compensation)
eeprom_write_byte((uint8_t*)EEPROM_CALIBRATION_STATUS_PINDA, 1);
eeprom_update_byte_notify((uint8_t*)EEPROM_CALIBRATION_STATUS_PINDA, 1);
int16_t z_shift = 0;
for (uint8_t i = 0; i < 5; i++) {
eeprom_update_word((uint16_t*)EEPROM_PROBE_TEMP_SHIFT + i, z_shift);
eeprom_update_word_notify((uint16_t*)EEPROM_PROBE_TEMP_SHIFT + i, z_shift);
}
SERIAL_PROTOCOLLNPGM("zerorized");
}
@ -8118,7 +8118,7 @@ Sigma_Exit:
if (code_seen('I')) {
uint8_t index = code_value_uint8();
if (index < 5) {
eeprom_update_word((uint16_t*)EEPROM_PROBE_TEMP_SHIFT + index, usteps);
eeprom_update_word_notify((uint16_t*)EEPROM_PROBE_TEMP_SHIFT + index, usteps);
SERIAL_PROTOCOLLNRPGM(MSG_OK);
SERIAL_PROTOCOLLNRPGM(_header);
gcode_M861_print_pinda_cal_eeprom();
@ -8439,7 +8439,7 @@ Sigma_Exit:
else if (code_seen('P'))
{
uint8_t newMenuMode = (mcode_in_progress==914) ? SILENT_MODE_NORMAL : SILENT_MODE_STEALTH;
eeprom_update_byte((unsigned char *)EEPROM_SILENT, newMenuMode);
eeprom_update_byte_notify((unsigned char *)EEPROM_SILENT, newMenuMode);
SilentModeMenu = newMenuMode;
//printf_P(_n("tmc2130mode/smm/eep: %d %d %d %d"),tmc2130_mode,SilentModeMenu,eeprom_read_byte((uint8_t*)EEPROM_SILENT), bEnableForce_z);
}
@ -8854,11 +8854,11 @@ Sigma_Exit:
switch (code_value_uint8())
{
case 0:
eeprom_update_byte((uint8_t *)EEPROM_MMU_ENABLED, false);
eeprom_update_byte_notify((uint8_t *)EEPROM_MMU_ENABLED, false);
MMU2::mmu2.Stop();
break;
case 1:
eeprom_update_byte((uint8_t *)EEPROM_MMU_ENABLED, true);
eeprom_update_byte_notify((uint8_t *)EEPROM_MMU_ENABLED, true);
MMU2::mmu2.Start();
break;
default:
@ -9736,8 +9736,8 @@ void kill(const char *full_screen_message) {
}
// update eeprom with the correct kill message to be shown on startup
eeprom_write_word((uint16_t*)EEPROM_KILL_MESSAGE, (uint16_t)full_screen_message);
eeprom_write_byte((uint8_t*)EEPROM_KILL_PENDING_FLAG, KILL_PENDING_FLAG);
eeprom_write_word_notify((uint16_t*)EEPROM_KILL_MESSAGE, (uint16_t)full_screen_message);
eeprom_write_byte_notify((uint8_t*)EEPROM_KILL_PENDING_FLAG, KILL_PENDING_FLAG);
softReset();
}
@ -9949,8 +9949,8 @@ void save_statistics() {
uint32_t _previous_time = eeprom_init_default_dword((uint32_t *)EEPROM_TOTALTIME, 0); //_previous_time unit: min
uint32_t time_minutes = print_job_timer.duration() / 60;
eeprom_update_dword((uint32_t *)EEPROM_TOTALTIME, _previous_time + time_minutes); // EEPROM_TOTALTIME unit: min
eeprom_update_dword((uint32_t *)EEPROM_FILAMENTUSED, _previous_filament + (total_filament_used / 1000));
eeprom_update_dword_notify((uint32_t *)EEPROM_TOTALTIME, _previous_time + time_minutes); // EEPROM_TOTALTIME unit: min
eeprom_update_dword_notify((uint32_t *)EEPROM_FILAMENTUSED, _previous_filament + (total_filament_used / 1000));
print_job_timer.reset();
total_filament_used = 0;
@ -10070,7 +10070,7 @@ void check_babystep()
if ((babystep_z < Z_BABYSTEP_MIN) || (babystep_z > Z_BABYSTEP_MAX)) {
babystep_z = 0; //if babystep value is out of min max range, set it to 0
SERIAL_ECHOLNPGM("Z live adjust out of range. Setting to 0");
eeprom_write_word(reinterpret_cast<uint16_t *>(&(EEPROM_Sheets_base->
eeprom_write_word_notify(reinterpret_cast<uint16_t *>(&(EEPROM_Sheets_base->
s[(eeprom_read_byte(&(EEPROM_Sheets_base->active_sheet)))].z_offset)),
babystep_z);
lcd_show_fullscreen_message_and_wait_P(PSTR("Z live adjust out of range. Setting to 0. Click to continue."));
@ -11034,7 +11034,7 @@ void restore_print_from_ram_and_continue(float e_move)
// Cancel the state related to a currently saved print
void cancel_saved_printing()
{
eeprom_update_byte((uint8_t*)EEPROM_UVLO, PowerPanic::NO_PENDING_RECOVERY);
eeprom_update_byte_notify((uint8_t*)EEPROM_UVLO, PowerPanic::NO_PENDING_RECOVERY);
saved_start_position[0] = SAVED_START_POSITION_UNSET;
saved_printing_type = PowerPanic::PRINT_TYPE_NONE;
saved_printing = false;

8
Firmware/Prusa_farm.cpp
View File

@ -403,7 +403,7 @@ void farm_mode_init() {
fsensor.setAutoLoadEnabled(false);
#endif //FILAMENT_SENSOR
// ~ FanCheck -> on
eeprom_update_byte((uint8_t*)EEPROM_FAN_CHECK_ENABLED, true);
eeprom_update_byte_notify((uint8_t*)EEPROM_FAN_CHECK_ENABLED, true);
}
}
@ -447,9 +447,9 @@ bool farm_prusa_code_seen() {
void farm_gcode_g98() {
farm_mode = 1;
eeprom_update_byte((unsigned char *)EEPROM_FARM_MODE, farm_mode);
eeprom_update_byte_notify((unsigned char *)EEPROM_FARM_MODE, farm_mode);
SilentModeMenu = SILENT_MODE_OFF;
eeprom_update_byte((unsigned char *)EEPROM_SILENT, SilentModeMenu);
eeprom_update_byte_notify((unsigned char *)EEPROM_SILENT, SilentModeMenu);
fCheckModeInit(); // alternatively invoke printer reset
}
@ -461,7 +461,7 @@ void farm_gcode_g99() {
void farm_disable() {
farm_mode = false;
eeprom_update_byte((uint8_t*)EEPROM_FARM_MODE, farm_mode);
eeprom_update_byte_notify((uint8_t*)EEPROM_FARM_MODE, farm_mode);
}
#else //PRUSA_FARM

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)
{
eeprom_write_byte((uint8_t*)EEPROM_SPOOL_JOIN, (uint8_t)EEPROM::Enabled);
eeprom_update_byte_notify((uint8_t*)EEPROM_SPOOL_JOIN, (uint8_t)EEPROM::Enabled);
} else {
eeprom_write_byte((uint8_t*)EEPROM_SPOOL_JOIN, (uint8_t)EEPROM::Disabled);
eeprom_update_byte_notify((uint8_t*)EEPROM_SPOOL_JOIN, (uint8_t)EEPROM::Disabled);
}
}

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.
{
eeprom_update_byte((uint8_t *)EEPROM_BACKLIGHT_LEVEL_HIGH, backlightLevel_HIGH);
eeprom_update_byte((uint8_t *)EEPROM_BACKLIGHT_LEVEL_LOW, backlightLevel_LOW);
eeprom_update_byte((uint8_t *)EEPROM_BACKLIGHT_MODE, backlightMode);
eeprom_update_word((uint16_t *)EEPROM_BACKLIGHT_TIMEOUT, backlightTimer_period);
eeprom_update_byte_notify((uint8_t *)EEPROM_BACKLIGHT_LEVEL_HIGH, backlightLevel_HIGH);
eeprom_update_byte_notify((uint8_t *)EEPROM_BACKLIGHT_LEVEL_LOW, backlightLevel_LOW);
eeprom_update_byte_notify((uint8_t *)EEPROM_BACKLIGHT_MODE, backlightMode);
eeprom_update_word_notify((uint16_t *)EEPROM_BACKLIGHT_TIMEOUT, backlightTimer_period);
}
void backlight_update()

2
Firmware/cmdqueue.cpp
View File

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

205
Firmware/eeprom.cpp
View File

@ -26,7 +26,7 @@ void eeprom_init()
eeprom_init_default_dword((uint32_t*)EEPROM_MMU_MATERIAL_CHANGES, 0);
if (eeprom_read_byte(&(EEPROM_Sheets_base->active_sheet)) == EEPROM_EMPTY_VALUE)
{
eeprom_update_byte(&(EEPROM_Sheets_base->active_sheet), 0);
eeprom_update_byte_notify(&(EEPROM_Sheets_base->active_sheet), 0);
// When upgrading from version older version (before multiple sheets were implemented in v3.8.0)
// Sheet 1 uses the previous Live adjust Z (@EEPROM_BABYSTEP_Z)
int last_babystep = eeprom_read_word((uint16_t *)EEPROM_BABYSTEP_Z);
@ -49,7 +49,7 @@ void eeprom_init()
// initialize custom mendel name in eeprom
if (eeprom_read_byte((uint8_t*)EEPROM_CUSTOM_MENDEL_NAME) == EEPROM_EMPTY_VALUE) {
//SERIAL_ECHOLN("Init Custom Mendel Name");
eeprom_update_block(CUSTOM_MENDEL_NAME, (uint8_t*)EEPROM_CUSTOM_MENDEL_NAME, sizeof(CUSTOM_MENDEL_NAME));
eeprom_update_block_notify(CUSTOM_MENDEL_NAME, (uint8_t*)EEPROM_CUSTOM_MENDEL_NAME, sizeof(CUSTOM_MENDEL_NAME));
} //else SERIAL_ECHOLN("Found Custom Mendel Name");
#ifdef PINDA_TEMP_COMP
@ -66,11 +66,11 @@ void eeprom_init()
}
void eeprom_adjust_bed_reset() {
eeprom_update_byte((uint8_t*)EEPROM_BED_CORRECTION_VALID, 1);
eeprom_update_byte((uint8_t*)EEPROM_BED_CORRECTION_LEFT, 0);
eeprom_update_byte((uint8_t*)EEPROM_BED_CORRECTION_RIGHT, 0);
eeprom_update_byte((uint8_t*)EEPROM_BED_CORRECTION_FRONT, 0);
eeprom_update_byte((uint8_t*)EEPROM_BED_CORRECTION_REAR, 0);
eeprom_update_byte_notify((uint8_t*)EEPROM_BED_CORRECTION_VALID, 1);
eeprom_update_byte_notify((uint8_t*)EEPROM_BED_CORRECTION_LEFT, 0);
eeprom_update_byte_notify((uint8_t*)EEPROM_BED_CORRECTION_RIGHT, 0);
eeprom_update_byte_notify((uint8_t*)EEPROM_BED_CORRECTION_FRONT, 0);
eeprom_update_byte_notify((uint8_t*)EEPROM_BED_CORRECTION_REAR, 0);
}
//! @brief Get default sheet name for index
@ -137,12 +137,175 @@ int8_t eeprom_next_initialized_sheet(int8_t sheet)
return -1;
}
#ifdef DEBUG_EEPROM_CHANGES
static void eeprom_byte_notify(uint8_t *dst, uint8_t previous_value, uint8_t value, bool write) {
printf_P(PSTR("EEPROMChng b %s %u %d -> %d\n"), write ? "write":"", dst , previous_value, value);
}
static void eeprom_word_notify(uint16_t *dst, uint16_t previous_value, uint16_t value, bool write) {
printf_P(PSTR("EEPROMChng w %s %u %u -> %u\n"), write ? "write":"", dst , previous_value, value);
}
static void eeprom_dword_notify(uint32_t *dst, uint32_t previous_value, uint32_t value, bool write) {
printf_P(PSTR("EEPROMChng d %s %u %x -> %x\n"), write ? "write":"", reinterpret_cast<const uint16_t>(dst) , previous_value, value);
}
static void eeprom_float_notify(float *dst, float previous_value, float value, bool write) {
printf_P(PSTR("EEPROMChng f %s %u %f -> %f\n"), write ? "write":"", reinterpret_cast<const uint16_t>(dst) , previous_value, value);
}
static void eeprom_block_notify(void *dst, const uint8_t *previous_values, const uint8_t *values, size_t size, bool write) {
for(size_t i = 0; i < size; ++i){
if (previous_values[i] != values[i] || write) {
printf_P(PSTR("EEPROMChng bl %s %u %x -> %x\n"), write ? "write":"", reinterpret_cast<const uint16_t>(dst) + i, previous_values[i], values[i]);
}
}
}
#endif //DEBUG_EEPROM_CHANGES
#ifndef DEBUG_EEPROM_CHANGES
void eeprom_write_byte_notify(uint8_t *dst, uint8_t value){
#else
void eeprom_write_byte_notify(uint8_t *dst, uint8_t value, bool active){
if (active) {
uint8_t previous_value = eeprom_read_byte(dst);
eeprom_byte_notify(dst, previous_value, value, true);
}
#endif //DEBUG_EEPROM_CHANGES
eeprom_write_byte(dst, value);
}
#ifndef DEBUG_EEPROM_CHANGES
void eeprom_update_byte_notify(uint8_t *dst, uint8_t value){
#else
void eeprom_update_byte_notify(uint8_t *dst, uint8_t value, bool active){
if (active) {
uint8_t previous_value = eeprom_read_byte(dst);
if (previous_value != value) {
eeprom_byte_notify(dst, previous_value, value, false);
}
}
#endif //DEBUG_EEPROM_CHANGES
eeprom_update_byte(dst, value);
}
#ifndef DEBUG_EEPROM_CHANGES
void eeprom_write_word_notify(uint16_t *dst, uint16_t value){
#else
void eeprom_write_word_notify(uint16_t *dst, uint16_t value, bool active){
if (active) {
uint16_t previous_value = eeprom_read_word(dst);
eeprom_word_notify(dst, previous_value, value, true);
}
#endif //DEBUG_EEPROM_CHANGES
eeprom_write_word(dst, value);
}
#ifndef DEBUG_EEPROM_CHANGES
void eeprom_update_word_notify(uint16_t *dst, uint16_t value){
#else
void eeprom_update_word_notify(uint16_t *dst, uint16_t value, bool active){
if (active) {
uint16_t previous_value = eeprom_read_word(dst);
if (previous_value != value) {
eeprom_word_notify(dst, previous_value, value, false);
}
}
#endif //DEBUG_EEPROM_CHANGES
eeprom_update_word(dst, value);
}
#ifndef DEBUG_EEPROM_CHANGES
void eeprom_write_dword_notify(uint32_t *dst, uint32_t value){
#else
void eeprom_write_dword_notify(uint32_t *dst, uint32_t value, bool active){
if (active) {
uint32_t previous_value = eeprom_read_dword(dst);
eeprom_dword_notify(dst, previous_value, value, true);
}
#endif //DEBUG_EEPROM_CHANGES
eeprom_write_dword(dst, value);
}
#ifndef DEBUG_EEPROM_CHANGES
void eeprom_update_dword_notify(uint32_t *dst, uint32_t value){
#else
void eeprom_update_dword_notify(uint32_t *dst, uint32_t value, bool active){
if (active) {
uint32_t previous_value = eeprom_read_dword(dst);
if (previous_value != value) {
eeprom_dword_notify(dst, previous_value, value, false);
}
}
#endif //DEBUG_EEPROM_CHANGES
eeprom_update_dword(dst, value);
}
#ifndef DEBUG_EEPROM_CHANGES
void eeprom_write_float_notify(float *dst, float value){
#else
void eeprom_write_float_notify(float *dst, float value, bool active){
if (active) {
float previous_value = eeprom_read_float(dst);
eeprom_float_notify(dst, previous_value, value, true);
}
#endif //DEBUG_EEPROM_CHANGES
eeprom_write_float(dst, value);
}
#ifndef DEBUG_EEPROM_CHANGES
void eeprom_update_float_notify(float *dst, float value){
#else
void eeprom_update_float_notify(float *dst, float value, bool active){
if (active) {
float previous_value = eeprom_read_float(dst);
if (previous_value != value) {
eeprom_float_notify(dst, previous_value, value, false);
}
}
#endif //DEBUG_EEPROM_CHANGES
eeprom_update_float(dst, value);
}
#ifndef DEBUG_EEPROM_CHANGES
void eeprom_write_block_notify(const void *__src, void *__dst, size_t __n){
eeprom_write_block(__src, __dst, __n);
#else
void eeprom_write_block_notify(const void *__src, void *__dst, size_t __n, bool active){
if (active) {
uint8_t previous_values[__n];
uint8_t new_values[__n];
eeprom_read_block(previous_values, __dst, __n);
eeprom_write_block(__src, __dst, __n);
eeprom_read_block(new_values, __dst, __n);
eeprom_block_notify(__dst, previous_values, new_values, __n, true);
}
#endif //DEBUG_EEPROM_CHANGES
}
#ifndef DEBUG_EEPROM_CHANGES
void eeprom_update_block_notify(const void *__src, void *__dst, size_t __n){
eeprom_update_block(__src, __dst, __n);
#else
void eeprom_update_block_notify(const void *__src, void *__dst, size_t __n, bool active){
if (active) {
uint8_t previous_values[__n];
uint8_t new_values[__n];
eeprom_read_block(previous_values, __dst, __n);
eeprom_update_block(__src, __dst, __n);
eeprom_read_block(new_values, __dst, __n);
eeprom_block_notify(__dst, previous_values, new_values, __n, false);
}
#endif //DEBUG_EEPROM_CHANGES
}
void eeprom_switch_to_next_sheet()
{
int8_t sheet = eeprom_read_byte(&(EEPROM_Sheets_base->active_sheet));
sheet = eeprom_next_initialized_sheet(sheet);
if (sheet >= 0) eeprom_update_byte(&(EEPROM_Sheets_base->active_sheet), sheet);
if (sheet >= 0) eeprom_update_byte_notify(&(EEPROM_Sheets_base->active_sheet), sheet);
}
bool __attribute__((noinline)) eeprom_is_sheet_initialized(uint8_t sheet_num) {
@ -163,44 +326,44 @@ void eeprom_update_block_P(const void *__src, void *__dst, size_t __n) {
const uint8_t *src = (const uint8_t*)__src;
uint8_t *dst = (uint8_t*)__dst;
while (__n--) {
eeprom_update_byte(dst++, pgm_read_byte(src++));
eeprom_update_byte_notify(dst++, pgm_read_byte(src++));
}
}
void eeprom_toggle(uint8_t *__p) {
eeprom_write_byte(__p, !eeprom_read_byte(__p));
eeprom_write_byte_notify(__p, !eeprom_read_byte(__p));
}
void __attribute__((noinline)) eeprom_increment_byte(uint8_t *__p) {
eeprom_write_byte(__p, eeprom_read_byte(__p) + 1);
eeprom_write_byte_notify(__p, eeprom_read_byte(__p) + 1);
}
void __attribute__((noinline)) eeprom_increment_word(uint16_t *__p) {
eeprom_write_word(__p, eeprom_read_word(__p) + 1);
eeprom_write_word_notify(__p, eeprom_read_word(__p) + 1);
}
void __attribute__((noinline)) eeprom_increment_dword(uint32_t *__p) {
eeprom_write_dword(__p, eeprom_read_dword(__p) + 1);
eeprom_write_dword_notify(__p, eeprom_read_dword(__p) + 1);
}
void __attribute__((noinline)) eeprom_add_byte(uint8_t *__p, uint8_t add) {
eeprom_write_byte(__p, eeprom_read_byte(__p) + add);
eeprom_write_byte_notify(__p, eeprom_read_byte(__p) + add);
}
void __attribute__((noinline)) eeprom_add_word(uint16_t *__p, uint16_t add) {
eeprom_write_word(__p, eeprom_read_word(__p) + add);
eeprom_write_word_notify(__p, eeprom_read_word(__p) + add);
}
void __attribute__((noinline)) eeprom_add_dword(uint32_t *__p, uint32_t add) {
eeprom_write_dword(__p, eeprom_read_dword(__p) + add);
eeprom_write_dword_notify(__p, eeprom_read_dword(__p) + add);
}
uint8_t __attribute__((noinline)) eeprom_init_default_byte(uint8_t *__p, uint8_t def) {
uint8_t val = eeprom_read_byte(__p);
if (val == EEPROM_EMPTY_VALUE) {
eeprom_write_byte(__p, def);
eeprom_write_byte_notify(__p, def);
return def;
}
return val;
@ -209,7 +372,7 @@ uint8_t __attribute__((noinline)) eeprom_init_default_byte(uint8_t *__p, uint8_t
uint16_t __attribute__((noinline)) eeprom_init_default_word(uint16_t *__p, uint16_t def) {
uint16_t val = eeprom_read_word(__p);
if (val == EEPROM_EMPTY_VALUE16) {
eeprom_write_word(__p, def);
eeprom_write_word_notify(__p, def);
return def;
}
return val;
@ -218,7 +381,7 @@ uint16_t __attribute__((noinline)) eeprom_init_default_word(uint16_t *__p, uint1
uint32_t __attribute__((noinline)) eeprom_init_default_dword(uint32_t *__p, uint32_t def) {
uint32_t val = eeprom_read_dword(__p);
if (val == EEPROM_EMPTY_VALUE32) {
eeprom_write_dword(__p, def);
eeprom_write_dword_notify(__p, def);
return def;
}
return val;
@ -226,12 +389,12 @@ uint32_t __attribute__((noinline)) eeprom_init_default_dword(uint32_t *__p, uint
void __attribute__((noinline)) eeprom_init_default_float(float *__p, float def) {
if (eeprom_read_dword((uint32_t*)__p) == EEPROM_EMPTY_VALUE32)
eeprom_write_float(__p, def);
eeprom_write_float_notify(__p, def);
}
void __attribute__((noinline)) eeprom_init_default_block(void *__p, size_t __n, const void *def) {
if (!eeprom_is_initialized_block(__p, __n))
eeprom_update_block(def, __p, __n);
eeprom_update_block_notify(def, __p, __n);
}
void __attribute__((noinline)) eeprom_init_default_block_P(void *__p, size_t __n, const void *def) {

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_block(void *__p, size_t __n, const void *def);
void eeprom_init_default_block_P(void *__p, size_t __n, const void *def);
/// Updates eeprom byte and notifies the changed eeprom address (just the address!) onto the serial line
#ifndef DEBUG_EEPROM_CHANGES
void eeprom_write_byte_notify(uint8_t *dst, uint8_t value);
void eeprom_update_byte_notify(uint8_t *dst, uint8_t value);
void eeprom_write_word_notify(uint16_t *dst, uint16_t value);
void eeprom_update_word_notify(uint16_t *dst, uint16_t value);
void eeprom_write_dword_notify(uint32_t *dst, uint32_t value);
void eeprom_update_dword_notify(uint32_t *dst, uint32_t value);
void eeprom_write_float_notify(float *dst, float value);
void eeprom_update_float_notify(float *dst, float value);
void eeprom_write_block_notify(const void *__src, void *__dst , size_t __size);
void eeprom_update_block_notify(const void *__src, void *__dst, size_t __size);
#else
void eeprom_write_byte_notify(uint8_t *dst, uint8_t value, bool active = true);
void eeprom_update_byte_notify(uint8_t *dst, uint8_t value, bool active = true);
void eeprom_write_word_notify(uint16_t *dst, uint16_t value, bool active = true);
void eeprom_update_word_notify(uint16_t *dst, uint16_t value, bool active = true);
void eeprom_write_dword_notify(uint32_t *dst, uint32_t value, bool active = true);
void eeprom_update_dword_notify(uint32_t *dst, uint32_t value, bool active = true);
void eeprom_write_float_notify(float *dst, float value, bool active = true);
void eeprom_update_float_notify(float *dst, float value, bool active = true);
void eeprom_write_block_notify(const void *__src, void *__dst , size_t __size, bool active = true);
void eeprom_update_block_notify(const void *__src, void *__dst, size_t __size , bool active = true);
#endif //DEBUG_EEPROM_CHANGES
#endif
#endif // EEPROM_H

2
Firmware/fancheck.cpp
View File

@ -238,7 +238,7 @@ bool extruder_altfan_detect()
void altfanOverride_toggle()
{
altfanStatus.altfanOverride = !altfanStatus.altfanOverride;
eeprom_update_byte((uint8_t *)EEPROM_ALTFAN_OVERRIDE, altfanStatus.altfanOverride);
eeprom_update_byte_notify((uint8_t *)EEPROM_ALTFAN_OVERRIDE, altfanStatus.altfanOverride);
}
bool altfanOverride_get()

30
Firmware/mesh_bed_calibration.cpp
View File

@ -373,7 +373,7 @@ BedSkewOffsetDetectionResultType calculate_machine_skew_and_offset_LS(
angleDiff = fabs(a2 - a1);
/// XY skew and Y-bed skew
DBG(_n("Measured skews: %f %f\n"), degrees(a2 - a1), degrees(a2));
eeprom_update_float((float *)(EEPROM_XYZ_CAL_SKEW), angleDiff); //storing xyz cal. skew to be able to show in support menu later
eeprom_update_float_notify((float *)(EEPROM_XYZ_CAL_SKEW), angleDiff); //storing xyz cal. skew to be able to show in support menu later
if (angleDiff > bed_skew_angle_mild)
result = (angleDiff > bed_skew_angle_extreme) ?
BED_SKEW_OFFSET_DETECTION_SKEW_EXTREME :
@ -669,16 +669,16 @@ BedSkewOffsetDetectionResultType calculate_machine_skew_and_offset_LS(
*/
void reset_bed_offset_and_skew()
{
eeprom_update_dword((uint32_t*)(EEPROM_BED_CALIBRATION_CENTER+0), 0x0FFFFFFFF);
eeprom_update_dword((uint32_t*)(EEPROM_BED_CALIBRATION_CENTER+4), 0x0FFFFFFFF);
eeprom_update_dword((uint32_t*)(EEPROM_BED_CALIBRATION_VEC_X +0), 0x0FFFFFFFF);
eeprom_update_dword((uint32_t*)(EEPROM_BED_CALIBRATION_VEC_X +4), 0x0FFFFFFFF);
eeprom_update_dword((uint32_t*)(EEPROM_BED_CALIBRATION_VEC_Y +0), 0x0FFFFFFFF);
eeprom_update_dword((uint32_t*)(EEPROM_BED_CALIBRATION_VEC_Y +4), 0x0FFFFFFFF);
eeprom_update_dword_notify((uint32_t*)(EEPROM_BED_CALIBRATION_CENTER+0), 0x0FFFFFFFF);
eeprom_update_dword_notify((uint32_t*)(EEPROM_BED_CALIBRATION_CENTER+4), 0x0FFFFFFFF);
eeprom_update_dword_notify((uint32_t*)(EEPROM_BED_CALIBRATION_VEC_X +0), 0x0FFFFFFFF);
eeprom_update_dword_notify((uint32_t*)(EEPROM_BED_CALIBRATION_VEC_X +4), 0x0FFFFFFFF);
eeprom_update_dword_notify((uint32_t*)(EEPROM_BED_CALIBRATION_VEC_Y +0), 0x0FFFFFFFF);
eeprom_update_dword_notify((uint32_t*)(EEPROM_BED_CALIBRATION_VEC_Y +4), 0x0FFFFFFFF);
// Reset the 8 16bit offsets.
for (int8_t i = 0; i < 4; ++ i)
eeprom_update_dword((uint32_t*)(EEPROM_BED_CALIBRATION_Z_JITTER+i*4), 0x0FFFFFFFF);
eeprom_update_dword_notify((uint32_t*)(EEPROM_BED_CALIBRATION_Z_JITTER+i*4), 0x0FFFFFFFF);
}
bool is_bed_z_jitter_data_valid()
@ -2443,9 +2443,9 @@ BedSkewOffsetDetectionResultType find_bed_offset_and_skew(int8_t verbosity_level
world2machine_update(vec_x, vec_y, cntr);
// Fearlessly store the calibration values into the eeprom.
eeprom_update_block(&cntr[0], (float*)(EEPROM_BED_CALIBRATION_CENTER), 8);
eeprom_update_block(&vec_x[0], (float*)(EEPROM_BED_CALIBRATION_VEC_X), 8);
eeprom_update_block(&vec_y[0], (float*)(EEPROM_BED_CALIBRATION_VEC_Y), 8);
eeprom_update_block_notify(&cntr[0], (float*)(EEPROM_BED_CALIBRATION_CENTER), 8);
eeprom_update_block_notify(&vec_x[0], (float*)(EEPROM_BED_CALIBRATION_VEC_X), 8);
eeprom_update_block_notify(&vec_y[0], (float*)(EEPROM_BED_CALIBRATION_VEC_Y), 8);
#ifdef SUPPORT_VERBOSITY
if (verbosity_level >= 10) {
@ -2731,9 +2731,9 @@ BedSkewOffsetDetectionResultType improve_bed_offset_and_skew(int8_t method, int8
world2machine_update(vec_x, vec_y, cntr);
// Fearlessly store the calibration values into the eeprom.
eeprom_update_block(&cntr[0], (float*)(EEPROM_BED_CALIBRATION_CENTER), 8);
eeprom_update_block(&vec_x[0], (float*)(EEPROM_BED_CALIBRATION_VEC_X), 8);
eeprom_update_block(&vec_y[0], (float*)(EEPROM_BED_CALIBRATION_VEC_Y), 8);
eeprom_update_block_notify(&cntr[0], (float*)(EEPROM_BED_CALIBRATION_CENTER), 8);
eeprom_update_block_notify(&vec_x[0], (float*)(EEPROM_BED_CALIBRATION_VEC_X), 8);
eeprom_update_block_notify(&vec_y[0], (float*)(EEPROM_BED_CALIBRATION_VEC_Y), 8);
// Correct the current_position to match the transformed coordinate system after world2machine_rotation_and_skew and world2machine_shift were set.
world2machine_update_current();
@ -2934,7 +2934,7 @@ bool sample_mesh_and_store_reference()
continue;
float dif = mbl.z_values[j][i] - mbl.z_values[0][0];
int16_t dif_quantized = int16_t(floor(dif * 100.f + 0.5f));
eeprom_update_word((uint16_t*)addr, *reinterpret_cast<uint16_t*>(&dif_quantized));
eeprom_update_word_notify((uint16_t*)addr, *reinterpret_cast<uint16_t*>(&dif_quantized));
#if 0
{
uint16_t z_offset_u = eeprom_read_word((uint16_t*)addr);

2
Firmware/mmu2_reporting.cpp
View File

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

50
Firmware/power_panic.cpp
View File

@ -113,11 +113,11 @@ void uvlo_() {
// mesh bed leveling offset value.
logical_z -= mbl.get_z(saved_pos[X_AXIS], saved_pos[Y_AXIS]);
}
eeprom_update_float((float*)EEPROM_UVLO_CURRENT_POSITION_Z, logical_z);
eeprom_update_float_notify((float*)EEPROM_UVLO_CURRENT_POSITION_Z, logical_z);
// Store the print E position before we lose track
eeprom_update_float((float*)(EEPROM_UVLO_CURRENT_POSITION_E), saved_pos[E_AXIS]);
eeprom_update_byte((uint8_t*)EEPROM_UVLO_E_ABS, !saved_extruder_relative_mode);
eeprom_update_float_notify((float*)(EEPROM_UVLO_CURRENT_POSITION_E), saved_pos[E_AXIS]);
eeprom_update_byte_notify((uint8_t*)EEPROM_UVLO_E_ABS, !saved_extruder_relative_mode);
// Clean the input command queue, inhibit serial processing using saved_printing
cmdqueue_reset();
@ -149,7 +149,7 @@ void uvlo_() {
poweroff_z();
// Write the file position.
eeprom_update_dword((uint32_t*)(EEPROM_FILE_POSITION), saved_sdpos);
eeprom_update_dword_notify((uint32_t*)(EEPROM_FILE_POSITION), saved_sdpos);
// Store the mesh bed leveling offsets. This is 2*7*7=98 bytes, which takes 98*3.4us=333us in worst case.
for (uint8_t mesh_point = 0; mesh_point < MESH_NUM_X_POINTS * MESH_NUM_Y_POINTS; ++ mesh_point)
@ -158,41 +158,41 @@ void uvlo_() {
uint8_t iy = mesh_point / MESH_NUM_X_POINTS;
// Scale the z value to 1u resolution.
int16_t v = mbl_was_active ? int16_t(floor(mbl.z_values[iy][ix] * 1000.f + 0.5f)) : 0;
eeprom_update_word((uint16_t*)(EEPROM_UVLO_MESH_BED_LEVELING_FULL +2*mesh_point), *reinterpret_cast<uint16_t*>(&v));
eeprom_update_word_notify((uint16_t*)(EEPROM_UVLO_MESH_BED_LEVELING_FULL +2*mesh_point), *reinterpret_cast<uint16_t*>(&v));
}
// Write the _final_ Z position
eeprom_update_float((float*)EEPROM_UVLO_TINY_CURRENT_POSITION_Z, current_position[Z_AXIS]);
eeprom_update_float_notify((float*)EEPROM_UVLO_TINY_CURRENT_POSITION_Z, current_position[Z_AXIS]);
// Store the current position.
eeprom_update_float((float*)(EEPROM_UVLO_CURRENT_POSITION + 0), saved_pos[X_AXIS]);
eeprom_update_float((float*)(EEPROM_UVLO_CURRENT_POSITION + 4), saved_pos[Y_AXIS]);
eeprom_update_float_notify((float*)(EEPROM_UVLO_CURRENT_POSITION + 0), saved_pos[X_AXIS]);
eeprom_update_float_notify((float*)(EEPROM_UVLO_CURRENT_POSITION + 4), saved_pos[Y_AXIS]);
// Store the current feed rate, temperatures, fan speed and extruder multipliers (flow rates)
eeprom_update_word((uint16_t*)EEPROM_UVLO_FEEDRATE, saved_feedrate2);
eeprom_update_word((uint16_t*)EEPROM_UVLO_FEEDMULTIPLY, feedmultiply);
eeprom_update_word((uint16_t*)EEPROM_UVLO_TARGET_HOTEND, saved_extruder_temperature);
eeprom_update_byte((uint8_t*)EEPROM_UVLO_TARGET_BED, saved_bed_temperature);
eeprom_update_byte((uint8_t*)EEPROM_UVLO_FAN_SPEED, saved_fan_speed);
eeprom_update_float((float*)(EEPROM_EXTRUDER_MULTIPLIER_0), extruder_multiplier[0]);
eeprom_update_word((uint16_t*)(EEPROM_EXTRUDEMULTIPLY), (uint16_t)extrudemultiply);
eeprom_update_word_notify((uint16_t*)EEPROM_UVLO_FEEDRATE, saved_feedrate2);
eeprom_update_word_notify((uint16_t*)EEPROM_UVLO_FEEDMULTIPLY, feedmultiply);
eeprom_update_word_notify((uint16_t*)EEPROM_UVLO_TARGET_HOTEND, saved_extruder_temperature);
eeprom_update_byte_notify((uint8_t*)EEPROM_UVLO_TARGET_BED, saved_bed_temperature);
eeprom_update_byte_notify((uint8_t*)EEPROM_UVLO_FAN_SPEED, saved_fan_speed);
eeprom_update_float_notify((float*)(EEPROM_EXTRUDER_MULTIPLIER_0), extruder_multiplier[0]);
eeprom_update_word_notify((uint16_t*)(EEPROM_EXTRUDEMULTIPLY), (uint16_t)extrudemultiply);
eeprom_update_float((float*)(EEPROM_UVLO_ACCELL), cs.acceleration);
eeprom_update_float((float*)(EEPROM_UVLO_RETRACT_ACCELL), cs.retract_acceleration);
eeprom_update_float((float*)(EEPROM_UVLO_TRAVEL_ACCELL), cs.travel_acceleration);
eeprom_update_float_notify((float*)(EEPROM_UVLO_ACCELL), cs.acceleration);
eeprom_update_float_notify((float*)(EEPROM_UVLO_RETRACT_ACCELL), cs.retract_acceleration);
eeprom_update_float_notify((float*)(EEPROM_UVLO_TRAVEL_ACCELL), cs.travel_acceleration);
// Store the saved target
eeprom_update_block(saved_start_position, (float *)EEPROM_UVLO_SAVED_START_POSITION, sizeof(saved_start_position));
eeprom_update_block_notify(saved_start_position, (float *)EEPROM_UVLO_SAVED_START_POSITION, sizeof(saved_start_position));
eeprom_update_word((uint16_t*)EEPROM_UVLO_SAVED_SEGMENT_IDX, saved_segment_idx);
eeprom_update_byte((uint8_t*)EEPROM_UVLO_PRINT_TYPE, saved_printing_type);
eeprom_update_word_notify((uint16_t*)EEPROM_UVLO_SAVED_SEGMENT_IDX, saved_segment_idx);
eeprom_update_byte_notify((uint8_t*)EEPROM_UVLO_PRINT_TYPE, saved_printing_type);
#ifdef LIN_ADVANCE
eeprom_update_float((float*)(EEPROM_UVLO_LA_K), extruder_advance_K);
eeprom_update_float_notify((float*)(EEPROM_UVLO_LA_K), extruder_advance_K);
#endif
// Finally store the "power outage" flag.
eeprom_update_byte((uint8_t*)EEPROM_UVLO, PowerPanic::PENDING_RECOVERY);
eeprom_update_byte_notify((uint8_t*)EEPROM_UVLO, PowerPanic::PENDING_RECOVERY);
// Increment power failure counter
eeprom_increment_byte((uint8_t*)EEPROM_POWER_COUNT);
@ -260,11 +260,11 @@ static void uvlo_tiny() {
poweroff_z();
// Update Z position
eeprom_update_float((float*)(EEPROM_UVLO_TINY_CURRENT_POSITION_Z), current_position[Z_AXIS]);
eeprom_update_float_notify((float*)(EEPROM_UVLO_TINY_CURRENT_POSITION_Z), current_position[Z_AXIS]);
}
// Update the the "power outage" flag.
eeprom_update_byte((uint8_t*)EEPROM_UVLO, PowerPanic::PENDING_RECOVERY_RETRY);
eeprom_update_byte_notify((uint8_t*)EEPROM_UVLO, PowerPanic::PENDING_RECOVERY_RETRY);
// Increment power failure counter
eeprom_increment_byte((uint8_t*)EEPROM_POWER_COUNT);

2
Firmware/sound.cpp
View File

@ -30,7 +30,7 @@ void Sound_Init(void)
void Sound_SaveMode(void)
{
eeprom_update_byte((uint8_t*)EEPROM_SOUND_MODE,(uint8_t)eSoundMode);
eeprom_update_byte_notify((uint8_t*)EEPROM_SOUND_MODE,(uint8_t)eSoundMode);
}
void Sound_CycleState(void)

22
Firmware/temperature.cpp
View File

@ -2431,17 +2431,17 @@ void thermal_model_load_settings()
void thermal_model_save_settings()
{
eeprom_update_byte((uint8_t*)EEPROM_THERMAL_MODEL_ENABLE, thermal_model::enabled);
eeprom_update_float((float*)EEPROM_THERMAL_MODEL_P, thermal_model::data.P);
eeprom_update_float((float*)EEPROM_THERMAL_MODEL_U, thermal_model::data.U);
eeprom_update_float((float*)EEPROM_THERMAL_MODEL_V, thermal_model::data.V);
eeprom_update_float((float*)EEPROM_THERMAL_MODEL_C, thermal_model::data.C);
eeprom_update_float((float*)EEPROM_THERMAL_MODEL_D, thermal_model::data.fS);
eeprom_update_word((uint16_t*)EEPROM_THERMAL_MODEL_L, thermal_model::data.L);
eeprom_update_block(&thermal_model::data.R[0], (float*)EEPROM_THERMAL_MODEL_R, THERMAL_MODEL_R_SIZE * sizeof(float));
eeprom_update_float((float*)EEPROM_THERMAL_MODEL_Ta_corr, thermal_model::data.Ta_corr);
eeprom_update_float((float*)EEPROM_THERMAL_MODEL_W, thermal_model::data.warn);
eeprom_update_float((float*)EEPROM_THERMAL_MODEL_E, thermal_model::data.err);
eeprom_update_byte_notify((uint8_t*)EEPROM_THERMAL_MODEL_ENABLE, thermal_model::enabled);
eeprom_update_float_notify((float*)EEPROM_THERMAL_MODEL_P, thermal_model::data.P);
eeprom_update_float_notify((float*)EEPROM_THERMAL_MODEL_U, thermal_model::data.U);
eeprom_update_float_notify((float*)EEPROM_THERMAL_MODEL_V, thermal_model::data.V);
eeprom_update_float_notify((float*)EEPROM_THERMAL_MODEL_C, thermal_model::data.C);
eeprom_update_float_notify((float*)EEPROM_THERMAL_MODEL_D, thermal_model::data.fS);
eeprom_update_word_notify((uint16_t*)EEPROM_THERMAL_MODEL_L, thermal_model::data.L);
eeprom_update_block_notify(&thermal_model::data.R[0], (float*)EEPROM_THERMAL_MODEL_R, THERMAL_MODEL_R_SIZE * sizeof(float));
eeprom_update_float_notify((float*)EEPROM_THERMAL_MODEL_Ta_corr, thermal_model::data.Ta_corr);
eeprom_update_float_notify((float*)EEPROM_THERMAL_MODEL_W, thermal_model::data.warn);
eeprom_update_float_notify((float*)EEPROM_THERMAL_MODEL_E, thermal_model::data.err);
}
namespace thermal_model_cal {

4
Firmware/tmc2130.cpp
View File

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

108
Firmware/ultralcd.cpp
View File

@ -1732,7 +1732,7 @@ static void lcd_support_menu()
void lcd_set_fan_check() {
fans_check_enabled = !fans_check_enabled;
eeprom_update_byte((unsigned char *)EEPROM_FAN_CHECK_ENABLED, fans_check_enabled);
eeprom_update_byte_notify((unsigned char *)EEPROM_FAN_CHECK_ENABLED, fans_check_enabled);
#ifdef FANCHECK
if (fans_check_enabled == false) fan_check_error = EFCE_OK; //reset error if fanCheck is disabled during error. Allows resuming print.
#endif //FANCHECK
@ -1744,19 +1744,19 @@ void lcd_cutter_enabled()
if (EEPROM_MMU_CUTTER_ENABLED_enabled == eeprom_read_byte((uint8_t*)EEPROM_MMU_CUTTER_ENABLED))
{
#ifndef MMU_ALWAYS_CUT
eeprom_update_byte((uint8_t*)EEPROM_MMU_CUTTER_ENABLED, 0);
eeprom_update_byte_notify((uint8_t*)EEPROM_MMU_CUTTER_ENABLED, 0);
}
#else //MMU_ALWAYS_CUT
eeprom_update_byte((uint8_t*)EEPROM_MMU_CUTTER_ENABLED, EEPROM_MMU_CUTTER_ENABLED_always);
eeprom_update_byte_notify((uint8_t*)EEPROM_MMU_CUTTER_ENABLED, EEPROM_MMU_CUTTER_ENABLED_always);
}
else if (EEPROM_MMU_CUTTER_ENABLED_always == eeprom_read_byte((uint8_t*)EEPROM_MMU_CUTTER_ENABLED))
{
eeprom_update_byte((uint8_t*)EEPROM_MMU_CUTTER_ENABLED, 0);
eeprom_update_byte_notify((uint8_t*)EEPROM_MMU_CUTTER_ENABLED, 0);
}
#endif //MMU_ALWAYS_CUT
else
{
eeprom_update_byte((uint8_t*)EEPROM_MMU_CUTTER_ENABLED, EEPROM_MMU_CUTTER_ENABLED_enabled);
eeprom_update_byte_notify((uint8_t*)EEPROM_MMU_CUTTER_ENABLED, EEPROM_MMU_CUTTER_ENABLED_enabled);
}
}
#endif //MMU_HAS_CUTTER
@ -2638,12 +2638,12 @@ static void lcd_babystep_z()
{
// Only update the EEPROM when leaving the menu.
uint8_t active_sheet=eeprom_read_byte(&(EEPROM_Sheets_base->active_sheet));
eeprom_update_word(reinterpret_cast<uint16_t *>(&(EEPROM_Sheets_base->s[active_sheet].z_offset)),_md->babystepMemZ);
eeprom_update_word_notify(reinterpret_cast<uint16_t *>(&(EEPROM_Sheets_base->s[active_sheet].z_offset)),_md->babystepMemZ);
// NOTE: bed_temp and pinda_temp are not currently read/used anywhere.
eeprom_update_byte(&(EEPROM_Sheets_base->s[active_sheet].bed_temp),target_temperature_bed);
eeprom_update_byte_notify(&(EEPROM_Sheets_base->s[active_sheet].bed_temp),target_temperature_bed);
#ifdef PINDA_THERMISTOR
eeprom_update_byte(&(EEPROM_Sheets_base->s[active_sheet].pinda_temp),current_temperature_pinda);
eeprom_update_byte_notify(&(EEPROM_Sheets_base->s[active_sheet].pinda_temp),current_temperature_pinda);
#endif //PINDA_THERMISTOR
calibration_status_set(CALIBRATION_STATUS_LIVE_ADJUST);
}
@ -2699,11 +2699,11 @@ void lcd_adjust_bed(void)
MENU_BEGIN();
// leaving menu - this condition must be immediately before MENU_ITEM_BACK_P
ON_MENU_LEAVE(
eeprom_update_byte((uint8_t*)EEPROM_BED_CORRECTION_LEFT, (uint8_t)_md->left);
eeprom_update_byte((uint8_t*)EEPROM_BED_CORRECTION_FRONT, (uint8_t)_md->front);
eeprom_update_byte((uint8_t*)EEPROM_BED_CORRECTION_REAR, (uint8_t)_md->rear);
eeprom_update_byte((uint8_t*)EEPROM_BED_CORRECTION_RIGHT, (uint8_t)_md->right);
eeprom_update_byte((uint8_t*)EEPROM_BED_CORRECTION_VALID, 1);
eeprom_update_byte_notify((uint8_t*)EEPROM_BED_CORRECTION_LEFT, (uint8_t)_md->left);
eeprom_update_byte_notify((uint8_t*)EEPROM_BED_CORRECTION_FRONT, (uint8_t)_md->front);
eeprom_update_byte_notify((uint8_t*)EEPROM_BED_CORRECTION_REAR, (uint8_t)_md->rear);
eeprom_update_byte_notify((uint8_t*)EEPROM_BED_CORRECTION_RIGHT, (uint8_t)_md->right);
eeprom_update_byte_notify((uint8_t*)EEPROM_BED_CORRECTION_VALID, 1);
);
MENU_ITEM_BACK_P(_T(MSG_BACK));
MENU_ITEM_EDIT_int3_P(_i("Left side [\xe4m]"), &_md->left, -BED_ADJUSTMENT_UM_MAX, BED_ADJUSTMENT_UM_MAX);////MSG_BED_CORRECTION_LEFT c=14
@ -3222,8 +3222,8 @@ void lcd_temp_cal_show_result(bool result) {
setTargetBed(0); //set bed target temperature back to 0
// Store boolean result
eeprom_update_byte((uint8_t*)EEPROM_CALIBRATION_STATUS_PINDA, result);
eeprom_update_byte((uint8_t*)EEPROM_TEMP_CAL_ACTIVE, result);
eeprom_update_byte_notify((uint8_t*)EEPROM_CALIBRATION_STATUS_PINDA, result);
eeprom_update_byte_notify((uint8_t*)EEPROM_TEMP_CAL_ACTIVE, result);
if (result) {
SERIAL_ECHOLNPGM("PINDA calibration done. Continue with pressing the knob.");
@ -3362,7 +3362,7 @@ static void lcd_sort_type_set() {
case SD_SORT_ALPHA: sdSort = SD_SORT_NONE; break;
default: sdSort = SD_SORT_TIME;
}
eeprom_update_byte((uint8_t*)EEPROM_SD_SORT, sdSort);
eeprom_update_byte_notify((uint8_t*)EEPROM_SD_SORT, sdSort);
card.presort_flag = true;
}
#endif //SDCARD_SORT_ALPHA
@ -3406,7 +3406,7 @@ static void lcd_silent_mode_set() {
default: SilentModeMenu = SILENT_MODE_POWER; break; // (probably) not needed
#endif //TMC2130
}
eeprom_update_byte((unsigned char *)EEPROM_SILENT, SilentModeMenu);
eeprom_update_byte_notify((unsigned char *)EEPROM_SILENT, SilentModeMenu);
#ifdef TMC2130
if (blocks_queued())
{
@ -3534,14 +3534,14 @@ void lcd_mesh_calibration_z()
void lcd_temp_calibration_set() {
bool temp_cal_active = eeprom_read_byte((unsigned char *)EEPROM_TEMP_CAL_ACTIVE);
temp_cal_active = !temp_cal_active;
eeprom_update_byte((unsigned char *)EEPROM_TEMP_CAL_ACTIVE, temp_cal_active);
eeprom_update_byte_notify((unsigned char *)EEPROM_TEMP_CAL_ACTIVE, temp_cal_active);
}
#ifdef HAS_SECOND_SERIAL_PORT
void lcd_second_serial_set() {
if(selectedSerialPort == 1) selectedSerialPort = 0;
else selectedSerialPort = 1;
eeprom_update_byte((unsigned char *)EEPROM_SECOND_SERIAL_ACTIVE, selectedSerialPort);
eeprom_update_byte_notify((unsigned char *)EEPROM_SECOND_SERIAL_ACTIVE, selectedSerialPort);
MYSERIAL.begin(BAUDRATE);
}
#endif //HAS_SECOND_SERIAL_PORT
@ -3554,7 +3554,7 @@ void lcd_calibrate_pinda() {
void lcd_toshiba_flash_air_compatibility_toggle()
{
card.ToshibaFlashAir_enable(! card.ToshibaFlashAir_isEnabled());
eeprom_update_byte((uint8_t*)EEPROM_TOSHIBA_FLASH_AIR_COMPATIBLITY, card.ToshibaFlashAir_isEnabled());
eeprom_update_byte_notify((uint8_t*)EEPROM_TOSHIBA_FLASH_AIR_COMPATIBLITY, card.ToshibaFlashAir_isEnabled());
}
//! @brief Continue first layer calibration with previous value or start from zero?
@ -3583,7 +3583,7 @@ void lcd_first_layer_calibration_reset()
{
if (menuData->reset)
{
eeprom_update_word(reinterpret_cast<uint16_t*>(&EEPROM_Sheets_base->s[(eeprom_read_byte(&(EEPROM_Sheets_base->active_sheet)))].z_offset), 0xffff);
eeprom_update_word_notify(reinterpret_cast<uint16_t*>(&EEPROM_Sheets_base->s[(eeprom_read_byte(&(EEPROM_Sheets_base->active_sheet)))].z_offset), 0xffff);
}
// If the knob was clicked, don't produce feedback
@ -3781,7 +3781,7 @@ void lcd_wizard(WizState state)
uint8_t wizard_event;
// Make sure EEPROM_WIZARD_ACTIVE is true if entering using different entry point
// other than WizState::Run - it is useful for debugging wizard.
if (state != S::Run) eeprom_update_byte((uint8_t*)EEPROM_WIZARD_ACTIVE, 1);
if (state != S::Run) eeprom_update_byte_notify((uint8_t*)EEPROM_WIZARD_ACTIVE, 1);
FORCE_BL_ON_START;
@ -3810,10 +3810,10 @@ void lcd_wizard(WizState state)
wizard_event = lcd_show_multiscreen_message_yes_no_and_wait_P(_T(MSG_WIZARD_WELCOME), false, LCD_LEFT_BUTTON_CHOICE);
if (wizard_event == LCD_LEFT_BUTTON_CHOICE) {
state = S::Restore;
eeprom_update_byte((uint8_t*)EEPROM_WIZARD_ACTIVE, 1);
eeprom_update_byte_notify((uint8_t*)EEPROM_WIZARD_ACTIVE, 1);
} else {
// user interrupted
eeprom_update_byte((uint8_t*)EEPROM_WIZARD_ACTIVE, 0);
eeprom_update_byte_notify((uint8_t*)EEPROM_WIZARD_ACTIVE, 0);
end = true;
}
}
@ -3934,7 +3934,7 @@ void lcd_wizard(WizState state)
break;
case S::Finish:
case S::Failed:
eeprom_update_byte((uint8_t*)EEPROM_WIZARD_ACTIVE, 0);
eeprom_update_byte_notify((uint8_t*)EEPROM_WIZARD_ACTIVE, 0);
end = true;
break;
}
@ -4218,7 +4218,7 @@ switch(oCheckMode)
default:
oCheckMode=ClCheckMode::_None;
}
eeprom_update_byte((uint8_t*)EEPROM_CHECK_MODE,(uint8_t)oCheckMode);
eeprom_update_byte_notify((uint8_t*)EEPROM_CHECK_MODE,(uint8_t)oCheckMode);
}
#define SETTINGS_MODE \
@ -4264,8 +4264,8 @@ static void lcd_nozzle_diameter_cycle(void) {
oNozzleDiameter=ClNozzleDiameter::_Diameter_400;
nDiameter=400;
}
eeprom_update_byte((uint8_t*)EEPROM_NOZZLE_DIAMETER,(uint8_t)oNozzleDiameter);
eeprom_update_word((uint16_t*)EEPROM_NOZZLE_DIAMETER_uM,nDiameter);
eeprom_update_byte_notify((uint8_t*)EEPROM_NOZZLE_DIAMETER,(uint8_t)oNozzleDiameter);
eeprom_update_word_notify((uint16_t*)EEPROM_NOZZLE_DIAMETER_uM,nDiameter);
}
#define SETTINGS_NOZZLE \
@ -4298,7 +4298,7 @@ switch(oCheckModel)
default:
oCheckModel=ClCheckModel::_None;
}
eeprom_update_byte((uint8_t*)EEPROM_CHECK_MODEL,(uint8_t)oCheckModel);
eeprom_update_byte_notify((uint8_t*)EEPROM_CHECK_MODEL,(uint8_t)oCheckModel);
}
#define SETTINGS_MODEL \
@ -4337,7 +4337,7 @@ switch(oCheckVersion)
default:
oCheckVersion=ClCheckVersion::_None;
}
eeprom_update_byte((uint8_t*)EEPROM_CHECK_VERSION,(uint8_t)oCheckVersion);
eeprom_update_byte_notify((uint8_t*)EEPROM_CHECK_VERSION,(uint8_t)oCheckVersion);
}
#define SETTINGS_VERSION \
@ -4541,10 +4541,10 @@ static void lcd_settings_menu()
#ifdef TMC2130
static void lcd_ustep_linearity_menu_save()
{
eeprom_update_byte((uint8_t*)EEPROM_TMC2130_WAVE_X_FAC, tmc2130_wave_fac[X_AXIS]);
eeprom_update_byte((uint8_t*)EEPROM_TMC2130_WAVE_Y_FAC, tmc2130_wave_fac[Y_AXIS]);
eeprom_update_byte((uint8_t*)EEPROM_TMC2130_WAVE_Z_FAC, tmc2130_wave_fac[Z_AXIS]);
eeprom_update_byte((uint8_t*)EEPROM_TMC2130_WAVE_E_FAC, tmc2130_wave_fac[E_AXIS]);
eeprom_update_byte_notify((uint8_t*)EEPROM_TMC2130_WAVE_X_FAC, tmc2130_wave_fac[X_AXIS]);
eeprom_update_byte_notify((uint8_t*)EEPROM_TMC2130_WAVE_Y_FAC, tmc2130_wave_fac[Y_AXIS]);
eeprom_update_byte_notify((uint8_t*)EEPROM_TMC2130_WAVE_Z_FAC, tmc2130_wave_fac[Z_AXIS]);
eeprom_update_byte_notify((uint8_t*)EEPROM_TMC2130_WAVE_E_FAC, tmc2130_wave_fac[E_AXIS]);
}
#endif //TMC2130
@ -5051,7 +5051,7 @@ void lcd_resume_usb_print()
static void change_sheet()
{
eeprom_update_byte(&(EEPROM_Sheets_base->active_sheet), selected_sheet);
eeprom_update_byte_notify(&(EEPROM_Sheets_base->active_sheet), selected_sheet);
menu_back(3);
}
@ -5096,7 +5096,7 @@ static void lcd_rename_sheet_menu()
}
else
{
eeprom_update_block(menuData->name,
eeprom_update_block_notify(menuData->name,
EEPROM_Sheets_base->s[selected_sheet].name,
sizeof(Sheet::name));
menu_back();
@ -5108,8 +5108,8 @@ static void lcd_reset_sheet()
{
SheetName sheetName;
eeprom_default_sheet_name(selected_sheet, sheetName);
eeprom_update_word(reinterpret_cast<uint16_t *>(&(EEPROM_Sheets_base->s[selected_sheet].z_offset)),EEPROM_EMPTY_VALUE16);
eeprom_update_block(sheetName.c,EEPROM_Sheets_base->s[selected_sheet].name,sizeof(Sheet::name));
eeprom_update_word_notify(reinterpret_cast<uint16_t *>(&(EEPROM_Sheets_base->s[selected_sheet].z_offset)),EEPROM_EMPTY_VALUE16);
eeprom_update_block_notify(sheetName.c,EEPROM_Sheets_base->s[selected_sheet].name,sizeof(Sheet::name));
if (selected_sheet == eeprom_read_byte(&(EEPROM_Sheets_base->active_sheet)))
{
eeprom_switch_to_next_sheet();
@ -5123,7 +5123,7 @@ static void lcd_reset_sheet()
//! @brief Activate selected_sheet and run first layer calibration
static void activate_calibrate_sheet()
{
eeprom_update_byte(&(EEPROM_Sheets_base->active_sheet), selected_sheet);
eeprom_update_byte_notify(&(EEPROM_Sheets_base->active_sheet), selected_sheet);
lcd_first_layer_calibration_reset();
}
@ -5544,14 +5544,14 @@ static void lcd_tune_menu()
static void mbl_magnets_elimination_toggle() {
bool magnet_elimination = (eeprom_read_byte((uint8_t*)EEPROM_MBL_MAGNET_ELIMINATION) > 0);
magnet_elimination = !magnet_elimination;
eeprom_update_byte((uint8_t*)EEPROM_MBL_MAGNET_ELIMINATION, (uint8_t)magnet_elimination);
eeprom_update_byte_notify((uint8_t*)EEPROM_MBL_MAGNET_ELIMINATION, (uint8_t)magnet_elimination);
}
static void mbl_mesh_toggle() {
uint8_t mesh_nr = eeprom_read_byte((uint8_t*)EEPROM_MBL_POINTS_NR);
if(mesh_nr == 3) mesh_nr = 7;
else mesh_nr = 3;
eeprom_update_byte((uint8_t*)EEPROM_MBL_POINTS_NR, mesh_nr);
eeprom_update_byte_notify((uint8_t*)EEPROM_MBL_POINTS_NR, mesh_nr);
}
static void mbl_probe_nr_toggle() {
@ -5562,7 +5562,7 @@ static void mbl_probe_nr_toggle() {
case 5: mbl_z_probe_nr = 1; break;
default: mbl_z_probe_nr = 3; break;
}
eeprom_update_byte((uint8_t*)EEPROM_MBL_PROBE_NR, mbl_z_probe_nr);
eeprom_update_byte_notify((uint8_t*)EEPROM_MBL_PROBE_NR, mbl_z_probe_nr);
}
static void lcd_mesh_bed_leveling_settings()
@ -6202,7 +6202,7 @@ bool lcd_selftest()
bres &= tmc2130_home_calibrate(Y_AXIS);
_progress = lcd_selftest_screen(TestScreen::Home, 2, 2, true, 0);
if (bres)
eeprom_update_byte((uint8_t*)EEPROM_TMC2130_HOME_ENABLED, 1);
eeprom_update_byte_notify((uint8_t*)EEPROM_TMC2130_HOME_ENABLED, 1);
_result = bres;
}
#endif //TMC2130
@ -6332,7 +6332,7 @@ static bool lcd_selfcheck_axis_sg(uint8_t axis) {
uint16_t sg1 = tmc2130_sg_measure_stop();
printf_P(PSTR("%c AXIS SG1=%d\n"), 'X'+axis, sg1);
eeprom_write_word(((uint16_t*)((axis == X_AXIS)?EEPROM_BELTSTATUS_X:EEPROM_BELTSTATUS_Y)), sg1);
eeprom_write_word_notify(((uint16_t*)((axis == X_AXIS)?EEPROM_BELTSTATUS_X:EEPROM_BELTSTATUS_Y)), sg1);
current_position_final = st_get_position_mm(axis);
measured_axis_length[0] = fabs(current_position_final - current_position_init);
@ -7096,11 +7096,11 @@ static void menu_action_sdfile(const char* filename)
for (uint_least8_t i = 0; i < 8; i++) {
if (selected_filename[i] == '\0' || selected_filename[i] == '.') {
//filename is shorter then 8.3, store '\0' character on position where ".gco" string was found to terminate stored string properly
eeprom_write_byte((uint8_t*)EEPROM_FILENAME + i, '\0');
eeprom_update_byte_notify((uint8_t*)EEPROM_FILENAME + i, '\0');
break;
}
else {
eeprom_write_byte((uint8_t*)EEPROM_FILENAME + i, selected_filename[i]);
eeprom_update_byte_notify((uint8_t*)EEPROM_FILENAME + i, selected_filename[i]);
}
}
@ -7114,17 +7114,17 @@ static void menu_action_sdfile(const char* filename)
for (uint_least8_t i = 0; i < 3; i++)
{
if (extension_ptr == NULL || extension_ptr[i] == '\0') {
eeprom_update_byte((uint8_t*)EEPROM_FILENAME_EXTENSION + i, '\0');
eeprom_update_byte_notify((uint8_t*)EEPROM_FILENAME_EXTENSION + i, '\0');
} else {
eeprom_update_byte((uint8_t*)EEPROM_FILENAME_EXTENSION + i, extension_ptr[i]);
eeprom_update_byte_notify((uint8_t*)EEPROM_FILENAME_EXTENSION + i, extension_ptr[i]);
}
}
const uint8_t depth = card.getWorkDirDepth();
eeprom_write_byte((uint8_t*)EEPROM_DIR_DEPTH, depth);
eeprom_update_byte_notify((uint8_t*)EEPROM_DIR_DEPTH, depth);
for (uint_least8_t i = 0; i < depth; i++) {
eeprom_update_block(card.dir_names[i], (uint8_t*)EEPROM_DIRS + 8 * i, 8);
eeprom_update_block_notify(card.dir_names[i], (uint8_t*)EEPROM_DIRS + 8 * i, 8);
}
if (!check_file(selected_filename)) {
@ -7436,7 +7436,7 @@ void UserECool_toggle(){
// The condition is intentionally inverted as we are toggling the state (i.e. if it was enabled, we are disabling the feature and vice versa)
bool enable = ! UserECoolEnabled();
eeprom_update_byte((uint8_t *)EEPROM_ECOOL_ENABLE, enable ? EEPROM_ECOOL_MAGIC_NUMBER : EEPROM_EMPTY_VALUE);
eeprom_update_byte_notify((uint8_t *)EEPROM_ECOOL_ENABLE, enable ? EEPROM_ECOOL_MAGIC_NUMBER : EEPROM_EMPTY_VALUE);
// @@TODO I don't like this - disabling the experimental menu shall disable ECool mode, but it will not reinit the TMC
// and I don't want to add more code for this experimental feature ... ideally do not reinit the TMC here at all and let the user reset the printer.
@ -7465,7 +7465,7 @@ bool FarmOrUserECool(){
void WorkaroundPrusaSN() {
const char *SN = PSTR("CZPXInvalidSerialNr");
for (uint8_t i = 0; i < 20; i++) {
eeprom_update_byte((uint8_t*)EEPROM_PRUSA_SN + i, pgm_read_byte(SN++));
eeprom_update_byte_notify((uint8_t*)EEPROM_PRUSA_SN + i, pgm_read_byte(SN++));
}
}
#endif //PRUSA_SN_SUPPORT
@ -7501,7 +7501,7 @@ void lcd_pinda_temp_compensation_toggle()
pinda_temp_compensation = 1; // But for MK3/S it should be 1 so SuperPINDA is "active"
else
pinda_temp_compensation = !pinda_temp_compensation;
eeprom_update_byte((uint8_t*)EEPROM_PINDA_TEMP_COMPENSATION, pinda_temp_compensation);
eeprom_update_byte_notify((uint8_t*)EEPROM_PINDA_TEMP_COMPENSATION, pinda_temp_compensation);
SERIAL_ECHOLNPGM("SuperPINDA:");
SERIAL_ECHOLN(pinda_temp_compensation);
}
@ -7514,7 +7514,7 @@ void lcd_heat_bed_on_load_toggle()
value = 1;
else
value = !value;
eeprom_update_byte((uint8_t*)EEPROM_HEAT_BED_ON_LOAD_FILAMENT, value);
eeprom_update_byte_notify((uint8_t*)EEPROM_HEAT_BED_ON_LOAD_FILAMENT, value);
}
void lcd_reprint_from_eeprom() {

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()
{
for (int8_t i = 0; i < FW_PRUSA3D_MAGIC_LEN; ++ i){
eeprom_update_byte((uint8_t*)(EEPROM_FIRMWARE_PRUSA_MAGIC+i), pgm_read_byte(FW_PRUSA3D_MAGIC_STR+i));
eeprom_update_byte_notify((uint8_t*)(EEPROM_FIRMWARE_PRUSA_MAGIC+i), pgm_read_byte(FW_PRUSA3D_MAGIC_STR+i));
}
eeprom_update_word((uint16_t*)EEPROM_FIRMWARE_VERSION_MAJOR, (uint16_t)pgm_read_word(&FW_VERSION_NR[0]));
eeprom_update_word((uint16_t*)EEPROM_FIRMWARE_VERSION_MINOR, (uint16_t)pgm_read_word(&FW_VERSION_NR[1]));
eeprom_update_word((uint16_t*)EEPROM_FIRMWARE_VERSION_REVISION, (uint16_t)pgm_read_word(&FW_VERSION_NR[2]));
eeprom_update_word_notify((uint16_t*)EEPROM_FIRMWARE_VERSION_MAJOR, (uint16_t)pgm_read_word(&FW_VERSION_NR[0]));
eeprom_update_word_notify((uint16_t*)EEPROM_FIRMWARE_VERSION_MINOR, (uint16_t)pgm_read_word(&FW_VERSION_NR[1]));
eeprom_update_word_notify((uint16_t*)EEPROM_FIRMWARE_VERSION_REVISION, (uint16_t)pgm_read_word(&FW_VERSION_NR[2]));
// See FirmwareRevisionFlavorType for the definition of firmware flavors.
eeprom_update_word((uint16_t*)EEPROM_FIRMWARE_VERSION_FLAVOR, (uint16_t)pgm_read_word(&FW_VERSION_NR[3]));
eeprom_update_word_notify((uint16_t*)EEPROM_FIRMWARE_VERSION_FLAVOR, (uint16_t)pgm_read_word(&FW_VERSION_NR[3]));
}
ClNozzleDiameter oNozzleDiameter;
@ -247,7 +247,7 @@ void fCheckModeInit() {
if (farm_mode) {
oCheckMode = ClCheckMode::_Strict;
eeprom_update_byte((uint8_t *)EEPROM_CHECK_MODE, (uint8_t)ClCheckMode::_Strict);
eeprom_update_byte_notify((uint8_t *)EEPROM_CHECK_MODE, (uint8_t)ClCheckMode::_Strict);
}
oNozzleDiameter = (ClNozzleDiameter)eeprom_init_default_byte((uint8_t *)EEPROM_NOZZLE_DIAMETER, (uint8_t)ClNozzleDiameter::_Diameter_400);
@ -438,12 +438,12 @@ void calibration_status_set(CalibrationStatus components)
{
CalibrationStatus status = eeprom_read_byte((uint8_t*)EEPROM_CALIBRATION_STATUS_V2);
status |= components;
eeprom_update_byte((uint8_t*)EEPROM_CALIBRATION_STATUS_V2, status);
eeprom_update_byte_notify((uint8_t*)EEPROM_CALIBRATION_STATUS_V2, status);
}
void calibration_status_clear(CalibrationStatus components)
{
CalibrationStatus status = eeprom_read_byte((uint8_t*)EEPROM_CALIBRATION_STATUS_V2);
status &= ~components;
eeprom_update_byte((uint8_t*)EEPROM_CALIBRATION_STATUS_V2, status);
eeprom_update_byte_notify((uint8_t*)EEPROM_CALIBRATION_STATUS_V2, status);
}

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

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

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

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

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

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

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

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

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

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

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

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

1
Firmware/variants/MK3.h
View File

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

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

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

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

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

1
Firmware/variants/MK3S.h
View File

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