⛙ Merge w/Marlin

Author: classicrocker883

Marlin/Configuration_adv.h

@@ -1803,6 +1803,8 @@
   #define POWER_LOSS_RECOVERY               // (3400 bytes of flash)
   #if ENABLED(POWER_LOSS_RECOVERY)
     #define PLR_ENABLED_DEFAULT       false // Power-Loss Recovery enabled by default. (Set with 'M413 Sn' & M500)
+    //#define PLR_HEAT_BED_ON_REBOOT        // Heat up bed immediately on reboot to mitigate object detaching/warping.
+    //#define PLR_HEAT_BED_EXTRA          0 // (°C) Relative increase of bed temperature for better adhesion (limited by max temp).
     //#define PLR_BED_THRESHOLD BED_MAXTEMP // (°C) Skip user confirmation at or above this bed temperature (0 to disable)
 
     //#define POWER_LOSS_PIN             44 // Pin to detect power-loss. Set to -1 to disable default pin on boards without module, or comment to use board default.

Marlin/Version.h

@@ -41,7 +41,7 @@
  * here we define this default string as the date where the latest release
  * version was tagged.
  */
-//#define STRING_DISTRIBUTION_DATE "2025-11-25"
+//#define STRING_DISTRIBUTION_DATE "2025-11-28"
 
 #define STRING_DISTRIBUTION_DATE __DATE__
 #define STRING_DISTRIBUTION_TIME __TIME__

Marlin/src/HAL/RP2040/HAL.cpp

@@ -32,17 +32,123 @@
 extern "C" {
   #include "pico/bootrom.h"
   #include "hardware/watchdog.h"
+  #include "pico/multicore.h"
+  #include "hardware/adc.h"
+  #include "pico/time.h"
 }
 
 #if HAS_SD_HOST_DRIVE
   #include "msc_sd.h"
-  #include "usbd_cdc_if.h"
 #endif
 
+// Core 1 watchdog configuration
+#define CORE1_MAX_RESETS 5  // Maximum number of Core 1 resets before halting system
+
 // ------------------------
 // Public Variables
 // ------------------------
 
+volatile uint32_t adc_accumulators[5] = {0}; // Accumulators for oversampling (sum of readings)
+volatile uint8_t adc_counts[5] = {0};        // Count of readings accumulated per channel
+volatile uint16_t adc_values[5] = {512, 512, 512, 512, 512}; // Final oversampled ADC values (averages) - initialized to mid-range
+
+// Core 1 watchdog monitoring
+volatile uint32_t core1_last_heartbeat = 0; // Timestamp of Core 1's last activity
+volatile bool core1_watchdog_triggered = false; // Flag to indicate Core 1 reset
+volatile uint8_t core1_reset_count = 0; // Count of Core 1 resets - halt system if >= CORE1_MAX_RESETS
+volatile uint8_t current_pin;
+volatile bool MarlinHAL::adc_has_result;
+volatile uint8_t adc_channels_enabled[5] = {false}; // Track which ADC channels are enabled
+
+// Helper function for LED blinking patterns
+void blink_led_pattern(uint8_t blink_count, uint32_t blink_duration_us = 100000) {
+  #if DISABLED(PINS_DEBUGGING) && PIN_EXISTS(LED)
+    for (uint8_t i = 0; i < blink_count; i++) {
+      WRITE(LED_PIN, HIGH);
+      busy_wait_us(blink_duration_us);
+      WRITE(LED_PIN, LOW);
+      if (i < blink_count - 1) { // Don't delay after the last blink
+        busy_wait_us(blink_duration_us);
+      }
+    }
+  #endif
+}
+
+// Core 1 ADC reading task - dynamically reads all enabled channels with oversampling
+void core1_adc_task() {
+  static uint32_t last_led_toggle = 0;
+  const uint8_t OVERSAMPLENR = 16; // Standard Marlin oversampling count
+
+  // Signal successful Core 1 startup/restart
+  SERIAL_ECHO_MSG("Core 1 ADC task started");
+
+  while (true) {
+    // Update heartbeat timestamp at start of each scan cycle
+    core1_last_heartbeat = time_us_32();
+
+    // Scan all enabled ADC channels
+    for (uint8_t channel = 0; channel < 5; channel++) {
+      if (!adc_channels_enabled[channel]) continue;
+
+      // Enable temperature sensor if reading channel 4
+      if (channel == 4) {
+        adc_set_temp_sensor_enabled(true);
+      }
+
+      // Select and read the channel
+      adc_select_input(channel);
+      busy_wait_us(100); // Settling delay
+      adc_fifo_drain();
+      adc_run(true);
+
+      // Wait for conversion with timeout
+      uint32_t timeout = 10000;
+      while (adc_fifo_is_empty() && timeout--) {
+        busy_wait_us(1);
+      }
+
+      adc_run(false);
+      uint16_t reading = adc_fifo_is_empty() ? 0 : adc_fifo_get();
+
+      // Accumulate readings for oversampling
+      adc_accumulators[channel] += reading;
+      adc_counts[channel]++;
+
+      // Update the averaged value with current accumulation (provides immediate valid data)
+      adc_values[channel] = adc_accumulators[channel] / adc_counts[channel];
+
+      // When we reach the full oversampling count, reset accumulator for next cycle
+      if (adc_counts[channel] >= OVERSAMPLENR) {
+        adc_accumulators[channel] = 0;
+        adc_counts[channel] = 0;
+      }
+
+      // Disable temp sensor after reading to save power
+      if (channel == 4) {
+        adc_set_temp_sensor_enabled(false);
+      }
+    }
+
+    // Core 1 LED indicator: Double blink every 2 seconds to show Core 1 is active
+    uint32_t now = time_us_32();
+    if (now - last_led_toggle >= 2000000) { // 2 seconds
+      last_led_toggle = now;
+      #if DISABLED(PINS_DEBUGGING) && PIN_EXISTS(LED)
+        // Triple blink pattern if watchdog was triggered (shows Core 1 was reset)
+        if (core1_watchdog_triggered) {
+          core1_watchdog_triggered = false; // Clear flag
+          blink_led_pattern(3); // Triple blink for watchdog reset
+        } else {
+          blink_led_pattern(2); // Normal double blink
+        }
+      #endif
+    }
+
+    // Delay between full scan cycles
+    busy_wait_us(10000); // 10ms between scans
+  }
+}
+
 volatile uint16_t adc_result;
 
 // ------------------------
@@ -118,9 +224,28 @@ void MarlinHAL::reboot() { watchdog_reboot(0, 0, 1); }
   }
 
   void MarlinHAL::watchdog_refresh() {
+    // If Core 1 has reset CORE1_MAX_RESETS+ times, stop updating watchdog to halt system
+    if (core1_reset_count >= CORE1_MAX_RESETS) {
+      SERIAL_ECHO_MSG("Core 1 reset limit exceeded (", core1_reset_count, " resets) - halting system for safety");
+      return; // Don't update watchdog - system will halt
+    }
+
     watchdog_update();
+
+    // Check Core 1 watchdog (15 second timeout)
+    uint32_t now = time_us_32();
+    if (now - core1_last_heartbeat > 15000000) { // 15 seconds
+      // Core 1 appears stuck - reset it
+      multicore_reset_core1();
+      multicore_launch_core1(core1_adc_task);
+      core1_watchdog_triggered = true; // Signal for LED indicator
+      core1_reset_count++; // Increment reset counter
+      SERIAL_ECHO_MSG("Core 1 ADC watchdog triggered - resetting Core 1 (attempt ", core1_reset_count, ")");
+    }
+
     #if DISABLED(PINS_DEBUGGING) && PIN_EXISTS(LED)
-      TOGGLE(LED_PIN);  // heartbeat indicator
+      // Core 0 LED indicator: Single toggle every watchdog refresh (shows Core 0 activity)
+      TOGGLE(LED_PIN);
     #endif
   }
 
@@ -130,44 +255,36 @@ void MarlinHAL::reboot() { watchdog_reboot(0, 0, 1); }
 // ADC
 // ------------------------
 
-volatile bool MarlinHAL::adc_has_result = false;
-
 void MarlinHAL::adc_init() {
   analogReadResolution(HAL_ADC_RESOLUTION);
   ::adc_init();
   adc_fifo_setup(true, false, 1, false, false);
-  irq_set_exclusive_handler(ADC_IRQ_FIFO, adc_exclusive_handler);
-  irq_set_enabled(ADC_IRQ_FIFO, true);
-  adc_irq_set_enabled(true);
+  // Launch Core 1 for continuous ADC reading
+  multicore_launch_core1(core1_adc_task);
+  adc_has_result = true; // Results are always available with continuous sampling
 }
 
 void MarlinHAL::adc_enable(const pin_t pin) {
-  if (pin >= A0 && pin <= A3)
+  if (pin >= A0 && pin <= A3) {
     adc_gpio_init(pin);
-  else if (pin == HAL_ADC_MCU_TEMP_DUMMY_PIN)
-    adc_set_temp_sensor_enabled(true);
+    adc_channels_enabled[pin - A0] = true; // Mark this channel as enabled
+  }
+  else if (pin == HAL_ADC_MCU_TEMP_DUMMY_PIN) {
+    adc_channels_enabled[4] = true; // Mark MCU temp channel as enabled
+  }
 }
 
 void MarlinHAL::adc_start(const pin_t pin) {
-  adc_has_result = false;
-  // Select an ADC input. 0...3 are GPIOs 26...29 respectively.
-  adc_select_input(pin == HAL_ADC_MCU_TEMP_DUMMY_PIN ? 4 : pin - A0);
-  adc_run(true);
+  // Just store which pin we need to read - values are continuously updated by Core 1
+  current_pin = pin;
 }
 
-void MarlinHAL::adc_exclusive_handler() {
-  adc_run(false); // Disable since we only want one result
-  irq_clear(ADC_IRQ_FIFO); // Clear the IRQ
-
-  if (adc_fifo_get_level() >= 1) {
-    adc_result = adc_fifo_get(); // Pop the result
-    adc_fifo_drain();
-    adc_has_result = true; // Signal the end of the conversion
-  }
+uint16_t MarlinHAL::adc_value() {
+  // Return the latest ADC value from Core 1's continuous readings
+  const uint8_t channel = (current_pin == HAL_ADC_MCU_TEMP_DUMMY_PIN) ? 4 : (current_pin - A0);
+  return adc_values[channel];
 }
 
-uint16_t MarlinHAL::adc_value() { return adc_result; }
-
 // Reset the system to initiate a firmware flash
 void flashFirmware(const int16_t) { hal.reboot(); }
 

Marlin/src/HAL/RP2040/HAL.h

@@ -40,6 +40,11 @@
   #include "msc_sd.h"
 #endif
 
+// ADC index 4 is the MCU temperature
+#define HAL_ADC_MCU_TEMP_DUMMY_PIN 127
+#define TEMP_SOC_PIN HAL_ADC_MCU_TEMP_DUMMY_PIN   // ADC4 is internal temp sensor
+#include "temp_soc.h"
+
 //
 // Serial Ports
 //
@@ -85,8 +90,6 @@ typedef libServo hal_servo_t;
 #else
   #define HAL_ADC_RESOLUTION 12
 #endif
-// ADC index 4 is the MCU temperature
-#define HAL_ADC_MCU_TEMP_DUMMY_PIN 127
 
 //
 // Pin Mapping for M42, M43, M226
@@ -164,9 +167,6 @@ class MarlinHAL {
   // Begin ADC sampling on the given pin. Called from Temperature::isr!
   static void adc_start(const pin_t pin);
 
-  // This ADC runs a periodic task
-  static void adc_exclusive_handler();
-
   // Is the ADC ready for reading?
   static volatile bool adc_has_result;
   static bool adc_ready() { return adc_has_result; }

Marlin/src/HAL/RP2040/eeprom/eeprom_flash.cpp

@@ -31,28 +31,48 @@
 
 // NOTE: The Bigtreetech SKR Pico has an onboard W25Q16 flash module
 
-// Use EEPROM.h for compatibility, for now.
-#include <EEPROM.h>
+// RP2040 Flash-based EEPROM emulation using internal flash memory
+#include <hardware/flash.h>
+#include <hardware/sync.h>
 
-static bool eeprom_data_written = false;
+// Flash sector size is already defined in hardware/flash.h as FLASH_SECTOR_SIZE
+// Place EEPROM emulation at the end of flash, before the filesystem
+// This assumes 2MB flash, adjust if using different flash size
+#define FLASH_TARGET_OFFSET (PICO_FLASH_SIZE_BYTES - FLASH_SECTOR_SIZE)
 
 #ifndef MARLIN_EEPROM_SIZE
   #define MARLIN_EEPROM_SIZE size_t(E2END + 1)
 #endif
+
+static uint8_t eeprom_buffer[MARLIN_EEPROM_SIZE];
+static bool eeprom_data_written = false;
+static bool eeprom_initialized = false;
 size_t PersistentStore::capacity() { return MARLIN_EEPROM_SIZE; }
 
 bool PersistentStore::access_start() {
-  EEPROM.begin(); // Avoid EEPROM.h warning (do nothing)
-  eeprom_buffer_fill();
+  if (!eeprom_initialized) {
+    // Read from flash into buffer
+    const uint8_t *flash_data = (const uint8_t *)(XIP_BASE + FLASH_TARGET_OFFSET);
+    memcpy(eeprom_buffer, flash_data, MARLIN_EEPROM_SIZE);
+    eeprom_initialized = true;
+  }
   return true;
 }
 
 bool PersistentStore::access_finish() {
   if (eeprom_data_written) {
     TERN_(HAS_PAUSE_SERVO_OUTPUT, PAUSE_SERVO_OUTPUT());
-    hal.isr_off();
-    eeprom_buffer_flush();
-    hal.isr_on();
+
+    // Disable interrupts during flash write
+    const uint32_t intstate = save_and_disable_interrupts();
+
+    // Erase and program the sector
+    flash_range_erase(FLASH_TARGET_OFFSET, FLASH_SECTOR_SIZE);
+    flash_range_program(FLASH_TARGET_OFFSET, eeprom_buffer, MARLIN_EEPROM_SIZE);
+
+    // Restore interrupts
+    restore_interrupts(intstate);
+
     TERN_(HAS_PAUSE_SERVO_OUTPUT, RESUME_SERVO_OUTPUT());
     eeprom_data_written = false;
   }
@@ -62,8 +82,8 @@ bool PersistentStore::access_finish() {
 bool PersistentStore::write_data(int &pos, const uint8_t *value, size_t size, uint16_t *crc) {
   while (size--) {
     uint8_t v = *value;
-    if (v != eeprom_buffered_read_byte(pos)) {
-      eeprom_buffered_write_byte(pos, v);
+    if (pos < (int)MARLIN_EEPROM_SIZE && v != eeprom_buffer[pos]) {
+      eeprom_buffer[pos] = v;
       eeprom_data_written = true;
     }
     crc16(crc, &v, 1);
@@ -75,7 +95,7 @@ bool PersistentStore::write_data(int &pos, const uint8_t *value, size_t size, ui
 
 bool PersistentStore::read_data(int &pos, uint8_t *value, size_t size, uint16_t *crc, const bool writing/*=true*/) {
   do {
-    const uint8_t c = eeprom_buffered_read_byte(pos);
+    const uint8_t c = (pos < (int)MARLIN_EEPROM_SIZE) ? eeprom_buffer[pos] : 0xFF;
     if (writing) *value = c;
     crc16(crc, &c, 1);
     pos++;