3D-printing/Marlin
1
0
Fork 0
mirror of https://github.com/MarlinFirmware/Marlin.git synced 2026-01-17 13:25:37 -07:00
Code Issues Projects Releases Packages Wiki Activity Actions 7

Merge branch 'bugfix-2.1.x' into bugfix-2.1.x-April5

Browse source
This commit is contained in:
Andrew 2025-06-05 06:50:56 -04:00 • committed by GitHub
commit 77858029f0
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
183 changed files with 3895 additions and 2408 deletions
Download patch file Download diff file Expand all files Collapse all files

10
.github/workflows/ci-build-tests.yml vendored
View file

@ -36,6 +36,9 @@ jobs:
runs-on: ubuntu-22.04
env:
CONFIG_BRANCH: ${{ github.base_ref || github.ref_name }}
strategy:
fail-fast: true
matrix:
@ -205,6 +208,13 @@ jobs:
sudo apt-get install libsdl2-net-dev
sudo apt-get install libglm-dev
- name: Checkout Configurations
uses: actions/checkout@v4
with:
repository: MarlinFirmware/Configurations
ref: ${{ env.CONFIG_BRANCH }}
path: ConfigurationsRepo
- name: Run ${{ matrix.test-platform }} Tests
run: |
make tests-single-ci TEST_TARGET=${{ matrix.test-platform }}

7
Marlin/Configuration.h
View file

@ -148,9 +148,9 @@
* Options: A4988, A5984, DRV8825, LV8729, TB6560, TB6600, TMC2100,
* TMC2130, TMC2130_STANDALONE, TMC2160, TMC2160_STANDALONE,
* TMC2208, TMC2208_STANDALONE, TMC2209, TMC2209_STANDALONE,
* TMC2660, TMC2660_STANDALONE, TMC5130, TMC5130_STANDALONE,
* TMC5160, TMC5160_STANDALONE
* :['A4988', 'A5984', 'DRV8825', 'LV8729', 'TB6560', 'TB6600', 'TMC2100', 'TMC2130', 'TMC2130_STANDALONE', 'TMC2160', 'TMC2160_STANDALONE', 'TMC2208', 'TMC2208_STANDALONE', 'TMC2209', 'TMC2209_STANDALONE', 'TMC2660', 'TMC2660_STANDALONE', 'TMC5130', 'TMC5130_STANDALONE', 'TMC5160', 'TMC5160_STANDALONE']
* TMC2240, TMC2240_STANDALONE, TMC2660, TMC2660_STANDALONE,
* TMC5130, TMC5130_STANDALONE, TMC5160, TMC5160_STANDALONE
* :['A4988', 'A5984', 'DRV8825', 'LV8729', 'TB6560', 'TB6600', 'TMC2100', 'TMC2130', 'TMC2130_STANDALONE', 'TMC2160', 'TMC2160_STANDALONE', 'TMC2208', 'TMC2208_STANDALONE', 'TMC2209', 'TMC2209_STANDALONE', 'TMC2240', 'TMC2240_STANDALONE', 'TMC2660', 'TMC2660_STANDALONE', 'TMC5130', 'TMC5130_STANDALONE', 'TMC5160', 'TMC5160_STANDALONE']
*/
#define X_DRIVER_TYPE A4988
#define Y_DRIVER_TYPE A4988
@ -767,6 +767,7 @@
#define MPC_TUNING_POS { X_CENTER, Y_CENTER, 1.0f } // (mm) M306 Autotuning position, ideally bed center at first layer height.
#define MPC_TUNING_END_Z 10.0f // (mm) M306 Autotuning final Z position.
//#define EVENT_GCODE_AFTER_MPC_TUNE "M84" // G-code to execute after MPC tune finished and Z raised.
#endif
//===========================================================================

50
Marlin/Configuration_adv.h
View file

@ -1673,11 +1673,12 @@
#endif // HAS_DISPLAY
#if HAS_FEEDRATE_EDIT
// Some displays offer Feedrate / Flow editing.
#if ANY(HAS_MARLINUI_MENU, DWIN_CREALITY_LCD, DWIN_LCD_PROUI, MALYAN_LCD, TOUCH_SCREEN, ULTIPANEL_FEEDMULTIPLY)
#define SPEED_EDIT_MIN 10 // (%) Feedrate percentage edit range minimum
#define SPEED_EDIT_MAX 999 // (%) Feedrate percentage edit range maximum
#endif
#if HAS_FLOW_EDIT
#if ANY(HAS_MARLINUI_MENU, DWIN_CREALITY_LCD, DWIN_LCD_PROUI, MALYAN_LCD, TOUCH_SCREEN)
#define FLOW_EDIT_MIN 10 // (%) Flow percentage edit range minimum
#define FLOW_EDIT_MAX 999 // (%) Flow percentage edit range maximum
#endif
@ -1938,6 +1939,9 @@
//#define CUSTOM_FIRMWARE_UPLOAD
#endif
// "Over-the-air" Firmware Update with M936 - Required to set EEPROM flag
//#define OTA_FIRMWARE_UPDATE
/**
* Set this option to one of the following (or the board's defaults apply):
*
@ -2363,11 +2367,11 @@
* Higher k and higher XY acceleration may require larger ADVANCE_TAU to avoid skipping steps.
*/
#if ENABLED(DISTINCT_E_FACTORS)
#define ADVANCE_TAU { 0.01 } // (s) Smoothing time to reduce extruder acceleration, per extruder
#define ADVANCE_TAU { 0.02 } // (s) Smoothing time to reduce extruder acceleration, per extruder
#else
#define ADVANCE_TAU 0.01 // (s) Smoothing time to reduce extruder acceleration
#define ADVANCE_TAU 0.02 // (s) Smoothing time to reduce extruder acceleration
#endif
#define SMOOTH_LIN_ADV_HZ 5000 // (Hz) How often to update extruder speed
#define SMOOTH_LIN_ADV_HZ 1000 // (Hz) How often to update extruder speed
#define INPUT_SHAPING_E_SYNC // Synchronize the extruder-shaped XY axes (to increase precision)
#endif
#endif
@ -2380,6 +2384,9 @@
* For better results also enable ADAPTIVE_STEP_SMOOTHING.
*/
//#define NONLINEAR_EXTRUSION
#if ENABLED(NONLINEAR_EXTRUSION)
//#define NONLINEAR_EXTRUSION_DEFAULT_ON // Enable if NLE should be ON by default
#endif
// @section leveling
@ -2993,7 +3000,7 @@
/**
* Trinamic Smart Drivers
*
* To use TMC2130, TMC2160, TMC2660, TMC5130, TMC5160 stepper drivers in SPI mode:
* To use TMC2130, TMC2160, TMC2240, TMC2660, TMC5130, TMC5160 stepper drivers in SPI mode:
* - Connect your SPI pins to the Hardware SPI interface on the board.
* Some boards have simple jumper connections! See your board's documentation.
* - Define the required Stepper CS pins in your `pins_MYBOARD.h` file.
@ -3023,6 +3030,15 @@
*/
#define INTERPOLATE true
#if HAS_DRIVER(TMC2240)
#define TMC2240_CURRENT_RANGE 1 // RMS: { 0:'690mA', 1:'1410mA', 2:'2120mA', 3:'2110mA' }
// PEAK:{ 0:'1A', 1:'2A', 2:'3A', 3:'3A' }
// Determines max current. Lower is more internal current resolution. Higher runs cooler.
#define TMC2240_Rref 12000 // ('rref', 12000, minval=12000, maxval=60000)
#define TMC2240_SLOPE_CONTROL 0 // :{ 0:'100V/us', 1:'200V/us', 2:'400V/us', 3:'800V/us' }
// Lower is more silent. Higher runs cooler.
#endif
#if AXIS_IS_TMC_CONFIG(X)
#define X_CURRENT 800 // (mA) RMS current. Multiply by 1.414 for peak current.
#define X_CURRENT_HOME X_CURRENT // (mA) RMS current for homing. (Typically lower than *_CURRENT.)
@ -3245,7 +3261,7 @@
// @section tmc/spi
/**
* Override default SPI pins for TMC2130, TMC2160, TMC2660, TMC5130 and TMC5160 drivers here.
* Override default SPI pins for TMC2130, TMC2160, TMC2240, TMC2660, TMC5130 and TMC5160 drivers here.
* The default pins can be found in your board's pins file.
*/
//#define X_CS_PIN -1
@ -3272,7 +3288,7 @@
//#define E7_CS_PIN -1
/**
* Software option for SPI driven drivers (TMC2130, TMC2160, TMC2660, TMC5130 and TMC5160).
* Software option for SPI driven drivers (TMC2130, TMC2160, TMC2240, TMC2660, TMC5130 and TMC5160).
* The default SW SPI pins are defined the respective pins files,
* but you can override or define them here.
*/
@ -3331,7 +3347,7 @@
// @section tmc/stealthchop
/**
* TMC2130, TMC2160, TMC2208, TMC2209, TMC5130 and TMC5160 only
* TMC2130, TMC2160, TMC2208, TMC2209, TMC2240, TMC5130 and TMC5160 only
* Use Trinamic's ultra quiet stepping mode.
* When disabled, Marlin will use spreadCycle stepping mode.
*/
@ -3410,7 +3426,7 @@
// @section tmc/hybrid
/**
* TMC2130, TMC2160, TMC2208, TMC2209, TMC5130 and TMC5160 only
* TMC2130, TMC2160, TMC2208, TMC2209, TMC2240, TMC5130 and TMC5160 only
* The driver will switch to spreadCycle when stepper speed is over HYBRID_THRESHOLD.
* This mode allows for faster movements at the expense of higher noise levels.
* STEALTHCHOP_(XY|Z|E) must be enabled to use HYBRID_THRESHOLD.
@ -3444,20 +3460,20 @@
/**
* Use StallGuard to home / probe X, Y, Z.
*
* TMC2130, TMC2160, TMC2209, TMC2660, TMC5130, and TMC5160 only
* TMC2130, TMC2160, TMC2209, TMC2240, TMC2660, TMC5130, and TMC5160 only
* Connect the stepper driver's DIAG1 pin to the X/Y endstop pin.
* X, Y, and Z homing will always be done in spreadCycle mode.
*
* X/Y/Z_STALL_SENSITIVITY is the default stall threshold.
* Use M914 X Y Z to set the stall threshold at runtime:
*
* Sensitivity TMC2209 Others
* HIGHEST 255 -64 (Too sensitive => False positive)
* LOWEST 0 63 (Too insensitive => No trigger)
* Sensitivity TMC2209/2240 Others
* HIGHEST 255 -64 (Too sensitive => False positive)
* LOWEST 0 63 (Too insensitive => No trigger)
*
* It is recommended to set HOMING_BUMP_MM to { 0, 0, 0 }.
*
* SPI_ENDSTOPS *** TMC2130/TMC5160 Only ***
* SPI_ENDSTOPS *** TMC2130, TMC2240, and TMC5160 Only ***
* Poll the driver through SPI to determine load when homing.
* Removes the need for a wire from DIAG1 to an endstop pin.
*
@ -3470,7 +3486,7 @@
//#define SENSORLESS_HOMING // StallGuard capable drivers only
#if ANY(SENSORLESS_HOMING, SENSORLESS_PROBING)
// TMC2209: 0...255. TMC2130: -64...63
// TMC2209/2240: 0...255. TMC2130: -64...63
#define X_STALL_SENSITIVITY 8
#define X2_STALL_SENSITIVITY X_STALL_SENSITIVITY
#define Y_STALL_SENSITIVITY 8
@ -3485,7 +3501,7 @@
//#define U_STALL_SENSITIVITY 8
//#define V_STALL_SENSITIVITY 8
//#define W_STALL_SENSITIVITY 8
//#define SPI_ENDSTOPS // TMC2130/TMC5160 only
//#define SPI_ENDSTOPS // TMC2130, TMC2240, and TMC5160
//#define IMPROVE_HOMING_RELIABILITY
#endif

8
Marlin/Makefile
View file

@ -798,10 +798,10 @@ endif
ifeq ($(TMC), 1)
LIB_CXXSRC += TMCStepper.cpp COOLCONF.cpp DRV_STATUS.cpp IHOLD_IRUN.cpp \
CHOPCONF.cpp GCONF.cpp PWMCONF.cpp DRV_CONF.cpp DRVCONF.cpp DRVCTRL.cpp \
DRVSTATUS.cpp ENCMODE.cpp RAMP_STAT.cpp SGCSCONF.cpp SHORT_CONF.cpp \
SMARTEN.cpp SW_MODE.cpp SW_SPI.cpp TMC2130Stepper.cpp TMC2208Stepper.cpp \
TMC2209Stepper.cpp TMC2660Stepper.cpp TMC5130Stepper.cpp TMC5160Stepper.cpp
CHOPCONF.cpp GCONF.cpp PWMCONF.cpp DRV_CONF.cpp DRVCONF.cpp DRVCTRL.cpp DRVSTATUS.cpp \
GLOBAL_SCALER.cpp SLAVECONF.cpp IOIN.cpp ENCMODE.cpp RAMP_STAT.cpp SGCSCONF.cpp \
SHORT_CONF.cpp SMARTEN.cpp SW_MODE.cpp SW_SPI.cpp TMC2130Stepper.cpp TMC2208Stepper.cpp \
TMC2209Stepper.cpp TMC2240Stepper.cpp TMC2660Stepper.cpp TMC5130Stepper.cpp TMC5160Stepper.cpp
endif
ifeq ($(RELOC_WORKAROUND), 1)

2
Marlin/Version.h
View file

@ -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-05-04"
//#define STRING_DISTRIBUTION_DATE "2025-06-05"
/**
* The protocol for communication to the host. Protocol indicates communication

2
Marlin/src/HAL/GD32_MFL/HAL.h
View file

@ -105,7 +105,7 @@ extern "C" char* dtostrf(double val, signed char width, unsigned char prec, char
class MarlinHAL {
public:
// Before setup()
MarlinHAL() {}
MarlinHAL() = default;
// Watchdog
static void watchdog_init() IF_DISABLED(USE_WATCHDOG, {});

6
Marlin/src/HAL/GD32_MFL/MarlinSerial.cpp
View file

@ -33,8 +33,8 @@
using namespace arduino;
MarlinSerial& MarlinSerial::get_instance(usart::USART_Base Base, pin_size_t rxPin, pin_size_t txPin) {
UsartSerial& serial = UsartSerial::get_instance(Base, rxPin, txPin);
auto MarlinSerial::get_instance(usart::USART_Base Base, pin_size_t rxPin, pin_size_t txPin) -> MarlinSerial& {
auto& serial = UsartSerial::get_instance(Base, rxPin, txPin);
return *reinterpret_cast<MarlinSerial*>(&serial);
}
@ -61,7 +61,7 @@ MarlinSerial& MarlinSerial::get_instance(usart::USART_Base Base, pin_size_t rxPi
static void emergency_callback() {
if (!current_serial_instance) return;
const uint8_t last_data = current_serial_instance->get_last_data();
const auto last_data = current_serial_instance->get_last_data();
emergency_parser.update(current_serial_instance->emergency_state, last_data);
}

4
Marlin/src/HAL/GD32_MFL/MarlinSerial.h
View file

@ -43,7 +43,7 @@
using namespace arduino;
struct MarlinSerial : public UsartSerial {
static MarlinSerial& get_instance(usart::USART_Base Base, pin_size_t rxPin = NO_PIN, pin_size_t txPin = NO_PIN);
static auto get_instance(usart::USART_Base Base, pin_size_t rxPin = NO_PIN, pin_size_t txPin = NO_PIN) -> MarlinSerial&;
void begin(unsigned long baudrate, uint16_t config);
inline void begin(unsigned long baudrate) { begin(baudrate, SERIAL_8N1); }
@ -57,7 +57,7 @@ struct MarlinSerial : public UsartSerial {
EmergencyParser::State emergency_state;
// Accessor method to get the last received byte
uint8_t get_last_data() { return usart_.get_last_data(); }
auto get_last_data() -> uint8_t { return usart_.get_last_data(); }
// Register the emergency callback
void register_emergency_callback(void (*callback)());

2
Marlin/src/HAL/GD32_MFL/eeprom/eeprom_bl24cxx.cpp
View file

@ -62,7 +62,7 @@ bool PersistentStore::write_data(int &pos, const uint8_t *value, size_t size, ui
// so only write bytes that have changed!
if (v != eeprom_read_byte(p)) {
eeprom_write_byte(p, v);
if (++written & 0x7F) delay(4); else safe_delay(4);
if (++written & 0x7F) delay(2); else safe_delay(2);
if (eeprom_read_byte(p) != v) {
SERIAL_ECHO_MSG(STR_ERR_EEPROM_WRITE);
return true;

2
Marlin/src/HAL/GD32_MFL/eeprom/eeprom_if_iic.cpp
View file

@ -42,7 +42,7 @@ void eeprom_init() {
void eeprom_write_byte(uint8_t *pos, uint8_t value) {
const unsigned eeprom_address = (unsigned)pos;
return BL24CXX::writeOneByte(eeprom_address, value);
BL24CXX::writeOneByte(eeprom_address, value);
}
uint8_t eeprom_read_byte(uint8_t *pos) {

21
Marlin/src/HAL/GD32_MFL/fastio.h
View file

@ -21,26 +21,27 @@
*/
#pragma once
// Fast I/O interfaces for GD32F303RE
// Fast I/O interfaces for GD32
#include <GPIO.hpp>
#include <variant.h>
#include <PinOps.hpp>
#include <PinOpsMap.hpp>
template<typename T>
static inline void fast_write_pin_wrapper(pin_size_t IO, T V) {
auto port = getPortFromPin(IO);
auto pin = getPinInPort(IO);
if (static_cast<bool>(V)) gpio::fast_set_pin(port, pin);
else gpio::fast_clear_pin(port, pin);
FORCE_INLINE static void fast_write_pin_wrapper(pin_size_t IO, T V) {
const PortPinPair& pp = port_pin_map[IO];
gpio::fast_write_pin(pp.port, pp.pin, static_cast<bool>(V));
}
static inline bool fast_read_pin_wrapper(pin_size_t IO) {
return gpio::fast_read_pin(getPortFromPin(IO), getPinInPort(IO));
FORCE_INLINE static auto fast_read_pin_wrapper(pin_size_t IO) -> bool {
const PortPinPair& pp = port_pin_map[IO];
return gpio::fast_read_pin(pp.port, pp.pin);
}
static inline void fast_toggle_pin_wrapper(pin_size_t IO) {
gpio::fast_toggle_pin(getPortFromPin(IO), getPinInPort(IO));
FORCE_INLINE static void fast_toggle_pin_wrapper(pin_size_t IO) {
const PortPinPair& pp = port_pin_map[IO];
gpio::fast_toggle_pin(pp.port, pp.pin);
}
// ------------------------

10
Marlin/src/HAL/GD32_MFL/pinsDebug.h
View file

@ -70,8 +70,9 @@ bool isAnalogPin(const pin_t pin) {
if (!isValidPin(pin)) return false;
if (getAdcChannel(pin) != adc::ADC_Channel::INVALID) {
auto& instance = gpio::GPIO::get_instance(getPortFromPin(pin)).value();
return instance.get_pin_mode(getPinInPort(pin)) == gpio::Pin_Mode::ANALOG && !M43_NEVER_TOUCH(pin);
const PortPinPair& pp = port_pin_map[pin];
auto& instance = gpio::GPIO::get_instance(pp.port).value();
return instance.get_pin_mode(pp.pin) == gpio::Pin_Mode::ANALOG && !M43_NEVER_TOUCH(pin);
}
return false;
@ -80,8 +81,9 @@ bool isAnalogPin(const pin_t pin) {
bool getValidPinMode(const pin_t pin) {
if (!isValidPin(pin)) return false;
auto& instance = gpio::GPIO::get_instance(getPortFromPin(pin)).value();
gpio::Pin_Mode mode = instance.get_pin_mode(getPinInPort(pin));
const PortPinPair& pp = port_pin_map[pin];
auto& instance = gpio::GPIO::get_instance(pp.port).value();
gpio::Pin_Mode mode = instance.get_pin_mode(pp.pin);
return mode != gpio::Pin_Mode::ANALOG && mode != gpio::Pin_Mode::INPUT_FLOATING &&
mode != gpio::Pin_Mode::INPUT_PULLUP && mode != gpio::Pin_Mode::INPUT_PULLDOWN;

246
Marlin/src/HAL/GD32_MFL/sd/SDCard.cpp
View file

@ -28,7 +28,7 @@
namespace sdio {
CardDMA& CardDMA::get_instance() {
auto CardDMA::get_instance() -> CardDMA& {
static CardDMA instance;
return instance;
}
@ -38,9 +38,7 @@ CardDMA::CardDMA() :
sdcard_cid_{0U, 0U, 0U, 0U},
sdcard_scr_{0U, 0U},
desired_clock_(Default_Desired_Clock),
stop_condition_(0U),
total_bytes_(0U),
count_(0U),
sdio_(SDIO::get_instance()),
config_(sdio_.get_config()),
dmaBase_(dma::DMA_Base::DMA1_BASE),
@ -50,15 +48,15 @@ CardDMA::CardDMA() :
transfer_error_(SDIO_Error_Type::OK),
interface_version_(Interface_Version::UNKNOWN),
card_type_(Card_Type::UNKNOWN),
current_state_(Operational_State::READY),
transfer_end_(false),
is_rx_(false),
multiblock_(false),
current_state_(Operational_State::READY)
is_rx_(false)
{
}
// Initialize card and put in standby state
SDIO_Error_Type CardDMA::init() {
auto CardDMA::init() -> SDIO_Error_Type {
// Reset SDIO peripheral
sdio_.reset();
sync_domains();
@ -79,7 +77,7 @@ SDIO_Error_Type CardDMA::init() {
}
// Startup command procedure according to SDIO specification
SDIO_Error_Type CardDMA::begin_startup_procedure() {
auto CardDMA::begin_startup_procedure() -> SDIO_Error_Type {
sdio_.set_power_mode(Power_Control::POWER_ON);
sdio_.set_clock_enable(true);
sync_domains();
@ -124,12 +122,12 @@ SDIO_Error_Type CardDMA::begin_startup_procedure() {
}
// Voltage validation
SDIO_Error_Type CardDMA::validate_voltage() {
auto CardDMA::validate_voltage() -> SDIO_Error_Type {
uint32_t response = 0U;
uint32_t count = 0U;
bool valid_voltage = false;
while ((count < Max_Voltage_Checks) && (valid_voltage == false)) {
while (count < Max_Voltage_Checks && valid_voltage == false) {
if (send_command_and_check(Command_Index::CMD55, 0, Command_Response::RSP_SHORT,
Wait_Type::WT_NONE, [this, cmd = Command_Index::CMD55]() {
return get_r1_result(cmd);
@ -144,7 +142,7 @@ SDIO_Error_Type CardDMA::validate_voltage() {
return SDIO_Error_Type::ACMD41_FAILED;
}
response = sdio_.get_response(Response_Type::RESPONSE0);
valid_voltage = (((response >> 31U) == 1U) ? true : false);
valid_voltage = ((response >> 31U) == 1U);
count++;
}
@ -171,7 +169,7 @@ void CardDMA::begin_shutdown_procedure() {
}
// Initialize card
SDIO_Error_Type CardDMA::card_init() {
auto CardDMA::card_init() -> SDIO_Error_Type {
if (sdio_.get_power_mode() == static_cast<uint32_t>(Power_Control::POWER_OFF)) {
return SDIO_Error_Type::INVALID_OPERATION;
}
@ -221,7 +219,7 @@ SDIO_Error_Type CardDMA::card_init() {
return SDIO_Error_Type::OK;
}
SDIO_Error_Type CardDMA::store_cid() {
auto CardDMA::store_cid() -> SDIO_Error_Type {
// Store the CID register values
sdcard_cid_[0] = sdio_.get_response(Response_Type::RESPONSE0);
sdcard_cid_[1] = sdio_.get_response(Response_Type::RESPONSE1);
@ -231,7 +229,7 @@ SDIO_Error_Type CardDMA::store_cid() {
return SDIO_Error_Type::OK;
}
SDIO_Error_Type CardDMA::store_csd() {
auto CardDMA::store_csd() -> SDIO_Error_Type {
// Store the CSD register values
sdcard_csd_[0] = sdio_.get_response(Response_Type::RESPONSE0);
sdcard_csd_[1] = sdio_.get_response(Response_Type::RESPONSE1);
@ -241,7 +239,7 @@ SDIO_Error_Type CardDMA::store_csd() {
return SDIO_Error_Type::OK;
}
SDIO_Error_Type CardDMA::set_hardware_bus_width(Bus_Width width) {
auto CardDMA::set_hardware_bus_width(Bus_Width width) -> SDIO_Error_Type {
if (card_type_ == Card_Type::SD_MMC || width == Bus_Width::WIDTH_8BIT) {
return SDIO_Error_Type::UNSUPPORTED_FUNCTION;
}
@ -283,7 +281,7 @@ SDIO_Error_Type CardDMA::set_hardware_bus_width(Bus_Width width) {
return SDIO_Error_Type::UNSUPPORTED_FUNCTION;
}
SDIO_Error_Type CardDMA::read(uint8_t* buf, uint32_t address, uint32_t count) {
auto CardDMA::read(uint8_t* buf, uint32_t address, uint32_t count) -> SDIO_Error_Type {
if (current_state_ == Operational_State::READY) {
transfer_error_ = SDIO_Error_Type::OK;
current_state_ = Operational_State::BUSY;
@ -340,7 +338,7 @@ SDIO_Error_Type CardDMA::read(uint8_t* buf, uint32_t address, uint32_t count) {
}
}
SDIO_Error_Type CardDMA::write(uint8_t* buf, uint32_t address, uint32_t count) {
auto CardDMA::write(uint8_t* buf, uint32_t address, uint32_t count) -> SDIO_Error_Type {
// Enable the interrupts
sdio_.set_interrupt_enable(Interrupt_Type::DTCRCERRIE, true);
sdio_.set_interrupt_enable(Interrupt_Type::DTTMOUTIE, true);
@ -363,7 +361,7 @@ SDIO_Error_Type CardDMA::write(uint8_t* buf, uint32_t address, uint32_t count) {
// CMD25/CMD24 (WRITE_MULTIPLE_BLOCK/WRITE_BLOCK) send write command
Command_Index write_cmd = (count > 1U) ? Command_Index::CMD25 : Command_Index::CMD24;
if (send_command_and_check(write_cmd, address, Command_Response::RSP_SHORT,
Wait_Type::WT_NONE, [this, cmd = write_cmd]() {
Wait_Type::WT_NONE, [this, cmd = write_cmd]() {
return get_r1_result(cmd);
}) != SDIO_Error_Type::OK) {
sdio_.clear_multiple_interrupt_flags(clear_common_flags);
@ -379,16 +377,16 @@ SDIO_Error_Type CardDMA::write(uint8_t* buf, uint32_t address, uint32_t count) {
Block_Size block_size = get_data_block_size_index(total_bytes_);
sdio_.set_data_state_machine_and_send(Data_Timeout, total_bytes_, block_size,
Transfer_Mode::BLOCK, Transfer_Direction::SDIO_TO_CARD, true);
Transfer_Mode::BLOCK, Transfer_Direction::SDIO_TO_CARD, true);
while ((dma_.get_flag(dma::Status_Flags::FLAG_FTFIF)) || (dma_.get_flag(dma::Status_Flags::FLAG_ERRIF))) {
while (dma_.get_flag(dma::Status_Flags::FLAG_FTFIF) || dma_.get_flag(dma::Status_Flags::FLAG_ERRIF)) {
// Wait for the IRQ handler to clear
}
return SDIO_Error_Type::OK;
}
SDIO_Error_Type CardDMA::erase(uint32_t address_start, uint32_t address_end) {
auto CardDMA::erase(uint32_t address_start, uint32_t address_end) -> SDIO_Error_Type {
SDIO_Error_Type result = SDIO_Error_Type::OK;
// Card command classes CSD
@ -459,9 +457,11 @@ void CardDMA::handle_interrupts() {
disable_all_interrupts();
sdio_.set_data_state_machine_enable(false);
if ((multiblock_) && (!is_rx_)) {
if (multiblock_ && !is_rx_) {
transfer_error_ = stop_transfer();
if (transfer_error_ != SDIO_Error_Type::OK) {}
if (transfer_error_ != SDIO_Error_Type::OK) {
return;
}
}
if (!is_rx_) {
@ -497,7 +497,7 @@ void CardDMA::handle_interrupts() {
}
}
SDIO_Error_Type CardDMA::select_deselect() {
auto CardDMA::select_deselect() -> SDIO_Error_Type {
// CMD7 (SELECT/DESELECT_CARD)
if (send_command_and_check(Command_Index::CMD7, static_cast<uint32_t>(sdcard_rca_ << RCA_Shift),
Command_Response::RSP_SHORT, Wait_Type::WT_NONE, [this, cmd = Command_Index::CMD7]() {
@ -508,7 +508,7 @@ SDIO_Error_Type CardDMA::select_deselect() {
return SDIO_Error_Type::OK;
}
SDIO_Error_Type CardDMA::get_card_interface_status(uint32_t* status) {
auto CardDMA::get_card_interface_status(uint32_t* status) -> SDIO_Error_Type {
if (status == nullptr) return SDIO_Error_Type::INVALID_PARAMETER;
// CMD13 (SEND_STATUS)
@ -524,7 +524,7 @@ SDIO_Error_Type CardDMA::get_card_interface_status(uint32_t* status) {
return SDIO_Error_Type::OK;
}
SDIO_Error_Type CardDMA::get_sdcard_status(uint32_t* status) {
auto CardDMA::get_sdcard_status(uint32_t* status) -> SDIO_Error_Type {
uint32_t count = 0U;
// CMD16 (SET_BLOCKLEN)
@ -599,7 +599,7 @@ void CardDMA::check_dma_complete() {
}
}
SDIO_Error_Type CardDMA::stop_transfer() {
auto CardDMA::stop_transfer() -> SDIO_Error_Type {
// CMD12 (STOP_TRANSMISSION)
if (send_command_and_check(Command_Index::CMD12, 0, Command_Response::RSP_SHORT, Wait_Type::WT_NONE, [this, cmd = Command_Index::CMD12]() {
return get_r1_result(cmd);
@ -609,7 +609,7 @@ SDIO_Error_Type CardDMA::stop_transfer() {
return SDIO_Error_Type::OK;
}
Transfer_State CardDMA::get_transfer_state() {
auto CardDMA::get_transfer_state() -> Transfer_State {
Transfer_State transfer_state = Transfer_State::IDLE;
if (sdio_.get_flag(Status_Flags::FLAG_TXRUN) | sdio_.get_flag(Status_Flags::FLAG_RXRUN)) {
transfer_state = Transfer_State::BUSY;
@ -618,7 +618,7 @@ Transfer_State CardDMA::get_transfer_state() {
return transfer_state;
}
uint32_t CardDMA::get_card_capacity() const {
[[nodiscard]] auto CardDMA::get_card_capacity() const -> uint32_t {
auto extract_bits = [](uint32_t value, uint8_t start_bit, uint8_t length) -> uint32_t {
return (value >> start_bit) & ((1U << length) - 1U);
};
@ -665,7 +665,7 @@ uint32_t CardDMA::get_card_capacity() const {
return capacity;
}
SDIO_Error_Type CardDMA::get_card_specific_data(Card_Info* info) {
auto CardDMA::get_card_specific_data(Card_Info* info) -> SDIO_Error_Type {
if (info == nullptr) return SDIO_Error_Type::INVALID_PARAMETER;
// Store basic card information
@ -735,28 +735,20 @@ SDIO_Error_Type CardDMA::get_card_specific_data(Card_Info* info) {
return SDIO_Error_Type::OK;
}
constexpr Block_Size CardDMA::get_data_block_size_index(uint16_t size) {
switch (size) {
case 1: return Block_Size::BYTES_1;
case 2: return Block_Size::BYTES_2;
case 4: return Block_Size::BYTES_4;
case 8: return Block_Size::BYTES_8;
case 16: return Block_Size::BYTES_16;
case 32: return Block_Size::BYTES_32;
case 64: return Block_Size::BYTES_64;
case 128: return Block_Size::BYTES_128;
case 256: return Block_Size::BYTES_256;
case 512: return Block_Size::BYTES_512;
case 1024: return Block_Size::BYTES_1024;
case 2048: return Block_Size::BYTES_2048;
case 4096: return Block_Size::BYTES_4096;
case 8192: return Block_Size::BYTES_8192;
case 16384: return Block_Size::BYTES_16384;
default: return Block_Size::BYTES_1;
}
constexpr auto CardDMA::get_data_block_size_index(uint16_t size) -> Block_Size {
if (size < 1 || size > 16384) return Block_Size::BYTES_1;
// Check if size is a power of two
if ((size & (size - 1)) != 0) return Block_Size::BYTES_1;
// Count trailing zeros to find the index
uint16_t index = 0;
while ((size >>= 1) != 0) ++index;
return static_cast<Block_Size>(index);
}
SDIO_Error_Type CardDMA::get_card_state(Card_State* card_state) {
auto CardDMA::get_card_state(Card_State* card_state) -> SDIO_Error_Type {
// CMD13 (SEND_STATUS)
if (send_command_and_check(Command_Index::CMD13, static_cast<uint32_t>(sdcard_rca_ << RCA_Shift),
Command_Response::RSP_SHORT, Wait_Type::WT_NONE, [this, cmd = Command_Index::CMD13]() {
@ -773,7 +765,7 @@ SDIO_Error_Type CardDMA::get_card_state(Card_State* card_state) {
if (response & All_R1_Error_Bits) {
for (const auto& entry : errorTableR1) {
if (response & entry.mask) {
if (TEST(response, entry.bit_position)) {
return entry.errorType;
}
}
@ -783,23 +775,28 @@ SDIO_Error_Type CardDMA::get_card_state(Card_State* card_state) {
return SDIO_Error_Type::OK;
}
SDIO_Error_Type CardDMA::get_command_sent_result() {
volatile uint32_t timeout = 0x00FFFFFFU;
auto CardDMA::get_command_sent_result() -> SDIO_Error_Type {
constexpr uint32_t MAX_TIMEOUT = 0x00FFFFFFU;
uint32_t timeout = MAX_TIMEOUT;
while ((sdio_.get_flag(Status_Flags::FLAG_CMDSEND) == false) && (timeout != 0U)) {
timeout = timeout - 1U;
// Wait for command sent flag or timeout
while (!sdio_.get_flag(Status_Flags::FLAG_CMDSEND) && timeout) {
--timeout;
}
if (timeout == 0U) return SDIO_Error_Type::RESPONSE_TIMEOUT;
sdio_.clear_multiple_interrupt_flags(clear_command_flags);
// Check if timeout occurred
if (timeout == 0U) {
return SDIO_Error_Type::RESPONSE_TIMEOUT;
}
// Clear command flags and return success
sdio_.clear_multiple_interrupt_flags(clear_command_flags);
return SDIO_Error_Type::OK;
}
SDIO_Error_Type CardDMA::check_sdio_status(Command_Index index, bool check_index, bool ignore_crc) {
auto CardDMA::check_sdio_status(Command_Index index, bool check_index, bool ignore_crc) -> SDIO_Error_Type {
// Wait until one of the relevant flags is set
bool flag_set = sdio_.wait_cmd_flags();
if (!flag_set) {
if (!sdio_.wait_cmd_flags()) {
return SDIO_Error_Type::RESPONSE_TIMEOUT;
}
@ -810,56 +807,55 @@ SDIO_Error_Type CardDMA::check_sdio_status(Command_Index index, bool check_index
// If cmd was received, check the index
// Responses that dont do an index check will send an invalid cmd index
if (check_index && (index != Command_Index::INVALID)) {
uint8_t idx = sdio_.get_command_index();
if (idx != static_cast<uint8_t>(index)) {
uint8_t received_idx = sdio_.get_command_index();
if (received_idx != static_cast<uint8_t>(index)) {
sdio_.clear_multiple_interrupt_flags(clear_command_flags);
return SDIO_Error_Type::ILLEGAL_COMMAND;
}
}
// Clear all flags before returning
// Command received successfully
sdio_.clear_multiple_interrupt_flags(clear_command_flags);
return SDIO_Error_Type::OK;
}
// Timeout check
// Check for timeout
if (sdio_.get_flag(Status_Flags::FLAG_CMDTMOUT)) {
sdio_.clear_flag(Clear_Flags::FLAG_CMDTMOUTC);
return SDIO_Error_Type::RESPONSE_TIMEOUT;
}
// CRC check
if (!ignore_crc) {
if (sdio_.get_flag(Status_Flags::FLAG_CCRCERR)) {
sdio_.clear_flag(Clear_Flags::FLAG_CCRCERRC);
return SDIO_Error_Type::COMMAND_CRC_ERROR;
}
// Check for CRC error if not ignored
if (!ignore_crc && sdio_.get_flag(Status_Flags::FLAG_CCRCERR)) {
sdio_.clear_flag(Clear_Flags::FLAG_CCRCERRC);
return SDIO_Error_Type::COMMAND_CRC_ERROR;
}
// Responses that dont do an index check will send an invalid cmd index
// Final index check (redundant with the first check, but keeping for safety)
// This code path should rarely be taken due to the earlier checks
if (check_index && (index != Command_Index::INVALID)) {
uint8_t idx = sdio_.get_command_index();
if (idx != static_cast<uint8_t>(index)) {
uint8_t received_idx = sdio_.get_command_index();
if (received_idx != static_cast<uint8_t>(index)) {
sdio_.clear_multiple_interrupt_flags(clear_command_flags);
return SDIO_Error_Type::ILLEGAL_COMMAND;
}
}
// Clear all flags before returning
// Clear all flags and return success
sdio_.clear_multiple_interrupt_flags(clear_command_flags);
return SDIO_Error_Type::OK;
}
SDIO_Error_Type CardDMA::get_r1_result(Command_Index index) {
auto CardDMA::get_r1_result(Command_Index index) -> SDIO_Error_Type {
SDIO_Error_Type result = check_sdio_status(index, true, false);
if (result != SDIO_Error_Type::OK) {
return result;
}
if (result != SDIO_Error_Type::OK) return result;
// Get the R1 response and check for errors
uint32_t response = sdio_.get_response(Response_Type::RESPONSE0);
if (response & All_R1_Error_Bits) {
for (const auto& entry : errorTableR1) {
if (response & entry.mask) {
if (TEST(response, entry.bit_position)) {
return entry.errorType;
}
}
@ -869,7 +865,7 @@ SDIO_Error_Type CardDMA::get_r1_result(Command_Index index) {
return SDIO_Error_Type::OK;
}
SDIO_Error_Type CardDMA::get_r6_result(Command_Index index, uint16_t* rca) {
auto CardDMA::get_r6_result(Command_Index index, uint16_t* rca) -> SDIO_Error_Type {
SDIO_Error_Type result = check_sdio_status(index, true, false);
if (result != SDIO_Error_Type::OK) return result;
@ -877,7 +873,7 @@ SDIO_Error_Type CardDMA::get_r6_result(Command_Index index, uint16_t* rca) {
if (response & R6_Error_Bits) {
for (const auto& entry : errorTableR6) {
if (response & entry.mask) {
if (TEST(response, entry.bit_position)) {
return entry.errorType;
}
}
@ -888,18 +884,13 @@ SDIO_Error_Type CardDMA::get_r6_result(Command_Index index, uint16_t* rca) {
return SDIO_Error_Type::OK;
}
SDIO_Error_Type CardDMA::get_r7_result() {
return check_sdio_status(Command_Index::INVALID, false, false);
}
SDIO_Error_Type CardDMA::get_scr(uint16_t rca, uint32_t* scr) {
auto CardDMA::get_scr(uint16_t rca, uint32_t* scr) -> SDIO_Error_Type {
uint32_t temp_scr[2] = {0U, 0U};
uint32_t index_scr = 0U;
uint32_t* src_data = scr;
// CMD16 (SET_BLOCKLEN)
if (send_command_and_check(Command_Index::CMD16, 8U, Command_Response::RSP_SHORT,
Wait_Type::WT_NONE, [this, cmd = Command_Index::CMD16]() {
Wait_Type::WT_NONE, [this, cmd = Command_Index::CMD16]() {
return get_r1_result(cmd);
}) != SDIO_Error_Type::OK) {
return SDIO_Error_Type::CMD16_FAILED;
@ -907,7 +898,7 @@ SDIO_Error_Type CardDMA::get_scr(uint16_t rca, uint32_t* scr) {
// CMD55 (APP_CMD)
if (send_command_and_check(Command_Index::CMD55, static_cast<uint32_t>(sdcard_rca_ << RCA_Shift),
Command_Response::RSP_SHORT, Wait_Type::WT_NONE, [this, cmd = Command_Index::CMD55]() {
Command_Response::RSP_SHORT, Wait_Type::WT_NONE, [this, cmd = Command_Index::CMD55]() {
return get_r1_result(cmd);
}) != SDIO_Error_Type::OK) {
return SDIO_Error_Type::CMD55_FAILED;
@ -919,7 +910,7 @@ SDIO_Error_Type CardDMA::get_scr(uint16_t rca, uint32_t* scr) {
// ACMD51 (SEND_SCR)
if (send_command_and_check(Command_Index::ACMD51, 0U, Command_Response::RSP_SHORT,
Wait_Type::WT_NONE, [this, cmd = Command_Index::ACMD51]() {
Wait_Type::WT_NONE, [this, cmd = Command_Index::ACMD51]() {
return get_r1_result(cmd);
}) != SDIO_Error_Type::OK) {
return SDIO_Error_Type::ACMD51_FAILED;
@ -928,36 +919,41 @@ SDIO_Error_Type CardDMA::get_scr(uint16_t rca, uint32_t* scr) {
// Store SCR
while (!sdio_.check_scr_flags()) {
if (sdio_.get_flag(Status_Flags::FLAG_RXDTVAL)) {
*(temp_scr + index_scr) = sdio_.read_fifo_word();
++index_scr;
temp_scr[index_scr++] = sdio_.read_fifo_word();
}
}
// Check for errors
if (sdio_.get_flag(Status_Flags::FLAG_DTTMOUT)) {
sdio_.clear_flag(Clear_Flags::FLAG_DTTMOUTC);
return SDIO_Error_Type::DATA_TIMEOUT;
} else if (sdio_.get_flag(Status_Flags::FLAG_DTCRCERR)) {
}
else if (sdio_.get_flag(Status_Flags::FLAG_DTCRCERR)) {
sdio_.clear_flag(Clear_Flags::FLAG_DTCRCERRC);
return SDIO_Error_Type::DATA_CRC_ERROR;
} else if (sdio_.get_flag(Status_Flags::FLAG_RXORE)) {
}
else if (sdio_.get_flag(Status_Flags::FLAG_RXORE)) {
sdio_.clear_flag(Clear_Flags::FLAG_RXOREC);
return SDIO_Error_Type::RX_FIFO_OVERRUN;
}
sdio_.clear_multiple_interrupt_flags(clear_data_flags);
constexpr uint32_t Zero_Seven = (0xFFU << 0U);
constexpr uint32_t Eight_Fifteen = (0xFFU << 8U);
constexpr uint32_t Sixteen_Twentythree = (0xFFU << 16U);
constexpr uint32_t TwentyFour_Thirtyone = (0xFFU << 24U);
constexpr uint32_t BYTE0_MASK = 0xFFU;
constexpr uint32_t BYTE1_MASK = 0xFF00U;
constexpr uint32_t BYTE2_MASK = 0xFF0000U;
constexpr uint32_t BYTE3_MASK = 0xFF000000U;
// adjust SCR value
*src_data = ((temp_scr[1] & Zero_Seven) << 24U) | ((temp_scr[1] & Eight_Fifteen) << 8U) |
((temp_scr[1] & Sixteen_Twentythree) >> 8U) | ((temp_scr[1] & TwentyFour_Thirtyone) >> 24U);
// Byte-swap the SCR values (convert from big-endian to little-endian)
scr[0] = ((temp_scr[1] & BYTE0_MASK) << 24) |
((temp_scr[1] & BYTE1_MASK) << 8) |
((temp_scr[1] & BYTE2_MASK) >> 8) |
((temp_scr[1] & BYTE3_MASK) >> 24);
src_data = src_data + 1U;
*src_data = ((temp_scr[0] & Zero_Seven) << 24U) | ((temp_scr[0] & Eight_Fifteen) << 8U) |
((temp_scr[0] & Sixteen_Twentythree) >> 8U) | ((temp_scr[0] & TwentyFour_Thirtyone) >> 24U);
scr[1] = ((temp_scr[0] & BYTE0_MASK) << 24) |
((temp_scr[0] & BYTE1_MASK) << 8) |
((temp_scr[0] & BYTE2_MASK) >> 8) |
((temp_scr[0] & BYTE3_MASK) >> 24);
return SDIO_Error_Type::OK;
}
@ -965,23 +961,22 @@ SDIO_Error_Type CardDMA::get_scr(uint16_t rca, uint32_t* scr) {
// DMA for rx/tx is always DMA1 channel 3
void CardDMA::set_dma_parameters(uint8_t* buf, uint32_t count, bool is_write) {
constexpr uint32_t flag_bits = (1U << static_cast<uint32_t>(dma::INTF_Bits::GIF3));
dma_.clear_flags(flag_bits);
// Disable and reset DMA
dma_.set_channel_enable(false);
dma_.clear_channel();
dma_.init({
count,
static_cast<uint32_t>(reinterpret_cast<uintptr_t>(buf)),
static_cast<uint32_t>(reinterpret_cast<uintptr_t>(sdio_.reg_address(SDIO_Regs::FIFO))),
dma::Bit_Width::WIDTH_32BIT,
dma::Bit_Width::WIDTH_32BIT,
dma::Increase_Mode::INCREASE_DISABLE,
dma::Increase_Mode::INCREASE_ENABLE,
dma::Channel_Priority::MEDIUM_PRIORITY,
is_write ? dma::Transfer_Direction::M2P : dma::Transfer_Direction::P2M
dma_.init(dma::DMA_Config{
.count = count,
.memory_address = static_cast<uint32_t>(reinterpret_cast<uintptr_t>(buf)),
.peripheral_address = static_cast<uint32_t>(reinterpret_cast<uintptr_t>(sdio_.reg_address(SDIO_Regs::FIFO))),
.peripheral_bit_width = dma::Bit_Width::WIDTH_32BIT,
.memory_bit_width = dma::Bit_Width::WIDTH_32BIT,
.peripheral_increase = dma::Increase_Mode::INCREASE_DISABLE,
.memory_increase = dma::Increase_Mode::INCREASE_ENABLE,
.channel_priority = dma::Channel_Priority::MEDIUM_PRIORITY,
.direction = is_write ? dma::Transfer_Direction::M2P : dma::Transfer_Direction::P2M
});
dma_.set_memory_to_memory_enable(false);
@ -995,24 +990,29 @@ void CardDMA::set_dma_parameters(uint8_t* buf, uint32_t count, bool is_write) {
dma_.set_channel_enable(true);
}
SDIO_Error_Type CardDMA::wait_for_card_ready() {
volatile uint32_t timeout = 0x00FFFFFFU;
auto CardDMA::wait_for_card_ready() -> SDIO_Error_Type {
constexpr uint32_t MAX_TIMEOUT = 0x00FFFFFFU;
uint32_t timeout = MAX_TIMEOUT;
uint32_t response = sdio_.get_response(Response_Type::RESPONSE0);
while (((response & static_cast<uint32_t>(R1_Status::READY_FOR_DATA)) == 0U) && (timeout != 0U)) {
// Continue to send CMD13 to poll the state of card until buffer empty or timeout
timeout = timeout - 1U;
// Poll until card is ready for data or timeout occurs
while (((response & static_cast<uint32_t>(R1_Status::READY_FOR_DATA)) == 0U) && timeout) {
--timeout;
// CMD13 (SEND_STATUS)
if (send_command_and_check(Command_Index::CMD13, static_cast<uint32_t>(sdcard_rca_ << RCA_Shift),
Command_Response::RSP_SHORT, Wait_Type::WT_NONE, [this, cmd = Command_Index::CMD13]() {
Command_Response::RSP_SHORT, Wait_Type::WT_NONE, [this, cmd = Command_Index::CMD13]() {
return get_r1_result(cmd);
}) != SDIO_Error_Type::OK) {
return SDIO_Error_Type::CMD13_FAILED;
}
// Get updated response
response = sdio_.get_response(Response_Type::RESPONSE0);
}
return (timeout == 0U) ? SDIO_Error_Type::ERROR : SDIO_Error_Type::OK;
// Return error if timeout occurred, otherwise success
return timeout ? SDIO_Error_Type::OK : SDIO_Error_Type::ERROR;
}
} // namespace sdio

198
Marlin/src/HAL/GD32_MFL/sd/SDCard.h
View file

@ -26,76 +26,82 @@ class DMA;
class CardDMA {
public:
static CardDMA& get_instance();
static auto get_instance() -> CardDMA&;
SDIO_Error_Type init();
SDIO_Error_Type card_init();
SDIO_Error_Type begin_startup_procedure();
// Initialization
auto init() -> SDIO_Error_Type;
auto card_init() -> SDIO_Error_Type;
// Startup and shutdown procedures
auto begin_startup_procedure() -> SDIO_Error_Type;
void begin_shutdown_procedure();
// Configuration
SDIO_Error_Type set_hardware_bus_width(Bus_Width width);
// Main read/write functions for single and multiblock transfers
SDIO_Error_Type read(uint8_t* buf, uint32_t address, uint32_t count);
SDIO_Error_Type write(uint8_t* buf, uint32_t address, uint32_t count);
// DMA transfers
// Other card functions
SDIO_Error_Type erase(uint32_t address_start, uint32_t address_end);
// Interrupt handler
void handle_interrupts();
auto set_hardware_bus_width(Bus_Width width) -> SDIO_Error_Type;
auto send_bus_width_command(uint32_t width_value) -> SDIO_Error_Type;
// Main read/write/erase functions
auto read(uint8_t* buf, uint32_t address, uint32_t count) -> SDIO_Error_Type;
auto write(uint8_t* buf, uint32_t address, uint32_t count) -> SDIO_Error_Type;
auto erase(uint32_t address_start, uint32_t address_end) -> SDIO_Error_Type;
// Card select
SDIO_Error_Type select_deselect();
auto select_deselect() -> SDIO_Error_Type;
SDIO_Error_Type get_card_interface_status(uint32_t* status);
SDIO_Error_Type get_sdcard_status(uint32_t* status);
// Status and state
auto get_card_interface_status(uint32_t* status) -> SDIO_Error_Type;
auto get_sdcard_status(uint32_t* status) -> SDIO_Error_Type;
auto get_transfer_state() -> Transfer_State;
auto get_card_state(Card_State* card_state) -> SDIO_Error_Type;
auto check_sdio_status(Command_Index index = Command_Index::INVALID, bool check_index = false, bool ignore_crc = false) -> SDIO_Error_Type;
void check_dma_complete();
SDIO_Error_Type stop_transfer();
Transfer_State get_transfer_state();
uint32_t get_card_capacity() const;
SDIO_Error_Type send_bus_width_command(uint32_t width_value);
SDIO_Error_Type get_card_specific_data(Card_Info* info);
constexpr Block_Size get_data_block_size_index(uint16_t size);
SDIO_Error_Type get_card_state(Card_State* card_state);
SDIO_Error_Type check_sdio_status(Command_Index index = Command_Index::INVALID, bool check_index = false, bool ignore_crc = false);
// DMA configuration
// DMA
void set_dma_parameters(uint8_t* buf, uint32_t count, bool is_write);
void check_dma_complete();
// Stop transfer
auto stop_transfer() -> SDIO_Error_Type;
// Card information
auto get_card_specific_data(Card_Info* info) -> SDIO_Error_Type;
constexpr auto get_data_block_size_index(uint16_t size) -> Block_Size;
[[nodiscard]] auto get_card_capacity() const -> uint32_t;
// SDIO configuration
void sdio_configure(const SDIO_Config config) { sdio_.init(config); }
// Varaible stored parameters
SDIO_Error_Type get_scr(uint16_t rca, uint32_t* scr);
SDIO_Error_Type store_cid();
SDIO_Error_Type store_csd();
// Interrupt handler
void handle_interrupts();
// Accessor methods
SDIO_Config& get_config() { return config_; }
dma::DMA& get_dma_instance() { return dma_; }
// Varaible stored parameters
auto get_scr(uint16_t rca, uint32_t* scr) -> SDIO_Error_Type;
auto store_cid() -> SDIO_Error_Type;
auto store_csd() -> SDIO_Error_Type;
// Inlined accessor methods
auto get_config() -> SDIO_Config& { return config_; }
auto get_dma_instance() -> dma::DMA& { return dma_; }
void set_data_end_interrupt() { sdio_.set_interrupt_enable(Interrupt_Type::DTENDIE, true); }
void set_sdio_dma_enable(bool enable) { sdio_.set_dma_enable(enable); }
bool get_is_sdio_rx() { return is_rx_; }
auto get_is_sdio_rx() -> bool { return is_rx_; }
void clear_sdio_data_flags() { sdio_.clear_multiple_interrupt_flags(clear_data_flags); }
void clear_sdio_cmd_flags() { sdio_.clear_multiple_interrupt_flags(clear_command_flags); }
void clear_sdio_common_flags() { sdio_.clear_multiple_interrupt_flags(clear_common_flags); }
Operational_State get_state() { return current_state_; }
auto get_state() -> Operational_State { return current_state_; }
void set_state(Operational_State state) { current_state_ = state; }
void set_transfer_end(bool value) { transfer_end_ = value; }
void set_transfer_error(SDIO_Error_Type error) { transfer_error_ = error; }
void set_transfer_end(bool end) { transfer_end_ = end; };
inline SDIO_Error_Type set_desired_clock(uint32_t desired_clock, bool wide_bus, bool low_power) {
sdio_.init({
desired_clock,
Clock_Edge::RISING_EDGE,
wide_bus ? Bus_Width::WIDTH_4BIT : Bus_Width::WIDTH_1BIT,
false,
low_power,
false
auto set_desired_clock(uint32_t desired_clock, bool wide_bus, bool low_power) -> SDIO_Error_Type {
sdio_.init(SDIO_Config{
.desired_clock = desired_clock,
.enable_bypass = false,
.enable_powersave = low_power,
.enable_hwclock = false,
.clock_edge = Clock_Edge::RISING_EDGE,
.width = wide_bus ? Bus_Width::WIDTH_4BIT : Bus_Width::WIDTH_1BIT
});
sync_domains();
desired_clock_ = desired_clock;
@ -107,19 +113,17 @@ private:
// Prevent copying or assigning
CardDMA(const CardDMA&) = delete;
CardDMA& operator=(const CardDMA&) = delete;
auto operator=(const CardDMA&) -> CardDMA& = delete;
// Helper function
SDIO_Error_Type wait_for_card_ready();
auto wait_for_card_ready() -> SDIO_Error_Type;
// Member variables
alignas(4) uint32_t sdcard_csd_[4];
alignas(4) uint32_t sdcard_cid_[4];
alignas(4) uint32_t sdcard_scr_[2];
uint32_t desired_clock_;
uint32_t stop_condition_;
uint32_t total_bytes_;
uint32_t count_;
SDIO& sdio_;
SDIO_Config& config_;
const dma::DMA_Base dmaBase_;
@ -129,66 +133,70 @@ private:
SDIO_Error_Type transfer_error_;
Interface_Version interface_version_;
Card_Type card_type_;
volatile bool transfer_end_;
volatile bool is_rx_;
volatile bool multiblock_;
volatile Operational_State current_state_;
Operational_State current_state_;
bool transfer_end_;
bool multiblock_;
bool is_rx_;
// Private helper methods
SDIO_Error_Type validate_voltage();
SDIO_Error_Type get_r1_result(Command_Index index);
//SDIO_Error_Type get_r2_r3_result();
SDIO_Error_Type get_r6_result(Command_Index index, uint16_t* rca);
SDIO_Error_Type get_r7_result();
//SDIO_Error_Type get_r1_error_type(uint32_t response);
SDIO_Error_Type get_command_sent_result();
auto validate_voltage() -> SDIO_Error_Type;
auto get_command_sent_result() -> SDIO_Error_Type;
auto get_r1_result(Command_Index index) -> SDIO_Error_Type;
auto get_r6_result(Command_Index index, uint16_t* rca) -> SDIO_Error_Type;
auto get_r7_result() -> SDIO_Error_Type { return check_sdio_status(Command_Index::INVALID, false, false); };
void sync_domains() { delayMicroseconds(8); }
inline void sync_domains() {
delayMicroseconds(8);
}
inline bool validate_transfer_params(uint32_t* buf, uint16_t size) {
auto validate_transfer_params(uint32_t* buf, uint16_t size) -> bool {
if (buf == nullptr) return false;
// Size must be > 0, <= 2048 and power of 2
if ((size == 0U) || (size > 2048U) || (size & (size - 1U))) {
return false;
}
return true;
return size > 0U && size <= 2048U && !(size & (size - 1U));
}
void process_sdsc_specific_csd(Card_Info* info, const uint8_t* csd_bytes) {
info->csd.device_size = (static_cast<uint32_t>(csd_bytes[6] & 0x03U) << 10U) |
(static_cast<uint32_t>(csd_bytes[7]) << 2U) |
(static_cast<uint32_t>((csd_bytes[8] & 0xC0U) >> 6U));
info->csd.device_size_multiplier = static_cast<uint8_t>((csd_bytes[9] & 0x03U) << 1U |
(csd_bytes[10] & 0x80U) >> 7U);
const uint32_t device_size = ((csd_bytes[6] & 0x3U) << 10) |
(csd_bytes[7] << 2) |
((csd_bytes[8] >> 6) & 0x3U);
info->block_size = static_cast<uint32_t>(1 << info->csd.read_block_length);
info->capacity = static_cast<uint32_t>((info->csd.device_size + 1U) *
(1U << (info->csd.device_size_multiplier + 2U)) *
info->block_size);
const uint8_t device_size_multiplier = ((csd_bytes[9] & 0x3U) << 1) |
((csd_bytes[10] >> 7) & 0x1U);
// Store calculated values
info->csd.device_size = device_size;
info->csd.device_size_multiplier = device_size_multiplier;
// Calculate block size and capacity
info->block_size = 1U << info->csd.read_block_length;
info->capacity = (device_size + 1U) *
(1U << (device_size_multiplier + 2U)) *
info->block_size;
}
void process_sdhc_specific_csd(Card_Info* info, const uint8_t* csd_bytes) {
info->csd.device_size = static_cast<uint32_t>((csd_bytes[7] & 0x3FU) << 16U) |
static_cast<uint32_t>((csd_bytes[8]) << 8U) |
static_cast<uint32_t>(csd_bytes[9]);
info->csd.device_size = static_cast<uint32_t>((csd_bytes[7] & 0x3FU) << 16) |
static_cast<uint32_t>((csd_bytes[8]) << 8) |
static_cast<uint32_t>(csd_bytes[9]);
// Set block size and calculate capacity
info->block_size = BLOCK_SIZE;
info->capacity = static_cast<uint32_t>((info->csd.device_size + 1U) *
BLOCK_SIZE * KILOBYTE);
BLOCK_SIZE * KILOBYTE);
}
void process_common_csd_tail(Card_Info* info, const uint8_t* csd_bytes) {
info->csd.sector_size = static_cast<uint8_t>(((csd_bytes[9] & 0x3FU) << 1U) |
(csd_bytes[10] & 0x80U) >> 7U);
info->csd.speed_factor = static_cast<uint8_t>((csd_bytes[11] & 0x1CU) >> 2U);
info->csd.write_block_length = static_cast<uint8_t>(((csd_bytes[11] & 0x03U) << 2U) |
((csd_bytes[12] & 0xC0U) >> 6U));
info->csd.checksum = static_cast<uint8_t>((csd_bytes[15] & 0xFEU) >> 1U);
// Calculate sector_size
info->csd.sector_size = static_cast<uint8_t>(((csd_bytes[9] & 0x3FU) << 1) |
(csd_bytes[10] & 0x80U) >> 7);
// Calculate speed_factor and write_block_length
info->csd.speed_factor = static_cast<uint8_t>((csd_bytes[11] & 0x1CU) >> 2);
info->csd.write_block_length = static_cast<uint8_t>(((csd_bytes[11] & 0x3U) << 2) |
((csd_bytes[12] & 0xC0U) >> 6));
// Calculate checksum
info->csd.checksum = static_cast<uint8_t>((csd_bytes[15] & 0xFEU) >> 1);
}
inline void disable_all_interrupts() {
void disable_all_interrupts() {
sdio_.set_interrupt_enable(Interrupt_Type::DTCRCERRIE, false);
sdio_.set_interrupt_enable(Interrupt_Type::DTTMOUTIE, false);
sdio_.set_interrupt_enable(Interrupt_Type::DTENDIE, false);
@ -200,8 +208,8 @@ private:
}
template <typename CheckFunc>
inline SDIO_Error_Type send_command_and_check(Command_Index command, uint32_t argument,
Command_Response response, Wait_Type type, CheckFunc check_result) {
auto send_command_and_check(Command_Index command, uint32_t argument,
Command_Response response, Wait_Type type, CheckFunc check_result) -> SDIO_Error_Type {
sdio_.set_command_state_machine(command, argument, response, type);
sync_domains();
sdio_.set_command_state_machine_enable(true);

2
Marlin/src/HAL/GD32_MFL/sd/sdio.cpp
View file

@ -47,7 +47,7 @@ inline constexpr uint8_t SDIO_READ_RETRIES = READ_RETRIES;
Card_State cardState = Card_State::READY;
bool SDIO_SetBusWidth(Bus_Width width) {
auto SDIO_SetBusWidth(Bus_Width width) -> bool {
return (CardDMA_I.set_hardware_bus_width(width) == SDIO_Error_Type::OK);
}

2
Marlin/src/HAL/GD32_MFL/sd/sdio.h
View file

@ -32,5 +32,5 @@
#define SDIO_CMD_PIN PD2
void sdio_mfl_init();
bool SDIO_SetBusWidth(sdio::Bus_Width width);
auto SDIO_SetBusWidth(sdio::Bus_Width width) -> bool;
void DMA1_IRQHandler(dma::DMA_Channel channel);

2
Marlin/src/HAL/GD32_MFL/temp_soc.h
View file

@ -26,4 +26,4 @@
#define TS_TYPICAL_SLOPE 4.5
// TODO: Implement voltage scaling (calibrated Vrefint) and ADC resolution scaling (when applicable)
#define TEMP_SOC_SENSOR(RAW) ((TS_TYPICAL_V - (RAW) / float(OVERSAMPLENR) / float(HAL_ADC_RANGE) * (float(ADC_VREF_MV) / 1000)) / ((TS_TYPICAL_SLOPE) / 1000) + TS_TYPICAL_TEMP)
#define TEMP_SOC_SENSOR(RAW) ((TS_TYPICAL_V - (RAW) / float(OVERSAMPLENR) / float(HAL_ADC_RANGE) * (float(ADC_VREF_MV) / 1000.0f)) / ((TS_TYPICAL_SLOPE) / 1000.0f) + TS_TYPICAL_TEMP)

10
Marlin/src/HAL/GD32_MFL/timers.h
View file

@ -44,9 +44,9 @@
extern uint32_t GetStepperTimerClkFreq();
// Timer prescaler calculations
#define STEPPER_TIMER_PRESCALE (GetStepperTimerClkFreq() / STEPPER_TIMER_RATE) // Prescaler = 30
#define STEPPER_TIMER_PRESCALE (GetStepperTimerClkFreq() / STEPPER_TIMER_RATE) // Prescaler = 30
#define PULSE_TIMER_PRESCALE STEPPER_TIMER_PRESCALE
#define STEPPER_TIMER_TICKS_PER_US ((STEPPER_TIMER_RATE) / 1000000) // Stepper timer ticks per µs
#define STEPPER_TIMER_TICKS_PER_US ((STEPPER_TIMER_RATE) / 1000000) // Stepper timer ticks per µs
#define PULSE_TIMER_RATE STEPPER_TIMER_RATE
#define PULSE_TIMER_TICKS_PER_US STEPPER_TIMER_TICKS_PER_US
@ -57,7 +57,7 @@ extern uint32_t GetStepperTimerClkFreq();
#define ENABLE_STEPPER_DRIVER_INTERRUPT() HAL_timer_enable_interrupt(MF_TIMER_STEP)
#define DISABLE_STEPPER_DRIVER_INTERRUPT() HAL_timer_disable_interrupt(MF_TIMER_STEP)
#define STEPPER_ISR_ENABLED() HAL_timer_interrupt_enabled(MF_TIMER_STEP)
#define ENABLE_TEMPERATURE_INTERRUPT() HAL_timer_enable_interrupt(MF_TIMER_TEMP)
#define ENABLE_TEMPERATURE_INTERRUPT() HAL_timer_enable_interrupt(MF_TIMER_TEMP)
#define DISABLE_TEMPERATURE_INTERRUPT() HAL_timer_disable_interrupt(MF_TIMER_TEMP)
extern void Step_Handler();
@ -89,7 +89,7 @@ static inline constexpr struct {timer::TIMER_Base base; uint8_t timer_number;} b
};
// Converts a timer base to an integer timer index.
constexpr int timer_base_to_index(timer::TIMER_Base base) {
constexpr auto timer_base_to_index(timer::TIMER_Base base) -> int {
for (const auto& timer : base_to_index) {
if (timer.base == base) {
return static_cast<int>(timer.timer_number);
@ -131,7 +131,7 @@ FORCE_INLINE static hal_timer_t HAL_timer_get_count(const uint8_t timer_number)
FORCE_INLINE static void HAL_timer_set_compare(const uint8_t timer_number, const hal_timer_t value) {
if (!HAL_timer_initialized(timer_number)) return;
const uint32_t new_value = static_cast<uint32_t>(value + 1U);
const auto new_value = static_cast<uint32_t>(value + 1U);
GeneralTimer& timer = (timer_number == MF_TIMER_STEP) ? Step_Timer : Temp_Timer;
if (timer_number == MF_TIMER_STEP || timer_number == MF_TIMER_TEMP) {

2
Marlin/src/HAL/HC32/eeprom/eeprom_if_iic.cpp
View file

@ -39,7 +39,7 @@ void eeprom_init() {
void eeprom_write_byte(uint8_t *pos, unsigned char value) {
const unsigned eeprom_address = (unsigned)pos;
return BL24CXX::writeOneByte(eeprom_address, value);
BL24CXX::writeOneByte(eeprom_address, value);
}
uint8_t eeprom_read_byte(uint8_t *pos) {

19
Marlin/src/HAL/LPC1768/upload_extra_script.py
View file

@ -54,18 +54,25 @@ if pioutil.is_pio_build():
final_drive_name = drive + ':'
# print ('disc check: {}'.format(final_drive_name))
try:
volume_info = str(subprocess.check_output('cmd /C dir ' + final_drive_name, stderr=subprocess.STDOUT))
volume_info = str(subprocess.check_output('cmd /C vol ' + final_drive_name, stderr=subprocess.STDOUT))
except Exception as e:
print ('error:{}'.format(e))
continue
else:
if target_drive in volume_info and not target_file_found: # set upload if not found target file yet
target_drive_found = True
if target_drive in volume_info: # set upload
upload_disk = PureWindowsPath(final_drive_name)
if target_filename in volume_info:
if not target_file_found:
target_drive_found = True
break
try:
dir_info = str(subprocess.check_output('cmd /C dir ' + final_drive_name, stderr=subprocess.STDOUT))
except Exception as e:
print ('error:{}'.format(e))
continue
else:
if target_filename in dir_info:
upload_disk = PureWindowsPath(final_drive_name)
target_file_found = True
target_file_found = True
break
elif current_OS == 'Linux':
#

2
Marlin/src/HAL/RP2040/HAL.cpp
View file

@ -59,7 +59,7 @@ void MarlinHAL::init() {
constexpr int cpuFreq = F_CPU;
UNUSED(cpuFreq);
#if HAS_MEDIA && DISABLED(SDIO_SUPPORT) && PIN_EXISTS(SD_SS)
#if HAS_MEDIA && DISABLED(ONBOARD_SDIO) && PIN_EXISTS(SD_SS)
OUT_WRITE(SD_SS_PIN, HIGH); // Try to set SD_SS_PIN inactive before any other SPI users start up
#endif

2
Marlin/src/HAL/STM32/eeprom/eeprom_if_iic.cpp
View file

@ -44,7 +44,7 @@ void eeprom_init() { BL24CXX::init(); }
void eeprom_write_byte(uint8_t *pos, uint8_t value) {
const unsigned eeprom_address = (unsigned)pos;
return BL24CXX::writeOneByte(eeprom_address, value);
BL24CXX::writeOneByte(eeprom_address, value);
}
uint8_t eeprom_read_byte(uint8_t *pos) {

2
Marlin/src/HAL/STM32/temp_soc.h
View file

@ -341,6 +341,6 @@
#elif defined(TS_TYPICAL_V) && defined(TS_TYPICAL_SLOPE) && defined(TS_TYPICAL_TEMP)
#define TEMP_SOC_SENSOR(RAW) ((TS_TYPICAL_V - (RAW) / float(OVERSAMPLENR) / float(HAL_ADC_RANGE) * (float(ADC_VREF_MV) / 1000.0f)) / ((TS_TYPICAL_SLOPE) / 1000) + TS_TYPICAL_TEMP)
#define TEMP_SOC_SENSOR(RAW) ((TS_TYPICAL_V - (RAW) / float(OVERSAMPLENR) / float(HAL_ADC_RANGE) * (float(ADC_VREF_MV) / 1000.0f)) / ((TS_TYPICAL_SLOPE) / 1000.0f) + TS_TYPICAL_TEMP)
#endif

2
Marlin/src/HAL/STM32F1/eeprom/eeprom_if_iic.cpp
View file

@ -42,7 +42,7 @@ void eeprom_init() { BL24CXX::init(); }
void eeprom_write_byte(uint8_t *pos, uint8_t value) {
const unsigned eeprom_address = (unsigned)pos;
return BL24CXX::writeOneByte(eeprom_address, value);
BL24CXX::writeOneByte(eeprom_address, value);
}
uint8_t eeprom_read_byte(uint8_t *pos) {

6
Marlin/src/HAL/shared/Delay.h
View file

@ -100,7 +100,7 @@ void calibrate_delay_loop();
// For delay in microseconds, no smart delay selection is required, directly call the delay function
// Teensy compiler is too old and does not accept smart delay compile-time / run-time selection correctly
#define DELAY_US(x) DelayCycleFnc((x) * ((F_CPU) / 1000000UL))
#define DELAY_US(x) DelayCycleFnc((unsigned long)(x) * ((F_CPU) / 1000000UL))
#elif defined(__AVR__)
FORCE_INLINE static void __delay_up_to_3c(uint8_t cycles) {
@ -164,7 +164,7 @@ void calibrate_delay_loop();
}
// Delay in microseconds
#define DELAY_US(x) DELAY_CYCLES((x) * ((F_CPU) / 1000000UL))
#define DELAY_US(x) DELAY_CYCLES((unsigned long)(x) * ((F_CPU) / 1000000UL))
#define DELAY_CYCLES_VAR DELAY_CYCLES
@ -173,7 +173,7 @@ void calibrate_delay_loop();
// DELAY_CYCLES specified inside platform
// Delay in microseconds
#define DELAY_US(x) DELAY_CYCLES((x) * ((F_CPU) / 1000000UL))
#define DELAY_US(x) DELAY_CYCLES((unsigned long)(x) * ((F_CPU) / 1000000UL))
#define DELAY_CYCLES_VAR DELAY_CYCLES

4
Marlin/src/core/boards.h
View file

@ -275,7 +275,7 @@
#define BOARD_MKS_SGEN_L_V2 2509 // MKS SGEN_L V2
#define BOARD_BTT_SKR_E3_TURBO 2510 // BigTreeTech SKR E3 Turbo
#define BOARD_FLY_CDY 2511 // FLYmaker FLY CDY
#define BOARD_XTLW_CLIMBER_8TH_LPC 2512 // XTLW_CLIMBER_8TH_LPC
#define BOARD_XTLW_CLIMBER_8TH_LPC 2512 // XTLW Climber 8
//
// SAM3X8E ARM Cortex-M3
@ -283,7 +283,7 @@
#define BOARD_DUE3DOM 3000 // DUE3DOM for Arduino DUE
#define BOARD_DUE3DOM_MINI 3001 // DUE3DOM MINI for Arduino DUE
#define BOARD_RADDS 3002 // RADDS
#define BOARD_RADDS 3002 // RADDS v1.5/v1.6
#define BOARD_RAMPS_FD_V1 3003 // RAMPS-FD v1
#define BOARD_RAMPS_FD_V2 3004 // RAMPS-FD v2
#define BOARD_RAMPS_SMART_EFB 3005 // RAMPS-SMART (Power outputs: Hotend, Fan, Bed)

36
Marlin/src/core/drivers.h
View file

@ -41,6 +41,8 @@
#define _TMC2208_STANDALONE 0x2208B
#define _TMC2209 0x2209A
#define _TMC2209_STANDALONE 0x2209B
#define _TMC2240 0x2240A
#define _TMC2240_STANDALONE 0x2240B
#define _TMC2660 0x2660A
#define _TMC2660_STANDALONE 0x2660B
#define _TMC5130 0x5130A
@ -96,7 +98,7 @@
// Does not match standalone configurations
#if ( HAS_DRIVER(TMC2130) || HAS_DRIVER(TMC2160) \
|| HAS_DRIVER(TMC2208) || HAS_DRIVER(TMC2209) \
|| HAS_DRIVER(TMC2660) \
|| HAS_DRIVER(TMC2240) || HAS_DRIVER(TMC2660) \
|| HAS_DRIVER(TMC5130) || HAS_DRIVER(TMC5160) )
#define HAS_TRINAMIC_CONFIG 1
#endif
@ -106,22 +108,33 @@
#if ( HAS_DRIVER(TMC2100) \
|| HAS_DRIVER(TMC2130_STANDALONE) || HAS_DRIVER(TMC2160_STANDALONE) \
|| HAS_DRIVER(TMC2208_STANDALONE) || HAS_DRIVER(TMC2209_STANDALONE) \
|| HAS_DRIVER(TMC2660_STANDALONE) || HAS_DRIVER(TMC5130_STANDALONE) \
|| HAS_DRIVER(TMC5160_STANDALONE) )
|| HAS_DRIVER(TMC2240_STANDALONE) || HAS_DRIVER(TMC2660_STANDALONE) \
|| HAS_DRIVER(TMC5130_STANDALONE) || HAS_DRIVER(TMC5160_STANDALONE) )
#define HAS_TRINAMIC_STANDALONE 1
#endif
#if HAS_DRIVER(TMC2130) || HAS_DRIVER(TMC2160) || HAS_DRIVER(TMC5130) || HAS_DRIVER(TMC5160)
#define HAS_TMCX1X0 1
#endif
#if HAS_TMCX1X0 || HAS_DRIVER(TMC2240)
#define HAS_TMCX1X0_OR_2240 1
#endif
#if HAS_DRIVER(TMC2208) || HAS_DRIVER(TMC2209)
#define HAS_TMC220x 1
#endif
//#if HAS_TMC_220x || HAS_DRIVER(TMC2240)
// #define HAS_TMC22xx 1
//#endif
//#if HAS_TMCX1X0 || HAS_TMC220x
// #define HAS_TMC_CS_ACTUAL 1
//#endif
//#if HAS_TMCX1X0 || HAS_DRIVER(TMC2209)
// #define HAS_TMC_SG_RESULT 1
//#endif
#define AXIS_IS_TMC(A) ( AXIS_DRIVER_TYPE(A,TMC2130) || AXIS_DRIVER_TYPE(A,TMC2160) \
|| AXIS_DRIVER_TYPE(A,TMC2208) || AXIS_DRIVER_TYPE(A,TMC2209) \
|| AXIS_DRIVER_TYPE(A,TMC2660) \
|| AXIS_DRIVER_TYPE(A,TMC2240) || AXIS_DRIVER_TYPE(A,TMC2660) \
|| AXIS_DRIVER_TYPE(A,TMC5130) || AXIS_DRIVER_TYPE(A,TMC5160) )
#define AXIS_IS_TMC_CONFIG AXIS_IS_TMC
@ -129,8 +142,8 @@
// Test for a driver that uses SPI - this allows checking whether a _CS_ pin
// is considered sensitive
#define AXIS_HAS_SPI(A) ( AXIS_DRIVER_TYPE(A,TMC2130) || AXIS_DRIVER_TYPE(A,TMC2160) \
|| AXIS_DRIVER_TYPE(A,TMC2660) || AXIS_DRIVER_TYPE(A,TMC5130) \
|| AXIS_DRIVER_TYPE(A,TMC5160) )
|| AXIS_DRIVER_TYPE(A,TMC2240) || AXIS_DRIVER_TYPE(A,TMC2660) \
|| AXIS_DRIVER_TYPE(A,TMC5130) || AXIS_DRIVER_TYPE(A,TMC5160) )
#define AXIS_HAS_UART(A) ( AXIS_DRIVER_TYPE(A,TMC2208) || AXIS_DRIVER_TYPE(A,TMC2209) )
@ -140,19 +153,21 @@
#define AXIS_HAS_SW_SERIAL(A) ( AXIS_HAS_UART(A) && !defined(A##_HARDWARE_SERIAL) )
#define AXIS_HAS_STALLGUARD(A) ( AXIS_DRIVER_TYPE(A,TMC2130) || AXIS_DRIVER_TYPE(A,TMC2160) \
|| AXIS_DRIVER_TYPE(A,TMC2209) \
|| AXIS_DRIVER_TYPE(A,TMC2209) || AXIS_DRIVER_TYPE(A,TMC2240) \
|| AXIS_DRIVER_TYPE(A,TMC2660) \
|| AXIS_DRIVER_TYPE(A,TMC5130) || AXIS_DRIVER_TYPE(A,TMC5160) )
#define AXIS_HAS_STEALTHCHOP(A) ( AXIS_DRIVER_TYPE(A,TMC2130) || AXIS_DRIVER_TYPE(A,TMC2160) \
|| AXIS_DRIVER_TYPE(A,TMC2208) || AXIS_DRIVER_TYPE(A,TMC2209) \
|| AXIS_DRIVER_TYPE(A,TMC2240) \
|| AXIS_DRIVER_TYPE(A,TMC5130) || AXIS_DRIVER_TYPE(A,TMC5160) )
#define AXIS_HAS_SG_RESULT(A) ( AXIS_DRIVER_TYPE(A,TMC2130) || AXIS_DRIVER_TYPE(A,TMC2160) \
|| AXIS_DRIVER_TYPE(A,TMC2208) || AXIS_DRIVER_TYPE(A,TMC2209) )
|| AXIS_DRIVER_TYPE(A,TMC2208) || AXIS_DRIVER_TYPE(A,TMC2209) \
|| AXIS_DRIVER_TYPE(A,TMC2240) )
#define AXIS_HAS_COOLSTEP(A) ( AXIS_DRIVER_TYPE(A,TMC2130) \
|| AXIS_DRIVER_TYPE(A,TMC2209) \
|| AXIS_DRIVER_TYPE(A,TMC2209) || AXIS_DRIVER_TYPE(A,TMC2240) \
|| AXIS_DRIVER_TYPE(A,TMC5130) || AXIS_DRIVER_TYPE(A,TMC5160) )
#define _OR_EAH(N,T) || AXIS_HAS_##T(E##N)
@ -195,6 +210,7 @@
#define THRS_TMC2160 255
#define THRS_TMC2208 255
#define THRS_TMC2209 255
#define THRS_TMC2240 255
#define THRS_TMC2660 65535
#define THRS_TMC5130 65535
#define THRS_TMC5160 65535

37
Marlin/src/core/macros.h
View file

@ -307,6 +307,12 @@
#define GANG_N_1(N,K) _GANG_N(N,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K)
// Expansion of some list items
#define LIST_32(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,AA,BB,CC,DD,EE,FF,...) A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,AA,BB,CC,DD,EE,FF
#define LIST_31(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,AA,BB,CC,DD,EE,...) A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,AA,BB,CC,DD,EE
#define LIST_30(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,AA,BB,CC,DD,...) A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,AA,BB,CC,DD
#define LIST_29(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,AA,BB,CC,...) A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,AA,BB,CC
#define LIST_28(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,AA,BB,...) A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,TU,V,W,X,Y,Z,AA,BB
#define LIST_27(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,AA,...) A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,AA
#define LIST_26(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,...) A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z
#define LIST_25(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,...) A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y
#define LIST_24(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,...) A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X
@ -547,6 +553,9 @@
#endif
// Limit an index to an array size
#define ALIM(I,ARR) _MIN(I, (signed)COUNT(ARR) - 1)
// Macros for adding
#define INC_0 1
#define INC_1 2
@ -569,6 +578,17 @@
#define INC_18 19
#define INC_19 20
#define INC_20 21
#define INC_21 22
#define INC_22 23
#define INC_23 24
#define INC_24 25
#define INC_25 26
#define INC_26 27
#define INC_27 28
#define INC_28 29
#define INC_29 30
#define INC_30 31
#define INC_31 32
#define INCREMENT_(n) INC_##n
#define INCREMENT(n) INCREMENT_(n)
@ -604,6 +624,23 @@
#define DEC_13 12
#define DEC_14 13
#define DEC_15 14
#define DEC_16 15
#define DEC_17 16
#define DEC_18 17
#define DEC_19 18
#define DEC_20 19
#define DEC_21 20
#define DEC_22 21
#define DEC_23 22
#define DEC_24 23
#define DEC_25 24
#define DEC_26 25
#define DEC_27 26
#define DEC_28 27
#define DEC_29 28
#define DEC_30 29
#define DEC_31 30
#define DEC_32 31
#define DECREMENT_(n) DEC_##n
#define DECREMENT(n) DECREMENT_(n)

4
Marlin/src/core/serial.cpp
View file

@ -114,10 +114,6 @@ void serial_ternary(FSTR_P const pre, const bool onoff, FSTR_P const on, FSTR_P
if (post) SERIAL_ECHO(post);
}
void serialprint_onoff(const bool onoff) { SERIAL_ECHO(onoff ? F(STR_ON) : F(STR_OFF)); }
void serialprintln_onoff(const bool onoff) { serialprint_onoff(onoff); SERIAL_EOL(); }
void serialprint_truefalse(const bool tf) { SERIAL_ECHO(tf ? F("true") : F("false")); }
void print_bin(uint16_t val) {
for (uint8_t i = 16; i--;) {
SERIAL_CHAR('0' + TEST(val, i));

6
Marlin/src/core/serial.h
View file

@ -233,9 +233,9 @@ void serial_ternary(FSTR_P const pre, const bool onoff, FSTR_P const on, FSTR_P
// Print up to 255 spaces
void SERIAL_ECHO_SP(uint8_t count);
void serialprint_onoff(const bool onoff);
void serialprintln_onoff(const bool onoff);
void serialprint_truefalse(const bool tf);
inline FSTR_P const ON_OFF(const bool onoff) { return onoff ? F("ON") : F("OFF"); }
inline FSTR_P const TRUE_FALSE(const bool tf) { return tf ? F("true") : F("false"); }
void serial_offset(const_float_t v, const uint8_t sp=0); // For v==0 draw space (sp==1) or plus (sp==2)
void print_bin(const uint16_t val);

38
Marlin/src/core/types.h
View file

@ -168,7 +168,7 @@ template <class L, class R> struct IF<true, L, R> { typedef L type; };
// Helpers
#define _RECIP(N) ((N) ? 1.0f / static_cast<float>(N) : 0.0f)
#define _ABS(N) ((N) < 0 ? -(N) : (N))
#define _ABS(N) ((N) < decltype(N)(0) ? -(N) : (N))
#define _LS(N) T(uint32_t(N) << p)
#define _RS(N) T(uint32_t(N) >> p)
#define _LSE(N) N = T(uint32_t(N) << p)
@ -640,8 +640,8 @@ struct XYZval {
FI void reset() { NUM_AXIS_CODE(x = 0, y = 0, z = 0, i = 0, j = 0, k = 0, u = 0, v = 0, w = 0); }
// Setters taking struct types and arrays
FI void set(const XYval<T> pxy) { XY_CODE(x = pxy.x, y = pxy.y); }
FI void set(const XYval<T> pxy, const T pz) { XYZ_CODE(x = pxy.x, y = pxy.y, z = pz); }
FI void set(const XYval<T> &pxy) { XY_CODE(x = pxy.x, y = pxy.y); }
FI void set(const XYval<T> &pxy, const T pz) { XYZ_CODE(x = pxy.x, y = pxy.y, z = pz); }
FI void set(const T (&arr)[NUM_AXES]) { NUM_AXIS_CODE(x = arr[0], y = arr[1], z = arr[2], i = arr[3], j = arr[4], k = arr[5], u = arr[6], v = arr[7], w = arr[8]); }
#if LOGICAL_AXES > NUM_AXES
FI void set(const T (&arr)[LOGICAL_AXES]) { NUM_AXIS_CODE(x = arr[0], y = arr[1], z = arr[2], i = arr[3], j = arr[4], k = arr[5], u = arr[6], v = arr[7], w = arr[8]); }
@ -743,7 +743,7 @@ struct XYZval {
// Absolute difference between two objects
FI constexpr XYZval<T> diff(const XYZEval<T> &rs) const { return NUM_AXIS_ARRAY(T(_ABS(x - rs.x)), T(_ABS(y - rs.y)), T(_ABS(z - rs.z)), T(_ABS(i - rs.i)), T(_ABS(j - rs.j)), T(_ABS(k - rs.k)), T(_ABS(u - rs.u)), T(_ABS(v - rs.v)), T(_ABS(w - rs.w)) ); }
FI constexpr XYZval<T> diff(const XYZval<T> &rs) const { return NUM_AXIS_ARRAY(T(_ABS(x - rs.x)), T(_ABS(y - rs.y)), T(_ABS(z - rs.z)), T(_ABS(i - rs.i)), T(_ABS(j - rs.j)), T(_ABS(k - rs.k)), T(_ABS(u - rs.u)), T(_ABS(v - rs.v)), T(_ABS(w - rs.w)) ); }
FI constexpr XYZval<T> diff(const XYZval<T> &rs) const { return NUM_AXIS_ARRAY(T(_ABS(x - rs.x)), T(_ABS(y - rs.y)), T(_ABS(z - rs.z)), T(_ABS(i - rs.i)), T(_ABS(j - rs.j)), T(_ABS(k - rs.k)), T(_ABS(u - rs.u)), T(_ABS(v - rs.v)), T(_ABS(w - rs.w)) ); }
FI constexpr XYZval<T> diff(const XYval<T> &rs) const { return NUM_AXIS_ARRAY(T(_ABS(x - rs.x)), T(_ABS(y - rs.y)), z, i, j, k, u, v, w ); }
// Modifier operators
@ -787,17 +787,17 @@ struct XYZEval {
FI void reset() { LOGICAL_AXIS_GANG(e =, x =, y =, z =, i =, j =, k =, u =, v =, w =) 0; }
// Setters taking struct types and arrays
FI void set(const XYval<T> pxy) { XY_CODE(x = pxy.x, y = pxy.y); }
FI void set(const XYval<T> pxy, const T pz) { XYZ_CODE(x = pxy.x, y = pxy.y, z = pz); }
FI void set(const XYZval<T> pxyz) { set(NUM_AXIS_ELEM_LC(pxyz)); }
FI void set(const T (&arr)[NUM_AXES]) { NUM_AXIS_CODE(x = arr[0], y = arr[1], z = arr[2], i = arr[3], j = arr[4], k = arr[5], u = arr[6], v = arr[7], w = arr[8]); }
FI void set(const XYval<T> &pxy) { XY_CODE(x = pxy.x, y = pxy.y); }
FI void set(const XYval<T> &pxy, const T pz) { XYZ_CODE(x = pxy.x, y = pxy.y, z = pz); }
FI void set(const XYZval<T> &pxyz) { set(NUM_AXIS_ELEM_LC(pxyz)); }
FI void set(const T (&arr)[NUM_AXES]) { NUM_AXIS_CODE(x = arr[0], y = arr[1], z = arr[2], i = arr[3], j = arr[4], k = arr[5], u = arr[6], v = arr[7], w = arr[8]); }
#if LOGICAL_AXES > NUM_AXES
FI void set(const T (&arr)[LOGICAL_AXES]) { LOGICAL_AXIS_CODE(e = arr[LOGICAL_AXES-1], x = arr[0], y = arr[1], z = arr[2], i = arr[3], j = arr[4], k = arr[5], u = arr[6], v = arr[7], w = arr[8]); }
FI void set(const XYval<T> pxy, const T pz, const T pe) { set(pxy, pz); e = pe; }
FI void set(const XYZval<T> pxyz, const T pe) { set(pxyz); e = pe; }
FI void set(LOGICAL_AXIS_ARGS_LC(const T)) { LOGICAL_AXIS_CODE(_e = e, a = x, b = y, c = z, _i = i, _j = j, _k = k, _u = u, _v = v, _w = w); }
FI void set(const T (&arr)[LOGICAL_AXES]) { LOGICAL_AXIS_CODE(e = arr[LOGICAL_AXES-1], x = arr[0], y = arr[1], z = arr[2], i = arr[3], j = arr[4], k = arr[5], u = arr[6], v = arr[7], w = arr[8]); }
FI void set(const XYval<T> &pxy, const T pz, const T pe) { set(pxy, pz); e = pe; }
FI void set(const XYZval<T> &pxyz, const T pe) { set(pxyz); e = pe; }
FI void set(LOGICAL_AXIS_ARGS_LC(const T)) { LOGICAL_AXIS_CODE(_e = e, a = x, b = y, c = z, _i = i, _j = j, _k = k, _u = u, _v = v, _w = w); }
#if DISTINCT_AXES > LOGICAL_AXES
FI void set(const T (&arr)[DISTINCT_AXES]) { LOGICAL_AXIS_CODE(e = arr[LOGICAL_AXES-1], x = arr[0], y = arr[1], z = arr[2], i = arr[3], j = arr[4], k = arr[5], u = arr[6], v = arr[7], w = arr[8]); }
FI void set(const T (&arr)[DISTINCT_AXES]) { LOGICAL_AXIS_CODE(e = arr[LOGICAL_AXES-1], x = arr[0], y = arr[1], z = arr[2], i = arr[3], j = arr[4], k = arr[5], u = arr[6], v = arr[7], w = arr[8]); }
#endif
#endif
@ -933,9 +933,9 @@ struct XYZarray {
};
FI void reset() { ZERO(data); }
FI void set(const int n, const XYval<T> p) { NUM_AXIS_CODE(x[n]=p.x, y[n]=p.y,,,,,,,); }
FI void set(const int n, const XYZval<T> p) { NUM_AXIS_CODE(x[n]=p.x, y[n]=p.y, z[n]=p.z, i[n]=p.i, j[n]=p.j, k[n]=p.k, u[n]=p.u, v[n]=p.v, w[n]=p.w ); }
FI void set(const int n, const XYZEval<T> p) { NUM_AXIS_CODE(x[n]=p.x, y[n]=p.y, z[n]=p.z, i[n]=p.i, j[n]=p.j, k[n]=p.k, u[n]=p.u, v[n]=p.v, w[n]=p.w ); }
FI void set(const int n, const XYval<T> &p) { NUM_AXIS_CODE(x[n]=p.x, y[n]=p.y,,,,,,,); }
FI void set(const int n, const XYZval<T> &p) { NUM_AXIS_CODE(x[n]=p.x, y[n]=p.y, z[n]=p.z, i[n]=p.i, j[n]=p.j, k[n]=p.k, u[n]=p.u, v[n]=p.v, w[n]=p.w ); }
FI void set(const int n, const XYZEval<T> &p) { NUM_AXIS_CODE(x[n]=p.x, y[n]=p.y, z[n]=p.z, i[n]=p.i, j[n]=p.j, k[n]=p.k, u[n]=p.u, v[n]=p.v, w[n]=p.w ); }
// Setter for all individual args
FI void set(const int n OPTARGS_NUM(const T)) { NUM_AXIS_CODE(a[n] = x, b[n] = y, c[n] = z, _i[n] = i, _j[n] = j, _k[n] = k, _u[n] = u, _v[n] = v, _w[n] = w); }
@ -981,9 +981,9 @@ struct XYZEarray {
};
FI void reset() { ZERO(data); }
FI void set(const int n, const XYval<T> p) { NUM_AXIS_CODE(x[n]=p.x, y[n]=p.y,,,,,,,); }
FI void set(const int n, const XYZval<T> p) { NUM_AXIS_CODE(x[n]=p.x, y[n]=p.y, z[n]=p.z, i[n]=p.i, j[n]=p.j, k[n]=p.k, u[n]=p.u, v[n]=p.v, w[n]=p.w ); }
FI void set(const int n, const XYZEval<T> p) { LOGICAL_AXIS_CODE(e[n]=p.e, x[n]=p.x, y[n]=p.y, z[n]=p.z, i[n]=p.i, j[n]=p.j, k[n]=p.k, u[n]=p.u, v[n]=p.v, w[n]=p.w ); }
FI void set(const int n, const XYval<T> &p) { NUM_AXIS_CODE(x[n]=p.x, y[n]=p.y,,,,,,,); }
FI void set(const int n, const XYZval<T> &p) { NUM_AXIS_CODE(x[n]=p.x, y[n]=p.y, z[n]=p.z, i[n]=p.i, j[n]=p.j, k[n]=p.k, u[n]=p.u, v[n]=p.v, w[n]=p.w ); }
FI void set(const int n, const XYZEval<T> &p) { LOGICAL_AXIS_CODE(e[n]=p.e, x[n]=p.x, y[n]=p.y, z[n]=p.z, i[n]=p.i, j[n]=p.j, k[n]=p.k, u[n]=p.u, v[n]=p.v, w[n]=p.w ); }
// Setter for all individual args
FI void set(const int n OPTARGS_NUM(const T)) { NUM_AXIS_CODE(a[n] = x, b[n] = y, c[n] = z, _i[n] = i, _j[n] = j, _k[n] = k, _u[n] = u, _v[n] = v, _w[n] = w); }

1
Marlin/src/feature/fwretract.cpp
View file

@ -244,6 +244,7 @@ void FWRetract::M208_report() {
" M208 S", LINEAR_UNIT(settings.retract_recover_extra)
, " W", LINEAR_UNIT(settings.swap_retract_recover_extra)
, " F", LINEAR_UNIT(MMS_TO_MMM(settings.retract_recover_feedrate_mm_s))
, " R", LINEAR_UNIT(MMS_TO_MMM(settings.swap_retract_recover_feedrate_mm_s))
);
}

2
Marlin/src/feature/max7219.cpp
View file

@ -770,7 +770,7 @@ void Max7219::idle_tasks() {
#ifdef MAX7219_DEBUG_SLOWDOWN
static uint8_t last_slowdown_count = 0;
const uint8_t slowdown_count = Planner::slowdown_count;
const uint8_t slowdown_count = planner.slowdown_count;
if (slowdown_count != last_slowdown_count) {
mark16(MAX7219_DEBUG_SLOWDOWN, last_slowdown_count, slowdown_count, &row_change_mask);
last_slowdown_count = slowdown_count;

8
Marlin/src/feature/meatpack.cpp
View file

@ -169,9 +169,11 @@ void MeatPack::handle_command(const MeatPack_Command c) {
void MeatPack::report_state() {
// NOTE: if any configuration vars are added below, the outgoing sync text for host plugin
// should not contain the "PV' substring, as this is used to indicate protocol version
SERIAL_ECHOPGM("[MP] " MeatPack_ProtocolVersion " ");
serialprint_onoff(TEST(state, MPConfig_Bit_Active));
SERIAL_ECHO(TEST(state, MPConfig_Bit_NoSpaces) ? F(" NSP\n") : F(" ESP\n"));
SERIAL_ECHO(
F("[MP] " MeatPack_ProtocolVersion " "),
ON_OFF(TEST(state, MPConfig_Bit_Active)),
TEST(state, MPConfig_Bit_NoSpaces) ? F(" NSP\n") : F(" ESP\n")
);
}
/**

236
Marlin/src/feature/tmc_util.cpp
View file

@ -72,7 +72,7 @@
#endif
;
#if ENABLED(TMC_DEBUG)
#if HAS_TMCX1X0 || HAS_TMC220x
#if HAS_TMCX1X0_OR_2240 || HAS_TMC220x
uint8_t cs_actual;
#endif
#if HAS_STALLGUARD
@ -142,6 +142,67 @@
#endif // HAS_TMCX1X0
#if HAS_DRIVER(TMC2240)
#if ENABLED(TMC_DEBUG)
static uint32_t get_pwm_scale(TMC2240Stepper &st) { return st.PWM_SCALE(); }
#endif
static TMC_driver_data get_driver_data(TMC2240Stepper &st) {
constexpr uint8_t OT_bp = 25, OTPW_bp = 26;
constexpr uint32_t S2G_bm = 0x18000000;
#if ENABLED(TMC_DEBUG)
constexpr uint16_t SG_RESULT_bm = 0x3FF; // 0:9
constexpr uint8_t STEALTH_bp = 14;
constexpr uint32_t CS_ACTUAL_bm = 0x1F0000; // 16:20
constexpr uint8_t STALL_GUARD_bp = 24;
constexpr uint8_t STST_bp = 31;
#endif
TMC_driver_data data;
const auto ds = data.drv_status = st.DRV_STATUS();
#ifdef __AVR__
// 8-bit optimization saves up to 70 bytes of PROGMEM per axis
uint8_t spart;
#if ENABLED(TMC_DEBUG)
data.sg_result = ds & SG_RESULT_bm;
spart = ds >> 8;
data.is_stealth = TEST(spart, STEALTH_bp - 8);
spart = ds >> 16;
data.cs_actual = spart & (CS_ACTUAL_bm >> 16);
#endif
spart = ds >> 24;
data.is_ot = TEST(spart, OT_bp - 24);
data.is_otpw = TEST(spart, OTPW_bp - 24);
data.is_s2g = !!(spart & (S2G_bm >> 24));
#if ENABLED(TMC_DEBUG)
data.is_stall = TEST(spart, STALL_GUARD_bp - 24);
data.is_standstill = TEST(spart, STST_bp - 24);
data.sg_result_reasonable = !data.is_standstill; // sg_result has no reasonable meaning while standstill
#endif
#else // !__AVR__
data.is_ot = TEST(ds, OT_bp);
data.is_otpw = TEST(ds, OTPW_bp);
data.is_s2g = !!(ds & S2G_bm);
#if ENABLED(TMC_DEBUG)
constexpr uint8_t CS_ACTUAL_sb = 16;
data.sg_result = ds & SG_RESULT_bm;
data.is_stealth = TEST(ds, STEALTH_bp);
data.cs_actual = (ds & CS_ACTUAL_bm) >> CS_ACTUAL_sb;
data.is_stall = TEST(ds, STALL_GUARD_bp);
data.is_standstill = TEST(ds, STST_bp);
data.sg_result_reasonable = !data.is_standstill; // sg_result has no reasonable meaning while standstill
#endif
#endif // !__AVR__
return data;
}
#endif // TMC2240
#if HAS_TMC220x
#if ENABLED(TMC_DEBUG)
@ -237,7 +298,7 @@
st.printLabel();
SString<60> report(':', pwm_scale);
#if ENABLED(TMC_DEBUG)
#if HAS_TMCX1X0 || HAS_TMC220x
#if HAS_TMCX1X0_OR_2240 || HAS_TMC220x
report.append('/', data.cs_actual);
#endif
#if HAS_STALLGUARD
@ -465,7 +526,12 @@
TMC_HSTRT,
TMC_SGT,
TMC_MSCNT,
TMC_INTERPOLATE
TMC_INTERPOLATE,
TMC_VAIN,
TMC_VSUPPLY,
TMC_TEMP,
TMC_OVERTEMP,
TMC_OVERVOLT_THD
};
enum TMC_drv_status_enum : char {
TMC_DRV_CODES,
@ -514,14 +580,35 @@
template<class TMC>
static void print_vsense(TMC &st) { SERIAL_ECHO(st.vsense() ? F("1=.18") : F("0=.325")); }
#if HAS_DRIVER(TMC2160)
template<char AXIS_LETTER, char DRIVER_ID, AxisEnum AXIS_ID>
void print_vsense(TMCMarlin<TMC2160Stepper, AXIS_LETTER, DRIVER_ID, AXIS_ID> &) { }
#endif
#if HAS_DRIVER(TMC5160)
template<char AXIS_LETTER, char DRIVER_ID, AxisEnum AXIS_ID>
void print_vsense(TMCMarlin<TMC5160Stepper, AXIS_LETTER, DRIVER_ID, AXIS_ID> &) { }
#endif
#if HAS_DRIVER(TMC2240)
template<char AXIS_LETTER, char DRIVER_ID, AxisEnum AXIS_ID>
void print_vsense(TMCMarlin<TMC2240Stepper, AXIS_LETTER, DRIVER_ID, AXIS_ID> &) { }
#endif
template <typename TMC>
void print_cs_actual(TMC &st) { SERIAL_ECHO(st.cs_actual(), F("/31")); }
#if HAS_DRIVER(TMC2240)
template<char AXIS_LETTER, char DRIVER_ID, AxisEnum AXIS_ID>
void print_cs_actual(TMCMarlin<TMC2240Stepper, AXIS_LETTER, DRIVER_ID, AXIS_ID> &) { }
#endif
static void print_true_or_false(const bool tf) { SERIAL_ECHO(TRUE_FALSE(tf)); }
#if HAS_DRIVER(TMC2130) || HAS_DRIVER(TMC5130)
static void _tmc_status(TMC2130Stepper &st, const TMC_debug_enum i) {
switch (i) {
case TMC_PWM_SCALE: SERIAL_ECHO(st.PWM_SCALE()); break;
case TMC_SGT: SERIAL_ECHO(st.sgt()); break;
case TMC_STEALTHCHOP: serialprint_truefalse(st.en_pwm_mode()); break;
case TMC_INTERPOLATE: serialprint_truefalse(st.intpol()); break;
case TMC_STEALTHCHOP: print_true_or_false(st.en_pwm_mode()); break;
case TMC_INTERPOLATE: print_true_or_false(st.intpol()); break;
default: break;
}
}
@ -539,17 +626,11 @@
#endif
#if HAS_DRIVER(TMC2160) || HAS_DRIVER(TMC5160)
template<char AXIS_LETTER, char DRIVER_ID, AxisEnum AXIS_ID>
void print_vsense(TMCMarlin<TMC2160Stepper, AXIS_LETTER, DRIVER_ID, AXIS_ID> &) { }
template<char AXIS_LETTER, char DRIVER_ID, AxisEnum AXIS_ID>
void print_vsense(TMCMarlin<TMC5160Stepper, AXIS_LETTER, DRIVER_ID, AXIS_ID> &) { }
static void _tmc_status(TMC2160Stepper &st, const TMC_debug_enum i) {
switch (i) {
case TMC_PWM_SCALE: SERIAL_ECHO(st.PWM_SCALE()); break;
case TMC_SGT: SERIAL_ECHO(st.sgt()); break;
case TMC_STEALTHCHOP: serialprint_truefalse(st.en_pwm_mode()); break;
case TMC_STEALTHCHOP: print_true_or_false(st.en_pwm_mode()); break;
case TMC_GLOBAL_SCALER:
{
const uint16_t value = st.GLOBAL_SCALER();
@ -557,7 +638,7 @@
SERIAL_ECHOPGM("/256");
}
break;
case TMC_INTERPOLATE: serialprint_truefalse(st.intpol()); break;
case TMC_INTERPOLATE: print_true_or_false(st.intpol()); break;
default: break;
}
}
@ -571,8 +652,8 @@
case TMC_PWM_SCALE_AUTO: SERIAL_ECHO(st.pwm_scale_auto()); break;
case TMC_PWM_OFS_AUTO: SERIAL_ECHO(st.pwm_ofs_auto()); break;
case TMC_PWM_GRAD_AUTO: SERIAL_ECHO(st.pwm_grad_auto()); break;
case TMC_STEALTHCHOP: serialprint_truefalse(st.stealth()); break;
case TMC_INTERPOLATE: serialprint_truefalse(st.intpol()); break;
case TMC_STEALTHCHOP: print_true_or_false(st.stealth()); break;
case TMC_INTERPOLATE: print_true_or_false(st.intpol()); break;
default: break;
}
}
@ -615,22 +696,57 @@
#endif // HAS_TMC220x
#if HAS_DRIVER(TMC2240)
static void _tmc_parse_drv_status(TMC2240Stepper, const TMC_drv_status_enum) { }
static void _tmc_status(TMC2240Stepper &st, const TMC_debug_enum i) {
switch (i) {
case TMC_PWM_SCALE_SUM: SERIAL_ECHO(st.pwm_scale_sum()); break;
case TMC_PWM_SCALE_AUTO: SERIAL_ECHO(st.pwm_scale_auto()); break;
case TMC_PWM_OFS_AUTO: SERIAL_ECHO(st.pwm_ofs_auto()); break;
case TMC_PWM_GRAD_AUTO: SERIAL_ECHO(st.pwm_grad_auto()); break;
case TMC_STEALTHCHOP: print_true_or_false(st.stealth()); break;
case TMC_INTERPOLATE: print_true_or_false(st.intpol()); break;
case TMC_VAIN: SERIAL_ECHO(st.get_ain_voltage()); break;
case TMC_VSUPPLY: SERIAL_ECHO(st.get_vsupply_voltage()); break;
case TMC_TEMP: SERIAL_ECHO(st.get_chip_temperature()); break;
case TMC_OVERTEMP: SERIAL_ECHO(st.get_overtemp_prewarn_celsius()); break;
case TMC_OVERVOLT_THD: SERIAL_ECHO(st.get_overvoltage_threshold_voltage()); break;
default: break;
}
}
#endif
#if HAS_DRIVER(TMC2660)
static void _tmc_parse_drv_status(TMC2660Stepper, const TMC_drv_status_enum) { }
static void _tmc_status(TMC2660Stepper &st, const TMC_debug_enum i) {
switch (i) {
case TMC_INTERPOLATE: serialprint_truefalse(st.intpol()); break;
case TMC_INTERPOLATE: print_true_or_false(st.intpol()); break;
default: break;
}
}
#endif
template <typename TMC>
void print_tstep(TMC &st) {
const uint32_t tstep_value = st.TSTEP();
if (tstep_value != 0xFFFFF)
SERIAL_ECHO(tstep_value);
else
SERIAL_ECHOPGM("max");
}
void print_tstep(TMC2660Stepper &st) { }
template <typename TMC>
void print_blank_time(TMC &st) { SERIAL_ECHO(st.blank_time()); }
template<char AXIS_LETTER, char DRIVER_ID, AxisEnum AXIS_ID>
void print_blank_time(TMCMarlin<TMC2240Stepper, AXIS_LETTER, DRIVER_ID, AXIS_ID> &) { }
template <typename TMC>
static void tmc_status(TMC &st, const TMC_debug_enum i) {
SERIAL_CHAR('\t');
switch (i) {
case TMC_CODES: st.printLabel(); break;
case TMC_ENABLED: serialprint_truefalse(st.isEnabled()); break;
case TMC_ENABLED: print_true_or_false(st.isEnabled()); break;
case TMC_CURRENT: SERIAL_ECHO(st.getMilliamps()); break;
case TMC_RMS_CURRENT: SERIAL_ECHO(st.rms_current()); break;
case TMC_MAX_CURRENT: SERIAL_ECHO(p_float_t(st.rms_current() * 1.41, 0)); break;
@ -642,16 +758,10 @@
SERIAL_ECHO(st.ihold());
SERIAL_ECHOPGM("/31");
break;
case TMC_CS_ACTUAL:
SERIAL_ECHO(st.cs_actual());
SERIAL_ECHOPGM("/31");
break;
case TMC_CS_ACTUAL: print_cs_actual(st); break;
case TMC_VSENSE: print_vsense(st); break;
case TMC_MICROSTEPS: SERIAL_ECHO(st.microsteps()); break;
case TMC_TSTEP: {
const uint32_t tstep_value = st.TSTEP();
if (tstep_value != 0xFFFFF) SERIAL_ECHO(tstep_value); else SERIAL_ECHOPGM("max");
} break;
case TMC_TSTEP: print_tstep(st); break;
#if ENABLED(HYBRID_THRESHOLD)
case TMC_TPWMTHRS: SERIAL_ECHO(uint32_t(st.TPWMTHRS())); break;
case TMC_TPWMTHRS_MMS: {
@ -659,12 +769,12 @@
if (tpwmthrs_val) SERIAL_ECHO(tpwmthrs_val); else SERIAL_CHAR('-');
} break;
#endif
case TMC_OTPW: serialprint_truefalse(st.otpw()); break;
case TMC_OTPW: print_true_or_false(st.otpw()); break;
#if ENABLED(MONITOR_DRIVER_STATUS)
case TMC_OTPW_TRIGGERED: serialprint_truefalse(st.getOTPW()); break;
case TMC_OTPW_TRIGGERED: print_true_or_false(st.getOTPW()); break;
#endif
case TMC_TOFF: SERIAL_ECHO(st.toff()); break;
case TMC_TBL: SERIAL_ECHO(st.blank_time()); break;
case TMC_TBL: print_blank_time(st); break;
case TMC_HEND: SERIAL_ECHO(st.hysteresis_end()); break;
case TMC_HSTRT: SERIAL_ECHO(st.hysteresis_start()); break;
case TMC_MSCNT: SERIAL_ECHO(st.get_microstep_counter()); break;
@ -678,7 +788,7 @@
SERIAL_CHAR('\t');
switch (i) {
case TMC_CODES: st.printLabel(); break;
case TMC_ENABLED: serialprint_truefalse(st.isEnabled()); break;
case TMC_ENABLED: print_true_or_false(st.isEnabled()); break;
case TMC_CURRENT: SERIAL_ECHO(st.getMilliamps()); break;
case TMC_RMS_CURRENT: SERIAL_ECHO(st.rms_current()); break;
case TMC_MAX_CURRENT: SERIAL_ECHO(p_float_t(st.rms_current() * 1.41, 0)); break;
@ -688,14 +798,14 @@
break;
case TMC_VSENSE: SERIAL_ECHO(st.vsense() ? F("1=.165") : F("0=.310")); break;
case TMC_MICROSTEPS: SERIAL_ECHO(st.microsteps()); break;
//case TMC_OTPW: serialprint_truefalse(st.otpw()); break;
//case TMC_OTPW_TRIGGERED: serialprint_truefalse(st.getOTPW()); break;
//case TMC_OTPW: print_true_or_false(st.otpw()); break;
//case TMC_OTPW_TRIGGERED: print_true_or_false(st.getOTPW()); break;
case TMC_SGT: SERIAL_ECHO(st.sgt()); break;
case TMC_TOFF: SERIAL_ECHO(st.toff()); break;
case TMC_TBL: SERIAL_ECHO(st.blank_time()); break;
case TMC_TBL: print_blank_time(st); break;
case TMC_HEND: SERIAL_ECHO(st.hysteresis_end()); break;
case TMC_HSTRT: SERIAL_ECHO(st.hysteresis_start()); break;
default: break;
default: _tmc_status(st, i); break;
}
}
#endif
@ -855,10 +965,10 @@
TMC_REPORT("Stallguard thrs", TMC_SGT);
TMC_REPORT("uStep count", TMC_MSCNT);
DRV_REPORT("DRVSTATUS", TMC_DRV_CODES);
#if HAS_TMCX1X0 || HAS_TMC220x
#if HAS_TMCX1X0_OR_2240 || HAS_TMC220x
DRV_REPORT("sg_result", TMC_SG_RESULT);
#endif
#if HAS_TMCX1X0
#if HAS_TMCX1X0_OR_2240
DRV_REPORT("stallguard", TMC_STALLGUARD);
DRV_REPORT("fsactive", TMC_FSACTIVE);
#endif
@ -878,26 +988,34 @@
DRV_REPORT("s2vsb\t", TMC_S2VSB);
#endif
DRV_REPORT("Driver registers:\n",TMC_DRV_STATUS_HEX);
#if HAS_DRIVER(TMC2240)
TMC_REPORT("Analog in (v)", TMC_VAIN);
TMC_REPORT("Supply (v)", TMC_VSUPPLY);
TMC_REPORT("Temp (°C)", TMC_TEMP);
TMC_REPORT("OT pre warn (°C)", TMC_OVERTEMP);
TMC_REPORT("OV theshold (v)", TMC_OVERVOLT_THD);
#endif
SERIAL_EOL();
}
#define PRINT_TMC_REGISTER(REG_CASE) case TMC_GET_##REG_CASE: print_hex_long(st.REG_CASE(), ':'); break
#if HAS_TMCX1X0
static void tmc_get_ic_registers(TMC2130Stepper &st, const TMC_get_registers_enum i) {
switch (i) {
PRINT_TMC_REGISTER(TCOOLTHRS);
PRINT_TMC_REGISTER(THIGH);
PRINT_TMC_REGISTER(COOLCONF);
default: SERIAL_CHAR('\t'); break;
}
}
#endif
#if HAS_TMC220x
static void tmc_get_ic_registers(TMC2208Stepper, const TMC_get_registers_enum) { SERIAL_CHAR('\t'); }
#endif
#if HAS_TRINAMIC_CONFIG
template<class TMC>
static void tmc_get_ic_registers(TMC &, const TMC_get_registers_enum) { SERIAL_CHAR('\t'); }
#if HAS_TMCX1X0
static void tmc_get_ic_registers(TMC2130Stepper &st, const TMC_get_registers_enum i) {
switch (i) {
PRINT_TMC_REGISTER(TCOOLTHRS);
PRINT_TMC_REGISTER(THIGH);
PRINT_TMC_REGISTER(COOLCONF);
default: SERIAL_CHAR('\t'); break;
}
}
#endif
template<class TMC>
static void tmc_get_registers(TMC &st, const TMC_get_registers_enum i) {
switch (i) {
@ -917,7 +1035,8 @@
}
SERIAL_CHAR('\t');
}
#endif
#endif // HAS_TRINAMIC_CONFIG
#if HAS_DRIVER(TMC2660)
template <char AXIS_LETTER, char DRIVER_ID, AxisEnum AXIS_ID>
static void tmc_get_registers(TMCMarlin<TMC2660Stepper, AXIS_LETTER, DRIVER_ID, AXIS_ID> &st, const TMC_get_registers_enum i) {
@ -1025,11 +1144,26 @@
st.TCOOLTHRS(0);
}
bool tmc_enable_stallguard(TMC2240Stepper &st) {
const bool stealthchop_was_enabled = st.en_pwm_mode();
st.TCOOLTHRS(0xFFFFF);
st.en_pwm_mode(false);
st.diag0_stall(true);
return stealthchop_was_enabled;
}
void tmc_disable_stallguard(TMC2240Stepper &st, const bool restore_stealth) {
st.TCOOLTHRS(0);
st.en_pwm_mode(restore_stealth);
st.diag0_stall(false);
}
bool tmc_enable_stallguard(TMC2660Stepper) {
// TODO
return false;
}
void tmc_disable_stallguard(TMC2660Stepper, const bool) {};
void tmc_disable_stallguard(TMC2660Stepper, const bool) { }
#endif // USE_SENSORLESS

80
Marlin/src/feature/tmc_util.h
View file

@ -95,7 +95,7 @@ class TMCMarlin : public TMC, public TMCStorage<AXIS_LETTER, DRIVER_ID> {
TMC(CS, RS, pinMOSI, pinMISO, pinSCK)
{}
TMCMarlin(const uint16_t CS, const float RS, const uint16_t pinMOSI, const uint16_t pinMISO, const uint16_t pinSCK, const uint8_t axis_chain_index) :
TMC(CS, RS, pinMOSI, pinMISO, pinSCK, axis_chain_index)
TMC(CS, RS, pinMOSI, pinMISO, pinSCK, axis_chain_index)
{}
uint16_t rms_current() { return TMC::rms_current(); }
void rms_current(uint16_t mA) {
@ -124,7 +124,7 @@ class TMCMarlin : public TMC, public TMCStorage<AXIS_LETTER, DRIVER_ID> {
#if ENABLED(HYBRID_THRESHOLD)
uint32_t get_pwm_thrs() {
return _tmc_thrs(this->microsteps(), this->TPWMTHRS(), planner.settings.axis_steps_per_mm[AXIS_ID]);
return _tmc_thrs(this->microsteps(), TMC::TPWMTHRS(), planner.settings.axis_steps_per_mm[AXIS_ID]);
}
void set_pwm_thrs(const uint32_t thrs) {
TMC::TPWMTHRS(_tmc_thrs(this->microsteps(), thrs, planner.settings.axis_steps_per_mm[AXIS_ID]));
@ -197,7 +197,7 @@ class TMCMarlin<TMC2208Stepper, AXIS_LETTER, DRIVER_ID, AXIS_ID> : public TMC220
#if ENABLED(HYBRID_THRESHOLD)
uint32_t get_pwm_thrs() {
return _tmc_thrs(this->microsteps(), this->TPWMTHRS(), planner.settings.axis_steps_per_mm[AXIS_ID]);
return _tmc_thrs(this->microsteps(), TMC2208Stepper::TPWMTHRS(), planner.settings.axis_steps_per_mm[AXIS_ID]);
}
void set_pwm_thrs(const uint32_t thrs) {
TMC2208Stepper::TPWMTHRS(_tmc_thrs(this->microsteps(), thrs, planner.settings.axis_steps_per_mm[AXIS_ID]));
@ -249,13 +249,14 @@ class TMCMarlin<TMC2209Stepper, AXIS_LETTER, DRIVER_ID, AXIS_ID> : public TMC220
#if ENABLED(HYBRID_THRESHOLD)
uint32_t get_pwm_thrs() {
return _tmc_thrs(this->microsteps(), this->TPWMTHRS(), planner.settings.axis_steps_per_mm[AXIS_ID]);
return _tmc_thrs(this->microsteps(), TMC2209Stepper::TPWMTHRS(), planner.settings.axis_steps_per_mm[AXIS_ID]);
}
void set_pwm_thrs(const uint32_t thrs) {
TMC2209Stepper::TPWMTHRS(_tmc_thrs(this->microsteps(), thrs, planner.settings.axis_steps_per_mm[AXIS_ID]));
TERN_(HAS_MARLINUI_MENU, this->stored.hybrid_thrs = thrs);
}
#endif
#if USE_SENSORLESS
int16_t homing_threshold() { return TMC2209Stepper::SGTHRS(); }
void homing_threshold(int16_t sgt_val) {
@ -278,6 +279,74 @@ class TMCMarlin<TMC2209Stepper, AXIS_LETTER, DRIVER_ID, AXIS_ID> : public TMC220
sgt_max = 255;
};
template<char AXIS_LETTER, char DRIVER_ID, AxisEnum AXIS_ID>
class TMCMarlin<TMC2240Stepper, AXIS_LETTER, DRIVER_ID, AXIS_ID> : public TMC2240Stepper, public TMCStorage<AXIS_LETTER, DRIVER_ID> {
public:
TMCMarlin(const uint16_t cs_pin, const uint8_t axis_chain_index) :
TMC2240Stepper(cs_pin, axis_chain_index)
{}
TMCMarlin(const uint16_t CS, const uint16_t pinMOSI, const uint16_t pinMISO, const uint16_t pinSCK, const uint8_t axis_chain_index) :
TMC2240Stepper(CS, pinMOSI, pinMISO, pinSCK, axis_chain_index )
{}
//uint8_t get_address() { return slave_address; }
uint16_t get_microstep_counter() { return microsteps(); }
uint16_t rms_current() { return TMC2240Stepper::rms_current(); }
void rms_current(const uint16_t mA) {
this->val_mA = mA;
TMC2240Stepper::rms_current(mA);
}
void rms_current(const uint16_t mA, const float mult) {
this->val_mA = mA;
TMC2240Stepper::rms_current(mA, mult);
}
#if HAS_STEALTHCHOP
bool get_stealthChop() { return this->en_pwm_mode(); }
bool get_stored_stealthChop() { return this->stored.stealthChop_enabled; }
void refresh_stepping_mode() { this->en_pwm_mode(this->stored.stealthChop_enabled); }
void set_stealthChop(const bool stch) { this->stored.stealthChop_enabled = stch; refresh_stepping_mode(); }
bool toggle_stepping_mode() { set_stealthChop(!this->stored.stealthChop_enabled); return get_stealthChop(); }
#endif
void set_chopper_times(const chopper_timing_t &ct) {
TMC2240Stepper::toff(ct.toff);
TMC2240Stepper::hysteresis_end(ct.hend);
TMC2240Stepper::hysteresis_start(ct.hstrt);
}
#if ENABLED(HYBRID_THRESHOLD)
uint32_t get_pwm_thrs() {
return _tmc_thrs(this->microsteps(), TMC2240Stepper::TPWMTHRS(), planner.settings.axis_steps_per_mm[AXIS_ID]);
}
void set_pwm_thrs(const uint32_t thrs) {
TMC2240Stepper::TPWMTHRS(_tmc_thrs(this->microsteps(), thrs, planner.settings.axis_steps_per_mm[AXIS_ID]));
TERN_(HAS_MARLINUI_MENU, this->stored.hybrid_thrs = thrs);
}
#endif
#if USE_SENSORLESS
int16_t homing_threshold() { return TMC2240Stepper::sgt(); }
void homing_threshold(int16_t sgt_val) {
sgt_val = (int16_t)constrain(sgt_val, sgt_min, sgt_max);
TMC2240Stepper::sgt(sgt_val);
TERN_(HAS_MARLINUI_MENU, this->stored.homing_thrs = sgt_val);
}
#endif
void refresh_stepper_current() { rms_current(this->val_mA); }
#if ENABLED(HYBRID_THRESHOLD)
void refresh_hybrid_thrs() { set_pwm_thrs(this->stored.hybrid_thrs); }
#endif
#if USE_SENSORLESS
void refresh_homing_thrs() { homing_threshold(this->stored.homing_thrs); }
#endif
static constexpr int8_t sgt_min = -64,
sgt_max = 63;
};
template<char AXIS_LETTER, char DRIVER_ID, AxisEnum AXIS_ID>
class TMCMarlin<TMC2660Stepper, AXIS_LETTER, DRIVER_ID, AXIS_ID> : public TMC2660Stepper, public TMCStorage<AXIS_LETTER, DRIVER_ID> {
public:
@ -353,6 +422,9 @@ void test_tmc_connection(LOGICAL_AXIS_DECL_LC(const bool, true));
bool tmc_enable_stallguard(TMC2209Stepper &st);
void tmc_disable_stallguard(TMC2209Stepper &st, const bool restore_stealth);
bool tmc_enable_stallguard(TMC2240Stepper &st);
void tmc_disable_stallguard(TMC2240Stepper &st, const bool restore_stealth);
bool tmc_enable_stallguard(TMC2660Stepper);
void tmc_disable_stallguard(TMC2660Stepper, const bool);

6
Marlin/src/gcode/bedlevel/G26.cpp
View file

@ -268,8 +268,10 @@ typedef struct {
// If the end point of the line is closer to the nozzle, flip the direction,
// moving from the end to the start. On very small lines the optimization isn't worth it.
if (dist_end < dist_start && (INTERSECTION_CIRCLE_RADIUS) < ABS(line_length))
return print_line_from_here_to_there(e, s);
if (dist_end < dist_start && (INTERSECTION_CIRCLE_RADIUS) < ABS(line_length)) {
print_line_from_here_to_there(e, s);
return;
}
// Decide whether to retract & lift
if (dist_start > 2.0) retract_lift_move(s);

9
Marlin/src/gcode/bedlevel/M420.cpp
View file

@ -228,9 +228,7 @@ void GcodeSuite::M420() {
if (to_enable && !planner.leveling_active)
SERIAL_ERROR_MSG(STR_ERR_M420_FAILED);
SERIAL_ECHO_START();
SERIAL_ECHOPGM("Bed Leveling ");
serialprintln_onoff(planner.leveling_active);
SERIAL_ECHO_MSG("Bed Leveling ", ON_OFF(planner.leveling_active));
#if ENABLED(ENABLE_LEVELING_FADE_HEIGHT)
SERIAL_ECHO_START();
@ -252,14 +250,13 @@ void GcodeSuite::M420_report(const bool forReplay/*=true*/) {
report_heading_etc(forReplay, F(
TERN(MESH_BED_LEVELING, "Mesh Bed Leveling", TERN(AUTO_BED_LEVELING_UBL, "Unified Bed Leveling", "Auto Bed Leveling"))
));
SERIAL_ECHO(
SERIAL_ECHOLN(
F(" M420 S"), planner.leveling_active
#if ENABLED(ENABLE_LEVELING_FADE_HEIGHT)
, FPSTR(SP_Z_STR), LINEAR_UNIT(planner.z_fade_height)
#endif
, F(" ; Leveling ")
, F(" ; Leveling "), ON_OFF(planner.leveling_active)
);
serialprintln_onoff(planner.leveling_active);
}
#endif // HAS_LEVELING

2
Marlin/src/gcode/bedlevel/mbl/G29.cpp
View file

@ -99,7 +99,7 @@ void GcodeSuite::G29() {
case MeshReport:
SERIAL_ECHOPGM("Mesh Bed Leveling ");
if (leveling_is_valid()) {
serialprintln_onoff(planner.leveling_active);
SERIAL_ECHOLN(ON_OFF(planner.leveling_active));
bedlevel.report_mesh();
}
else

3
Marlin/src/gcode/calibrate/G28.cpp
View file

@ -300,7 +300,8 @@ void GcodeSuite::G28() {
#endif
// PARKING_EXTRUDER homing requires different handling of movement / solenoid activation, depending on the side of homing
#if ENABLED(PARKING_EXTRUDER)
const bool pe_final_change_must_unpark = parking_extruder_unpark_after_homing(old_tool_index, X_HOME_DIR + 1 == old_tool_index * 2);
const bool homed_towards_tool = old_tool_index == TERN(X_HOME_TO_MIN, 0, 1),
pe_final_change_must_unpark = parking_extruder_unpark_after_homing(old_tool_index, homed_towards_tool);
#endif
tool_change(0, true);
#endif

4
Marlin/src/gcode/calibrate/G33.cpp
View file

@ -598,7 +598,7 @@ void GcodeSuite::G33() {
LOOP_NUM_AXES(axis) delta_tower_angle_trim[axis] -= a_sum / 3.0f;
}
// adjust delta_height and endstops by the max amount
// Adjust delta_height and endstops by the max amount
const float z_temp = _MAX(delta_endstop_adj.a, delta_endstop_adj.b, delta_endstop_adj.c);
delta_height -= z_temp;
LOOP_NUM_AXES(axis) delta_endstop_adj[axis] -= z_temp;
@ -606,7 +606,7 @@ void GcodeSuite::G33() {
recalc_delta_settings();
NOMORE(zero_std_dev_min, zero_std_dev);
// print report
// Print report
if (verbose_level == 3 || verbose_level == 0) {
print_calibration_results(z_at_pt, _tower_results, _opposite_results);

29
Marlin/src/gcode/config/M200-M205.cpp
View file

@ -124,8 +124,13 @@
* S<percent> : Speed factor percentage.
*/
void GcodeSuite::M201() {
if (!parser.seen("T" STR_AXES_LOGICAL TERN_(XY_FREQUENCY_LIMIT, "FS")))
if (!parser.seen("T" STR_AXES_LOGICAL
#ifdef XY_FREQUENCY_LIMIT
"FS"
#endif
)) {
return M201_report();
}
const int8_t target_extruder = get_target_extruder_from_command();
if (target_extruder < 0) return;
@ -147,7 +152,11 @@ void GcodeSuite::M201_report(const bool forReplay/*=true*/) {
TERN_(MARLIN_SMALL_BUILD, return);
report_heading_etc(forReplay, F(STR_MAX_ACCELERATION));
bool eol = false;
#if NUM_AXES
eol = true;
SERIAL_ECHOPGM_P(
LIST_N(DOUBLE(NUM_AXES),
PSTR(" M201 X"), LINEAR_UNIT(planner.settings.max_acceleration_mm_per_s2[X_AXIS]),
@ -164,13 +173,18 @@ void GcodeSuite::M201_report(const bool forReplay/*=true*/) {
#endif
#if HAS_EXTRUDERS && DISABLED(DISTINCT_E_FACTORS)
eol = true;
SERIAL_ECHOPGM_P(SP_E_STR, VOLUMETRIC_UNIT(planner.settings.max_acceleration_mm_per_s2[E_AXIS]));
#endif
#if NUM_AXES || (HAS_EXTRUDERS && DISABLED(DISTINCT_E_FACTORS))
SERIAL_EOL();
#ifdef XY_FREQUENCY_LIMIT
eol = true;
SERIAL_ECHOPGM_P(PSTR(" F"), planner.xy_freq_limit_hz);
SERIAL_ECHOPGM_P(PSTR(" S"), (planner.xy_freq_min_speed_factor * 100));
#endif
if (eol) SERIAL_EOL();
#if ENABLED(DISTINCT_E_FACTORS)
for (uint8_t i = 0; i < E_STEPPERS; ++i) {
report_echo_start(forReplay);
@ -205,7 +219,11 @@ void GcodeSuite::M203_report(const bool forReplay/*=true*/) {
TERN_(MARLIN_SMALL_BUILD, return);
report_heading_etc(forReplay, F(STR_MAX_FEEDRATES));
bool eol = false;
#if NUM_AXES
eol = true;
SERIAL_ECHOPGM_P(
LIST_N(DOUBLE(NUM_AXES),
PSTR(" M203 X"), LINEAR_UNIT(planner.settings.max_feedrate_mm_s[X_AXIS]),
@ -222,12 +240,11 @@ void GcodeSuite::M203_report(const bool forReplay/*=true*/) {
#endif
#if HAS_EXTRUDERS && DISABLED(DISTINCT_E_FACTORS)
eol = true;
SERIAL_ECHOPGM_P(SP_E_STR, VOLUMETRIC_UNIT(planner.settings.max_feedrate_mm_s[E_AXIS]));
#endif
#if NUM_AXES || (HAS_EXTRUDERS && DISABLED(DISTINCT_E_FACTORS))
SERIAL_EOL();
#endif
if (eol) SERIAL_EOL();
#if ENABLED(DISTINCT_E_FACTORS)
for (uint8_t i = 0; i < E_STEPPERS; ++i) {

3
Marlin/src/gcode/control/M211.cpp
View file

@ -43,8 +43,7 @@ void GcodeSuite::M211_report(const bool forReplay/*=true*/) {
TERN_(MARLIN_SMALL_BUILD, return);
report_heading_etc(forReplay, F(STR_SOFT_ENDSTOPS));
SERIAL_ECHOPGM(" M211 S", AS_DIGIT(soft_endstop._enabled), " ; ");
serialprintln_onoff(soft_endstop._enabled);
SERIAL_ECHOLNPGM(" M211 S", AS_DIGIT(soft_endstop._enabled), " ; ", ON_OFF(soft_endstop._enabled));
report_echo_start(forReplay);
const xyz_pos_t l_soft_min = soft_endstop.min.asLogical(),

3
Marlin/src/gcode/control/M605.cpp
View file

@ -173,8 +173,7 @@
set_duplication_enabled(ena && (duplication_e_mask >= 3));
}
SERIAL_ECHO_START();
SERIAL_ECHOPGM(STR_DUPLICATION_MODE);
serialprint_onoff(extruder_duplication_enabled);
SERIAL_ECHOPGM(STR_DUPLICATION_MODE, ON_OFF(extruder_duplication_enabled));
if (ena) {
SERIAL_ECHOPGM(" ( ");
HOTEND_LOOP() if (TEST(duplication_e_mask, e)) { SERIAL_ECHO(e); SERIAL_CHAR(' '); }

74
Marlin/src/gcode/feature/advance/M900.cpp
View file

@ -29,16 +29,18 @@
#include "../../../module/stepper.h"
#if ENABLED(ADVANCE_K_EXTRA)
float other_extruder_advance_K[DISTINCT_E];
float other_extruder_advance_K[EXTRUDERS];
uint8_t lin_adv_slot = 0;
#endif
/**
* M900: Get or Set Linear Advance K-factor
* T<tool> Which tool to address
* K<factor> Set current advance K factor (Slot 0).
* L<factor> Set secondary advance K factor (Slot 1). Requires ADVANCE_K_EXTRA.
* S<0/1> Activate slot 0 or 1. Requires ADVANCE_K_EXTRA.
* K<factor> Set current advance K factor (aka Slot 0).
*
* With ADVANCE_K_EXTRA:
* S<0/1> Activate slot 0 or 1.
* L<factor> Set secondary advance K factor (Slot 1).
*/
void GcodeSuite::M900() {
@ -60,43 +62,43 @@ void GcodeSuite::M900() {
}
#endif
float &kref = planner.extruder_advance_K[E_INDEX_N(tool_index)], newK = kref;
const float oldK = newK;
const float oldK = planner.get_advance_k(tool_index);
float newK = oldK;
#if ENABLED(SMOOTH_LIN_ADVANCE)
const float oldU = stepper.get_advance_tau(E_INDEX_N(tool_index));
const float oldU = stepper.get_advance_tau(tool_index);
float newU = oldU;
#endif
#if ENABLED(ADVANCE_K_EXTRA)
float &lref = other_extruder_advance_K[E_INDEX_N(tool_index)];
float &lref = other_extruder_advance_K[tool_index];
const bool old_slot = TEST(lin_adv_slot, tool_index), // The tool's current slot (0 or 1)
new_slot = parser.boolval('S', old_slot); // The passed slot (default = current)
const bool old_slot = TEST(lin_adv_slot, tool_index), // Each tool uses 1 bit to store its current slot (0 or 1)
new_slot = parser.boolval('S', old_slot); // The new slot (0 or 1) to set for the tool (default = no change)
// If a new slot is being selected swap the current and
// saved K values. Do here so K/L will apply correctly.
if (new_slot != old_slot) { // Not the same slot?
SET_BIT_TO(lin_adv_slot, tool_index, new_slot); // Update the slot for the tool
newK = lref; // Get new K value from backup
lref = oldK; // Save K to backup
newK = lref; // Get the backup K value (to apply below)
lref = oldK; // Back up the active K value
}
// Set the main K value. Apply if the main slot is active.
if (parser.seenval('K')) {
const float K = parser.value_float();
if (!WITHIN(K, 0, 10)) echo_value_oor('K');
else if (new_slot) lref = K; // S1 Knn
else newK = K; // S0 Knn
else if (new_slot) lref = K; // S1 Knn (set main K in its backup slot)
else newK = K; // S0 Knn (use main K now)
}
// Set the extra K value. Apply if the extra slot is active.
if (parser.seenval('L')) {
const float L = parser.value_float();
if (!WITHIN(L, 0, 10)) echo_value_oor('L');
else if (!new_slot) lref = L; // S0 Lnn
else newK = L; // S1 Lnn
else if (!new_slot) lref = L; // S0 Lnn (set extra K in its backup slot)
else newK = L; // S1 Lnn (use extra K now)
}
#else
@ -123,9 +125,9 @@ void GcodeSuite::M900() {
if (newK != oldK || TERN0(SMOOTH_LIN_ADVANCE, newU != oldU)) {
planner.synchronize();
if (newK != oldK) kref = newK;
if (newK != oldK) planner.set_advance_k(newK, tool_index);
#if ENABLED(SMOOTH_LIN_ADVANCE)
if (newU != oldU) stepper.set_advance_tau(newU);
if (newU != oldU) stepper.set_advance_tau(newU, tool_index);
#endif
}
@ -133,12 +135,12 @@ void GcodeSuite::M900() {
#if ENABLED(ADVANCE_K_EXTRA)
#if DISTINCT_E < 2
SERIAL_ECHOLNPGM("Advance S", new_slot, " K", kref, "(S", !new_slot, " K", lref, ")");
#if DISABLED(DISTINCT_E_FACTORS)
SERIAL_ECHOLNPGM("Advance S", new_slot, " K", newK, "(S", !new_slot, " K", lref, ")");
#else
EXTRUDER_LOOP() {
const bool slot = TEST(lin_adv_slot, e);
SERIAL_ECHOLNPGM("Advance T", e, " S", slot, " K", planner.extruder_advance_K[e],
SERIAL_ECHOLNPGM("Advance T", e, " S", slot, " K", planner.get_advance_k(e),
"(S", !slot, " K", other_extruder_advance_K[e], ")");
}
#endif
@ -146,15 +148,15 @@ void GcodeSuite::M900() {
#else // !ADVANCE_K_EXTRA
SERIAL_ECHO_START();
#if DISTINCT_E < 2
SERIAL_ECHOPGM("Advance K=", planner.extruder_advance_K[0]);
#if DISABLED(DISTINCT_E_FACTORS)
SERIAL_ECHOPGM("Advance K=", planner.get_advance_k());
#if ENABLED(SMOOTH_LIN_ADVANCE)
SERIAL_ECHOPGM(" TAU=", stepper.get_advance_tau());
#endif
SERIAL_EOL();
#else
SERIAL_ECHOPGM("Advance K");
EXTRUDER_LOOP() SERIAL_ECHO(C(' '), C('0' + e), C(':'), planner.extruder_advance_K[e]);
EXTRUDER_LOOP() SERIAL_ECHO(C(' '), C('0' + e), C(':'), planner.get_advance_k(e));
SERIAL_EOL();
#if ENABLED(SMOOTH_LIN_ADVANCE)
SERIAL_ECHOPGM("Advance TAU");
@ -172,23 +174,21 @@ void GcodeSuite::M900_report(const bool forReplay/*=true*/) {
TERN_(MARLIN_SMALL_BUILD, return);
report_heading(forReplay, F(STR_LINEAR_ADVANCE));
#if DISTINCT_E < 2
DISTINCT_E_LOOP() {
report_echo_start(forReplay);
SERIAL_ECHOPGM(" M900 K", planner.extruder_advance_K[0]);
SERIAL_ECHOPGM(
#if ENABLED(DISTINCT_E_FACTORS)
" M900 T", e, " K"
#else
" M900 K"
#endif
);
SERIAL_ECHO(planner.get_advance_k(e));
#if ENABLED(SMOOTH_LIN_ADVANCE)
SERIAL_ECHOPGM(" M900 U", stepper.get_advance_tau());
SERIAL_ECHOPGM(" U", stepper.get_advance_tau(e));
#endif
SERIAL_EOL();
#else
EXTRUDER_LOOP() {
report_echo_start(forReplay);
SERIAL_ECHOPGM(" M900 T", e, " K", planner.extruder_advance_K[e]);
#if ENABLED(SMOOTH_LIN_ADVANCE)
SERIAL_ECHOPGM(" U", stepper.get_advance_tau(e));
#endif
SERIAL_EOL();
}
#endif
}
}
#endif // LIN_ADVANCE

3
Marlin/src/gcode/feature/mixing/M166.cpp
View file

@ -68,8 +68,7 @@ void GcodeSuite::M166() {
mixer.refresh_gradient();
SERIAL_ECHOPGM("Gradient Mix ");
serialprint_onoff(mixer.gradient.enabled);
SERIAL_ECHOPGM("Gradient Mix ", ON_OFF(mixer.gradient.enabled));
if (mixer.gradient.enabled) {
#if ENABLED(GRADIENT_VTOOL)

20
Marlin/src/gcode/feature/nonlinear/M592.cpp
View file

@ -30,11 +30,13 @@
void GcodeSuite::M592_report(const bool forReplay/*=true*/) {
TERN_(MARLIN_SMALL_BUILD, return);
report_heading_etc(forReplay, F(STR_NONLINEAR_EXTRUSION));
SERIAL_ECHOLNPGM(" M592 A", stepper.ne.A, " B", stepper.ne.B, " C", stepper.ne.C);
const nonlinear_settings_t &sns = stepper.ne.settings;
SERIAL_ECHOLNPGM(" M592 S", sns.enabled, " A", sns.coeff.A, " B", sns.coeff.B, " C", sns.coeff.C);
}
/**
* M592: Get or set nonlinear extrusion parameters
* S<flag> Enable / Disable Nonlinear Extrusion
* A<factor> Quadratic coefficient (default 0.0)
* B<factor> Linear coefficient (default 0.0)
* C<factor> Constant coefficient (default 1.0)
@ -46,9 +48,19 @@ void GcodeSuite::M592_report(const bool forReplay/*=true*/) {
void GcodeSuite::M592() {
if (!parser.seen_any()) return M592_report();
if (parser.seenval('A')) stepper.ne.A = parser.value_float();
if (parser.seenval('B')) stepper.ne.B = parser.value_float();
if (parser.seenval('C')) stepper.ne.C = parser.value_float();
nonlinear_t &ne = stepper.ne;
nonlinear_settings_t &sns = ne.settings;
if (parser.seen('S')) sns.enabled = parser.value_bool();
if (parser.seenval('A')) sns.coeff.A = parser.value_float();
if (parser.seenval('B')) sns.coeff.B = parser.value_float();
if (parser.seenval('C')) sns.coeff.C = parser.value_float();
#if ENABLED(SMOOTH_LIN_ADVANCE)
ne.q30.A = _BV32(30) * (sns.coeff.A * planner.mm_per_step[E_AXIS_N(0)] * planner.mm_per_step[E_AXIS_N(0)]);
ne.q30.B = _BV32(30) * (sns.coeff.B * planner.mm_per_step[E_AXIS_N(0)]);
ne.q30.C = _BV32(30) * sns.coeff.C;
#endif
}
#endif // NONLINEAR_EXTRUSION

9
Marlin/src/gcode/feature/powerloss/M413.cpp
View file

@ -41,10 +41,10 @@
*/
void GcodeSuite::M413() {
if (!parser.seen_any()) return M413_report();
if (parser.seen('S'))
recovery.enable(parser.value_bool());
else
M413_report();
#if HAS_PLR_BED_THRESHOLD
if (parser.seenval('B'))
@ -67,13 +67,12 @@ void GcodeSuite::M413_report(const bool forReplay/*=true*/) {
TERN_(MARLIN_SMALL_BUILD, return);
report_heading_etc(forReplay, F(STR_POWER_LOSS_RECOVERY));
SERIAL_ECHOPGM(" M413 S", AS_DIGIT(recovery.enabled)
SERIAL_ECHOLNPGM(" M413 S", AS_DIGIT(recovery.enabled)
#if HAS_PLR_BED_THRESHOLD
, " B", recovery.bed_temp_threshold
#endif
, " ; ", ON_OFF(recovery.enabled)
);
SERIAL_ECHO(" ; ");
serialprintln_onoff(recovery.enabled);
}
#endif // POWER_LOSS_RECOVERY

9
Marlin/src/gcode/feature/prusa_MMU2/M704-M709.cpp
View file

@ -185,13 +185,12 @@ void GcodeSuite::M709() {
void GcodeSuite::MMU3_report(const bool forReplay/*=true*/) {
using namespace MMU3;
report_heading(forReplay, F("MMU3 Operational Stats"));
SERIAL_ECHOPGM(" MMU "); serialprintln_onoff(mmu3.mmu_hw_enabled);
SERIAL_ECHOPGM(" Stealth Mode "); serialprintln_onoff(mmu3.stealth_mode);
SERIAL_ECHOLNPGM(" MMU ", ON_OFF(mmu3.mmu_hw_enabled));
SERIAL_ECHOLNPGM(" Stealth Mode ", ON_OFF(mmu3.stealth_mode));
#if ENABLED(MMU3_HAS_CUTTER)
SERIAL_ECHOPGM(" Cutter ");
serialprintln_onoff(mmu3.cutter_mode != 0);
SERIAL_ECHOLNPGM(" Cutter ", ON_OFF(mmu3.cutter_mode != 0));
#endif
SERIAL_ECHOPGM(" SpoolJoin "); serialprintln_onoff(spooljoin.enabled);
SERIAL_ECHOLNPGM(" SpoolJoin ", ON_OFF(spooljoin.enabled));
SERIAL_ECHOLNPGM(" Tool Changes ", operation_statistics.tool_change_counter);
SERIAL_ECHOLNPGM(" Total Tool Changes ", operation_statistics.tool_change_total_counter);
SERIAL_ECHOLNPGM(" Fails ", operation_statistics.fail_num);

11
Marlin/src/gcode/feature/runout/M412.cpp
View file

@ -53,14 +53,12 @@ void GcodeSuite::M412() {
}
else {
SERIAL_ECHO_START();
SERIAL_ECHOPGM("Filament runout ");
serialprint_onoff(runout.enabled);
SERIAL_ECHOPGM("Filament runout ", ON_OFF(runout.enabled));
#if HAS_FILAMENT_RUNOUT_DISTANCE
SERIAL_ECHOPGM(" ; Distance ", runout.runout_distance(), "mm");
#endif
#if ENABLED(HOST_ACTION_COMMANDS)
SERIAL_ECHOPGM(" ; Host handling ");
serialprint_onoff(runout.host_handling);
SERIAL_ECHOPGM(" ; Host handling ", ON_OFF(runout.host_handling));
#endif
SERIAL_EOL();
}
@ -70,14 +68,13 @@ void GcodeSuite::M412_report(const bool forReplay/*=true*/) {
TERN_(MARLIN_SMALL_BUILD, return);
report_heading_etc(forReplay, F(STR_FILAMENT_RUNOUT_SENSOR));
SERIAL_ECHOPGM(
SERIAL_ECHOLNPGM(
" M412 S", runout.enabled
#if HAS_FILAMENT_RUNOUT_DISTANCE
, " D", LINEAR_UNIT(runout.runout_distance())
#endif
, " ; Sensor "
, " ; Sensor ", ON_OFF(runout.enabled)
);
serialprintln_onoff(runout.enabled);
}
#endif // HAS_FILAMENT_SENSOR

10
Marlin/src/gcode/feature/trinamic/M911-M914.cpp
View file

@ -32,7 +32,9 @@
#if ENABLED(MONITOR_DRIVER_STATUS)
#define M91x_USE(ST) (AXIS_DRIVER_TYPE(ST, TMC2130) || AXIS_DRIVER_TYPE(ST, TMC2160) || AXIS_DRIVER_TYPE(ST, TMC2208) || AXIS_DRIVER_TYPE(ST, TMC2209) || AXIS_DRIVER_TYPE(ST, TMC2660) || AXIS_DRIVER_TYPE(ST, TMC5130) || AXIS_DRIVER_TYPE(ST, TMC5160))
#define M91x_USE(ST) (AXIS_DRIVER_TYPE(ST, TMC2130) || AXIS_DRIVER_TYPE(ST, TMC2160) \
|| AXIS_DRIVER_TYPE(ST, TMC2208) || AXIS_DRIVER_TYPE(ST, TMC2209) || AXIS_DRIVER_TYPE(ST, TMC2240) \
|| AXIS_DRIVER_TYPE(ST, TMC2660) || AXIS_DRIVER_TYPE(ST, TMC5130) || AXIS_DRIVER_TYPE(ST, TMC5160))
#define M91x_USE_E(N) (E_STEPPERS > N && M91x_USE(E##N))
#if HAS_X_AXIS && (M91x_USE(X) || M91x_USE(X2))
@ -68,15 +70,13 @@
#endif
#if !M91x_SOME_X && !M91x_SOME_Y && !M91x_SOME_Z && !M91x_USE_I && !M91x_USE_J && !M91x_USE_K && !M91x_USE_U && !M91x_USE_V && !M91x_USE_W && !M91x_SOME_E
#error "MONITOR_DRIVER_STATUS requires at least one TMC2130, 2160, 2208, 2209, 2660, 5130, or 5160."
#error "MONITOR_DRIVER_STATUS requires at least one TMC2130, 2160, 2208, 2209, 2240, 2660, 5130, or 5160."
#endif
template<typename TMC>
static void tmc_report_otpw(TMC &st) {
st.printLabel();
SERIAL_ECHOPGM(" temperature prewarn triggered: ");
serialprint_truefalse(st.getOTPW());
SERIAL_EOL();
SERIAL_ECHOLNPGM(" temperature prewarn triggered: ", TRUE_FALSE(st.getOTPW()));
}
template<typename TMC>

8
Marlin/src/gcode/gcode.cpp
View file

@ -319,7 +319,7 @@ void GcodeSuite::dwell(const millis_t time) {
/**
* Process the parsed command and dispatch it to its handler
*/
void GcodeSuite::process_parsed_command(const bool no_ok/*=false*/) {
void GcodeSuite::process_parsed_command(bool no_ok/*=false*/) {
TERN_(HAS_FANCHECK, fan_check.check_deferred_error());
KEEPALIVE_STATE(IN_HANDLER);
@ -458,8 +458,8 @@ void GcodeSuite::process_parsed_command(const bool no_ok/*=false*/) {
case 80: G80(); break; // G80: Reset the current motion mode
#endif
case 90: set_relative_mode(false); break; // G90: Absolute Mode
case 91: set_relative_mode(true); break; // G91: Relative Mode
case 90: G90(); break; // G90: Absolute Mode
case 91: G91(); break; // G91: Relative Mode
case 92: G92(); break; // G92: Set current axis position(s)
@ -582,7 +582,7 @@ void GcodeSuite::process_parsed_command(const bool no_ok/*=false*/) {
case 109: M109(); break; // M109: Wait for hotend temperature to reach target
#endif
case 105: M105(); return; // M105: Report Temperatures (and say "ok")
case 105: M105(); no_ok = true; break; // M105: Report Temperatures (and say "ok")
#if HAS_FAN
case 106: M106(); break; // M106: Fan On

17
Marlin/src/gcode/gcode.h
View file

@ -159,7 +159,7 @@
* M120 - Enable endstops detection.
* M121 - Disable endstops detection.
*
* M122 - Debug stepper (Requires *_DRIVER_TYPE TMC(2130|2160|5130|5160|2208|2209|2660))
* M122 - Debug stepper (Requires *_DRIVER_TYPE TMC(2130|2160|5130|5160|2208|2209|2240|2660))
* M123 - Report fan tachometers. (Requires En_FAN_TACHO_PIN) Optionally set auto-report interval. (Requires AUTO_REPORT_FANS)
* M125 - Save current position and move to filament change position. (Requires PARK_HEAD_ON_PAUSE)
*
@ -265,7 +265,7 @@
* M552 - Get or set IP address. Enable/disable network interface. (Requires enabled Ethernet port)
* M553 - Get or set IP netmask. (Requires enabled Ethernet port)
* M554 - Get or set IP gateway. (Requires enabled Ethernet port)
* M569 - Enable stealthChop on an axis. (Requires *_DRIVER_TYPE TMC(2130|2160|2208|2209|5130|5160))
* M569 - Enable stealthChop on an axis. (Requires *_DRIVER_TYPE TMC(2130|2160|2208|2209|2240|5130|5160))
* M575 - Change the serial baud rate. (Requires BAUD_RATE_GCODE)
* M592 - Get or set Nonlinear Extrusion parameters. (Requires NONLINEAR_EXTRUSION)
* M593 - Get or set input shaping parameters. (Requires INPUT_SHAPING_[XY])
@ -309,17 +309,17 @@
* M871 - Print/reset/clear first layer temperature offset values. (Requires PTC_PROBE, PTC_BED, or PTC_HOTEND)
* M876 - Handle Prompt Response. (Requires HOST_PROMPT_SUPPORT and not EMERGENCY_PARSER)
* M900 - Set or Report Linear Advance K-factor. (Requires LIN_ADVANCE)
* M906 - Set or Report motor current in milliamps using axis codes XYZE, etc. Report values if no axis codes given. (Requires *_DRIVER_TYPE TMC(2130|2160|5130|5160|2208|2209|2660))
* M906 - Set or Report motor current in milliamps using axis codes XYZE, etc. Report values if no axis codes given. (Requires *_DRIVER_TYPE TMC(2130|2160|5130|5160|2208|2209|2240|2660))
* M907 - Set digital trimpot motor current using axis codes. (Requires a board with digital trimpots)
* M908 - Control digital trimpot directly. (Requires HAS_MOTOR_CURRENT_DAC or DIGIPOTSS_PIN)
* M909 - Print digipot/DAC current value. (Requires HAS_MOTOR_CURRENT_DAC)
* M910 - Commit digipot/DAC value to external EEPROM via I2C. (Requires HAS_MOTOR_CURRENT_DAC)
* M911 - Report stepper driver overtemperature pre-warn condition. (Requires *_DRIVER_TYPE TMC(2130|2160|5130|5160|2208|2209|2660))
* M912 - Clear stepper driver overtemperature pre-warn condition flag. (Requires *_DRIVER_TYPE TMC(2130|2160|5130|5160|2208|2209|2660))
* M911 - Report stepper driver overtemperature pre-warn condition. (Requires *_DRIVER_TYPE TMC(2130|2160|5130|5160|2208|2209|2240|2660))
* M912 - Clear stepper driver overtemperature pre-warn condition flag. (Requires *_DRIVER_TYPE TMC(2130|2160|5130|5160|2208|2209|2240|2660))
* M913 - Set HYBRID_THRESHOLD speed. (Requires HYBRID_THRESHOLD)
* M914 - Set StallGuard sensitivity. (Requires SENSORLESS_HOMING or SENSORLESS_PROBING)
* M919 - Set or Report motor Chopper Times (time_off, hysteresis_end, hysteresis_start) using axis codes XYZE, etc.
* If no parameters are given, report. (Requires *_DRIVER_TYPE TMC(2130|2160|5130|5160|2208|2209|2660))
* If no parameters are given, report. (Requires *_DRIVER_TYPE TMC(2130|2160|5130|5160|2208|2209|2240|2660))
* M920 - Set Homing Current. (Requires distinct *_CURRENT_HOME settings)
* M936 - OTA update firmware. (Requires OTA_FIRMWARE_UPDATE)
* M951 - Set Magnetic Parking Extruder parameters. (Requires MAGNETIC_PARKING_EXTRUDER)
@ -458,7 +458,7 @@ public:
static int8_t get_target_e_stepper_from_command(const int8_t dval=-1);
static void get_destination_from_command();
static void process_parsed_command(const bool no_ok=false);
static void process_parsed_command(bool no_ok=false);
static void process_next_command();
// Execute G-code in-place, preserving current G-code parameters
@ -632,6 +632,9 @@ private:
static void G80();
#endif
static void G90() { set_relative_mode(false); }
static void G91() { set_relative_mode(true); }
static void G92();
#if ENABLED(CALIBRATION_GCODE)

179
Marlin/src/gcode/host/M360.cpp
View file

@ -22,6 +22,10 @@
#include "../../inc/MarlinConfig.h"
/**
* M360 Report Printer Configuration - Repetier Firmware
* See https://github.com/repetier/Repetier-Firmware/blob/master/src/ArduinoAVR/Repetier/Printer.cpp
*/
#if ENABLED(REPETIER_GCODE_M360)
#include "../gcode.h"
@ -33,74 +37,112 @@
#include "../../module/temperature.h"
#endif
static void config_prefix(PGM_P const name, PGM_P const pref=nullptr, const int8_t ind=-1) {
#include <cstddef>
struct ProgStr {
PGM_P ptr;
constexpr ProgStr(PGM_P p) : ptr(p) {}
ProgStr(FSTR_P f) : ptr(FTOP(f)) {}
ProgStr(std::nullptr_t) : ptr(nullptr) {}
constexpr operator PGM_P() const { return ptr; }
constexpr explicit operator bool() const { return ptr != nullptr; }
};
static void config_prefix(ProgStr name, ProgStr pref=nullptr, int8_t ind=-1) {
SERIAL_ECHOPGM("Config:");
if (pref) SERIAL_ECHOPGM_P(pref);
if (pref) SERIAL_ECHOPGM_P(static_cast<PGM_P>(pref));
if (ind >= 0) { SERIAL_ECHO(ind); SERIAL_CHAR(':'); }
SERIAL_ECHOPGM_P(name, C(':'));
SERIAL_ECHOPGM_P(static_cast<PGM_P>(name), C(':'));
}
static void config_line(PGM_P const name, const float val, PGM_P const pref=nullptr, const int8_t ind=-1) {
template<typename T>
static void config_line(ProgStr name, const T val, ProgStr pref=nullptr, int8_t ind=-1) {
config_prefix(name, pref, ind);
SERIAL_ECHOLN(val);
}
static void config_line(FSTR_P const name, const float val, FSTR_P const pref=nullptr, const int8_t ind=-1) {
config_line(FTOP(name), val, FTOP(pref), ind);
}
static void config_line_e(const int8_t e, PGM_P const name, const float val) {
template<typename T>
static void config_line_e(int8_t e, ProgStr name, const T val) {
config_line(name, val, PSTR("Extr."), e + 1);
}
static void config_line_e(const int8_t e, FSTR_P const name, const float val) {
config_line_e(e, FTOP(name), val);
}
/**
* M360: Report Firmware configuration
* in RepRapFirmware-compatible format
*/
void GcodeSuite::M360() {
PGMSTR(X_STR, "X");
PGMSTR(Y_STR, "Y");
PGMSTR(Z_STR, "Z");
#if ANY(CLASSIC_JERK, HAS_LINEAR_E_JERK)
PGMSTR(JERK_STR, "Jerk");
#endif
//
// Basics and Enabled items
//
config_line(F("Baudrate"), BAUDRATE);
config_line(F("InputBuffer"), MAX_CMD_SIZE);
config_line(F("PrintlineCache"), BUFSIZE);
config_line(F("MixingExtruder"), ENABLED(MIXING_EXTRUDER));
config_line(F("SDCard"), ENABLED(HAS_MEDIA));
config_line(F("Fan"), ENABLED(HAS_FAN));
config_line(F("LCD"), ENABLED(HAS_DISPLAY));
config_line(F("MixingExtruder"), bool(ENABLED(MIXING_EXTRUDER)));
config_line(F("SDCard"), bool(ENABLED(HAS_MEDIA)));
config_line(F("Fan"), bool(ENABLED(HAS_FAN)));
config_line(F("LCD"), bool(ENABLED(HAS_DISPLAY)));
config_line(F("SoftwarePowerSwitch"), 1);
config_line(F("SupportLocalFilamentchange"), ENABLED(ADVANCED_PAUSE_FEATURE));
config_line(F("CaseLights"), ENABLED(CASE_LIGHT_ENABLE));
config_line(F("ZProbe"), ENABLED(HAS_BED_PROBE));
config_line(F("Autolevel"), ENABLED(HAS_LEVELING));
config_line(F("EEPROM"), ENABLED(EEPROM_SETTINGS));
config_line(F("SupportLocalFilamentchange"), bool(ENABLED(ADVANCED_PAUSE_FEATURE)));
config_line(F("CaseLights"), bool(ENABLED(CASE_LIGHT_ENABLE)));
config_line(F("ZProbe"), bool(ENABLED(HAS_BED_PROBE)));
config_line(F("Autolevel"), bool(ENABLED(HAS_LEVELING)));
config_line(F("EEPROM"), bool(ENABLED(EEPROM_SETTINGS)));
//
// Axis letters, in PROGMEM
//
#define _DEFINE_A_STR(Q) PGMSTR(Q##_STR, STR_##Q);
MAIN_AXIS_MAP(_DEFINE_A_STR);
//
// Homing Directions
//
PGMSTR(H_DIR_STR, "HomeDir");
config_line(H_DIR_STR, X_HOME_DIR, X_STR);
config_line(H_DIR_STR, Y_HOME_DIR, Y_STR);
config_line(H_DIR_STR, Z_HOME_DIR, Z_STR);
#if X_HOME_DIR
config_line(H_DIR_STR, X_HOME_DIR, X_STR);
#endif
#if Y_HOME_DIR
config_line(H_DIR_STR, Y_HOME_DIR, Y_STR);
#endif
#if Z_HOME_DIR
config_line(H_DIR_STR, Z_HOME_DIR, Z_STR);
#endif
#if I_HOME_DIR
config_line(H_DIR_STR, I_HOME_DIR, I_STR);
#endif
#if J_HOME_DIR
config_line(H_DIR_STR, J_HOME_DIR, J_STR);
#endif
#if K_HOME_DIR
config_line(H_DIR_STR, K_HOME_DIR, K_STR);
#endif
#if U_HOME_DIR
config_line(H_DIR_STR, U_HOME_DIR, U_STR);
#endif
#if V_HOME_DIR
config_line(H_DIR_STR, V_HOME_DIR, V_STR);
#endif
#if W_HOME_DIR
config_line(H_DIR_STR, W_HOME_DIR, W_STR);
#endif
#if ANY(CLASSIC_JERK, HAS_LINEAR_E_JERK)
PGMSTR(JERK_STR, "Jerk");
#endif
//
// XYZ Axis Jerk
//
#if ENABLED(CLASSIC_JERK)
if (planner.max_jerk.x == planner.max_jerk.y)
config_line(F("XY"), planner.max_jerk.x, FPSTR(JERK_STR));
#define _REPORT_JERK(Q) config_line(Q##_STR, planner.max_jerk.Q, JERK_STR);
if (TERN0(HAS_Y_AXIS, planner.max_jerk.x == planner.max_jerk.y))
config_line(F("XY"), planner.max_jerk.x, JERK_STR);
else {
config_line(X_STR, planner.max_jerk.x, JERK_STR);
config_line(Y_STR, planner.max_jerk.y, JERK_STR);
TERN_(HAS_X_AXIS, _REPORT_JERK(X));
TERN_(HAS_Y_AXIS, _REPORT_JERK(Y));
}
config_line(Z_STR, planner.max_jerk.z, JERK_STR);
TERN_(HAS_Z_AXIS, config_line(Z_STR, planner.max_jerk.z, JERK_STR));
SECONDARY_AXIS_MAP(_REPORT_JERK);
#endif
//
@ -112,53 +154,62 @@ void GcodeSuite::M360() {
PGMSTR(UNRET_STR, "RetractionUndo");
PGMSTR(SPEED_STR, "Speed");
// M10 Retract with swap (long) moves
config_line(F("Length"), fwretract.settings.retract_length, FPSTR(RET_STR));
config_line(F("Length"), fwretract.settings.retract_length, RET_STR);
config_line(F("LongLength"), fwretract.settings.swap_retract_length, RET_STR);
config_line(SPEED_STR, fwretract.settings.retract_feedrate_mm_s, RET_STR);
config_line(F("ZLift"), fwretract.settings.retract_zraise, FPSTR(RET_STR));
config_line(F("LongLength"), fwretract.settings.swap_retract_length, FPSTR(RET_STR));
config_line(F("ZLift"), fwretract.settings.retract_zraise, RET_STR);
// M11 Recover (undo) with swap (long) moves
config_line(F("ExtraLength"), fwretract.settings.retract_recover_extra, UNRET_STR);
config_line(F("ExtraLongLength"), fwretract.settings.swap_retract_recover_extra, UNRET_STR);
config_line(SPEED_STR, fwretract.settings.retract_recover_feedrate_mm_s, UNRET_STR);
config_line(F("ExtraLength"), fwretract.settings.retract_recover_extra, FPSTR(UNRET_STR));
config_line(F("ExtraLongLength"), fwretract.settings.swap_retract_recover_extra, FPSTR(UNRET_STR));
config_line(F("LongSpeed"), fwretract.settings.swap_retract_recover_feedrate_mm_s, FPSTR(UNRET_STR));
config_line(F("LongSpeed"), fwretract.settings.swap_retract_recover_feedrate_mm_s, UNRET_STR);
#endif
//
// Workspace boundaries
//
const xyz_pos_t dmin = { X_MIN_POS, Y_MIN_POS, Z_MIN_POS },
dmax = { X_MAX_POS, Y_MAX_POS, Z_MAX_POS };
const xyz_pos_t dmin = NUM_AXIS_ARRAY(X_MIN_POS, Y_MIN_POS, Z_MIN_POS, I_MIN_POS, J_MIN_POS, K_MIN_POS, U_MIN_POS, V_MIN_POS, W_MIN_POS),
dmax = NUM_AXIS_ARRAY(X_MAX_POS, Y_MAX_POS, Z_MAX_POS, I_MAX_POS, J_MAX_POS, K_MAX_POS, U_MAX_POS, V_MAX_POS, W_MAX_POS);
xyz_pos_t cmin = dmin, cmax = dmax;
apply_motion_limits(cmin);
apply_motion_limits(cmax);
const xyz_pos_t wmin = cmin.asLogical(), wmax = cmax.asLogical();
PGMSTR(MIN_STR, "Min");
#define _REPORT_MIN(Q) config_line(MIN_STR, wmin.Q, Q##_STR);
MAIN_AXIS_MAP(_REPORT_MIN);
PGMSTR(MAX_STR, "Max");
#define _REPORT_MAX(Q) config_line(MAX_STR, wmax.Q, Q##_STR);
MAIN_AXIS_MAP(_REPORT_MAX);
PGMSTR(SIZE_STR, "Size");
config_line(MIN_STR, wmin.x, X_STR);
config_line(MIN_STR, wmin.y, Y_STR);
config_line(MIN_STR, wmin.z, Z_STR);
config_line(MAX_STR, wmax.x, X_STR);
config_line(MAX_STR, wmax.y, Y_STR);
config_line(MAX_STR, wmax.z, Z_STR);
config_line(SIZE_STR, wmax.x - wmin.x, X_STR);
config_line(SIZE_STR, wmax.y - wmin.y, Y_STR);
config_line(SIZE_STR, wmax.z - wmin.z, Z_STR);
#define _REPORT_SIZE(Q) config_line(SIZE_STR, wmax.Q - wmin.Q, Q##_STR);
MAIN_AXIS_MAP(_REPORT_SIZE);
//
// Axis Steps per mm
//
PGMSTR(S_MM_STR, "Steps/mm");
#define _REPORT_S_MM(Q) config_line(S_MM_STR, planner.settings.axis_steps_per_mm[_AXIS(Q)], Q##_STR);
MAIN_AXIS_MAP(_REPORT_S_MM);
//
// Print and Travel Acceleration
//
#define _ACCEL(A,B) _MIN(planner.settings.max_acceleration_mm_per_s2[A##_AXIS], planner.settings.B)
PGMSTR(P_ACC_STR, "PrintAccel");
PGMSTR(T_ACC_STR, "TravelAccel");
config_line(P_ACC_STR, _ACCEL(X, acceleration), X_STR);
config_line(P_ACC_STR, _ACCEL(Y, acceleration), Y_STR);
config_line(P_ACC_STR, _ACCEL(Z, acceleration), Z_STR);
config_line(T_ACC_STR, _ACCEL(X, travel_acceleration), X_STR);
config_line(T_ACC_STR, _ACCEL(Y, travel_acceleration), Y_STR);
config_line(T_ACC_STR, _ACCEL(Z, travel_acceleration), Z_STR);
#define _ACCEL(Q,B) _MIN(planner.settings.max_acceleration_mm_per_s2[Q##_AXIS], planner.settings.B)
PGMSTR(P_ACC_STR, "PrintAccel");
#define _REPORT_P_ACC(Q) config_line(P_ACC_STR, _ACCEL(Q, acceleration), Q##_STR);
MAIN_AXIS_MAP(_REPORT_P_ACC);
PGMSTR(T_ACC_STR, "TravelAccel");
#define _REPORT_T_ACC(Q) config_line(T_ACC_STR, _ACCEL(Q, travel_acceleration), Q##_STR);
MAIN_AXIS_MAP(_REPORT_T_ACC);
//
// Printer Type
//
config_prefix(PSTR("PrinterType"));
SERIAL_ECHOLNPGM(
TERN_(DELTA, "Delta")
@ -189,12 +240,12 @@ void GcodeSuite::M360() {
#elif ENABLED(CLASSIC_JERK)
config_line_e(e, JERK_STR, planner.max_jerk.e);
#endif
config_line_e(e, F("MaxSpeed"), planner.settings.max_feedrate_mm_s[E_AXIS_N(e)]);
config_line_e(e, F("Acceleration"), planner.settings.max_acceleration_mm_per_s2[E_AXIS_N(e)]);
config_line_e(e, F("MaxSpeed"), planner.settings.max_feedrate_mm_s[E_AXIS_N(e)]);
config_line_e(e, F("Diameter"), TERN(NO_VOLUMETRICS, DEFAULT_NOMINAL_FILAMENT_DIA, planner.filament_size[e]));
config_line_e(e, F("MaxTemp"), thermalManager.hotend_maxtemp[e]);
}
#endif
}
#endif
#endif // REPETIER_GCODE_M360

7
Marlin/src/gcode/motion/G0_G1.cpp
View file

@ -86,9 +86,10 @@ void GcodeSuite::G0_G1(TERN_(HAS_FAST_MOVES, const bool fast_move/*=false*/)) {
const float echange = destination.e - current_position.e;
// Is this a retract or recover move?
if (WITHIN(ABS(echange), MIN_AUTORETRACT, MAX_AUTORETRACT) && fwretract.retracted[active_extruder] == (echange > 0.0)) {
current_position.e = destination.e; // Hide a G1-based retract/recover from calculations
sync_plan_position_e(); // AND from the planner
return fwretract.retract(echange < 0.0); // Firmware-based retract/recover (double-retract ignored)
current_position.e = destination.e; // Hide a G1-based retract/recover from calculations
sync_plan_position_e(); // AND from the planner
fwretract.retract(echange < 0.0); // Firmware-based retract/recover (double-retract ignored)
return;
}
}
}

1
Marlin/src/gcode/ota/M936.cpp
View file

@ -34,7 +34,6 @@
/**
* M936: Set one of the OTA update flags.
* V2 = Upgrade the motherboard firmware
* V3 = Upgrade the RTS controller firmware
*/
void GcodeSuite::M936() {
static uint8_t ota_update_flag = 0x00;

4
Marlin/src/gcode/probe/M401_M402.cpp
View file

@ -47,9 +47,7 @@ void GcodeSuite::M401() {
seenS = parser.seen('S');
if (seenH || seenS) {
if (seenS) bltouch.high_speed_mode = parser.value_bool();
SERIAL_ECHO_START();
SERIAL_ECHOPGM("BLTouch HS mode ");
serialprintln_onoff(bltouch.high_speed_mode);
SERIAL_ECHO_MSG("BLTouch HS mode ", ON_OFF(bltouch.high_speed_mode));
return;
}
#endif

2
Marlin/src/gcode/probe/M951.cpp
View file

@ -80,7 +80,7 @@ void GcodeSuite::M951() {
if (parser.seenval('H')) mpe_settings.fast_feedrate = MMM_TO_MMS(parser.value_linear_units());
if (parser.seenval('D')) mpe_settings.travel_distance = parser.value_linear_units();
if (parser.seenval('C')) mpe_settings.compensation_factor = parser.value_float();
if (!parser.seen("CDHIJLR")) mpe_settings_report();
if (!parser.seen_any()) mpe_settings_report();
}
#endif // MAGNETIC_PARKING_EXTRUDER

5
Marlin/src/gcode/temp/M106_M107.cpp
View file

@ -65,7 +65,10 @@ void GcodeSuite::M106() {
#if ENABLED(EXTRA_FAN_SPEED)
const uint16_t t = parser.intval('T');
if (t > 0) return thermalManager.set_temp_fan_speed(pfan, t);
if (t > 0) {
thermalManager.set_temp_fan_speed(pfan, t);
return;
}
#endif
const uint16_t dspeed = parser.seen_test('A') ? thermalManager.fan_speed[active_extruder] : 255;

4
Marlin/src/gcode/temp/M303.cpp
View file

@ -50,9 +50,7 @@ void GcodeSuite::M303() {
#if HAS_PID_DEBUG
if (parser.seen_test('D')) {
FLIP(thermalManager.pid_debug_flag);
SERIAL_ECHO_START();
SERIAL_ECHOPGM("PID Debug ");
serialprintln_onoff(thermalManager.pid_debug_flag);
SERIAL_ECHO_MSG("PID Debug ", ON_OFF(thermalManager.pid_debug_flag));
return;
}
#endif

12
Marlin/src/inc/Changes.h
View file

@ -765,15 +765,15 @@
#endif
// Consolidate TMC26X, validate migration (#24373)
#define _ISMAX_1(A) defined(A##_MAX_CURRENT)
#define _ISSNS_1(A) defined(A##_SENSE_RESISTOR)
#if DO(ISMAX,||,ALL_AXIS_NAMES)
#define _ISMAX(A) defined(A##_MAX_CURRENT) ||
#define _ISSNS(A) defined(A##_SENSE_RESISTOR) ||
#if MAP(_ISMAX, ALL_AXIS_NAMES) 0
#error "*_MAX_CURRENT is now set with *_CURRENT."
#elif DO(ISSNS,||,ALL_AXIS_NAMES)
#elif MAP(_ISSNS, ALL_AXIS_NAMES) 0
#error "*_SENSE_RESISTOR (in Milli-Ohms) is now set with *_RSENSE (in Ohms), so you must divide values by 1000."
#endif
#undef _ISMAX_1
#undef _ISSNS_1
#undef _ISMAX
#undef _ISSNS
// L64xx stepper drivers have been removed
#define _L6470 0x6470

2
Marlin/src/inc/Conditionals-1-axes.h
View file

@ -544,6 +544,8 @@
#endif
// Helper macros for extruder and hotend arrays
#define _DISTINCT_E_LOOP(E) for (int8_t E = 0; E < DISTINCT_E; E++)
#define DISTINCT_E_LOOP() _DISTINCT_E_LOOP(e)
#define _EXTRUDER_LOOP(E) for (int8_t E = 0; E < EXTRUDERS; E++)
#define EXTRUDER_LOOP() _EXTRUDER_LOOP(e)
#define _HOTEND_LOOP(H) for (int8_t H = 0; H < HOTENDS; H++)

8
Marlin/src/inc/Conditionals-2-LCD.h
View file

@ -663,14 +663,6 @@
#define BOOT_MARLIN_LOGO_SMALL
#endif
// Flow and feedrate editing
#if HAS_EXTRUDERS && ANY(HAS_MARLINUI_MENU, DWIN_CREALITY_LCD, DWIN_LCD_PROUI, MALYAN_LCD, TOUCH_SCREEN)
#define HAS_FLOW_EDIT 1
#endif
#if ANY(HAS_MARLINUI_MENU, ULTIPANEL_FEEDMULTIPLY, DWIN_CREALITY_LCD, DWIN_LCD_PROUI, MALYAN_LCD, TOUCH_SCREEN)
#define HAS_FEEDRATE_EDIT 1
#endif
/**
* TFT Displays
*

5
Marlin/src/inc/Conditionals-3-etc.h
View file

@ -560,11 +560,6 @@
#undef Z_CLEARANCE_DEPLOY_PROBE
#endif
#if !(ANY(HAS_BED_PROBE, BACKLASH_GCODE) || (ENABLED(EXTENSIBLE_UI) && ANY(MESH_BED_LEVELING, AUTO_BED_LEVELING_UBL)))
#undef Z_PROBE_FEEDRATE_FAST
#undef Z_PROBE_FEEDRATE_SLOW
#endif
/**
* Z_CLEARANCE_FOR_HOMING
*/

4
Marlin/src/inc/Conditionals-4-adv.h
View file

@ -105,6 +105,10 @@
#endif
#endif
#if !(ANY(HAS_BED_PROBE, BACKLASH_GCODE) || (ENABLED(EXTENSIBLE_UI) && ANY(MESH_BED_LEVELING, AUTO_BED_LEVELING_UBL)))
#undef Z_PROBE_FEEDRATE_FAST
#undef Z_PROBE_FEEDRATE_SLOW
#endif
#if !HAS_BED_PROBE
#undef BABYSTEP_ZPROBE_OFFSET
#undef PROBING_USE_CURRENT_HOME

68
Marlin/src/inc/SanityCheck.h
View file

@ -846,7 +846,7 @@ static_assert(COUNT(arm) == LOGICAL_AXES, "AXIS_RELATIVE_MODES must contain " _L
* Linear Advance 1.5 - Check K value range
*/
#if ENABLED(LIN_ADVANCE)
#if DISTINCT_E > 1
#if ENABLED(DISTINCT_E_FACTORS)
constexpr float lak[] = ADVANCE_K;
static_assert(COUNT(lak) <= DISTINCT_E, "The ADVANCE_K array has too many elements (i.e., more than " STRINGIFY(DISTINCT_E) ").");
#define _LIN_ASSERT(N) static_assert(N >= COUNT(lak) || WITHIN(lak[N], 0, 10), "ADVANCE_K values must be from 0 to 10 (Changed in LIN_ADVANCE v1.5, Marlin 1.1.9).");
@ -3378,19 +3378,19 @@ static_assert(NUM_SERVOS <= NUM_SERVO_PLUGS, "NUM_SERVOS (or some servo index) i
#error "SPI_ENDSTOPS requires stepper drivers with SPI support."
#endif
#else // !SPI_ENDSTOPS
// Stall detection DIAG = HIGH : TMC2209
// Stall detection DIAG = LOW : TMC2130/TMC2160/TMC2660/TMC5130/TMC5160
// Stall detection DIAG = HIGH : TMC2209/2240
// Stall detection DIAG = LOW : TMC2130/2160/2660/5130/5160
#if X_SENSORLESS
#define _HIT_STATE AXIS_DRIVER_TYPE(X,TMC2209)
#define _HIT_STATE (AXIS_DRIVER_TYPE(X,TMC2209) || AXIS_DRIVER_TYPE(X,TMC2240))
#if X_HOME_TO_MIN && X_MIN_ENDSTOP_HIT_STATE != _HIT_STATE
#if _HIT_STATE
#error "SENSORLESS_HOMING requires X_MIN_ENDSTOP_HIT_STATE HIGH for X MIN homing with TMC2209."
#error "SENSORLESS_HOMING requires X_MIN_ENDSTOP_HIT_STATE HIGH for X MIN homing with TMC2209/2240."
#else
#error "SENSORLESS_HOMING requires X_MIN_ENDSTOP_HIT_STATE LOW for X MIN homing."
#endif
#elif X_HOME_TO_MAX && X_MAX_ENDSTOP_HIT_STATE != _HIT_STATE
#if _HIT_STATE
#error "SENSORLESS_HOMING requires X_MAX_ENDSTOP_HIT_STATE HIGH for X MAX homing with TMC2209."
#error "SENSORLESS_HOMING requires X_MAX_ENDSTOP_HIT_STATE HIGH for X MAX homing with TMC2209/2240."
#else
#error "SENSORLESS_HOMING requires X_MAX_ENDSTOP_HIT_STATE LOW for X MAX homing."
#endif
@ -3399,16 +3399,16 @@ static_assert(NUM_SERVOS <= NUM_SERVO_PLUGS, "NUM_SERVOS (or some servo index) i
#endif
#if Y_SENSORLESS
#define _HIT_STATE AXIS_DRIVER_TYPE(Y,TMC2209)
#define _HIT_STATE (AXIS_DRIVER_TYPE(Y,TMC2209) || AXIS_DRIVER_TYPE(Y,TMC2240))
#if Y_HOME_TO_MIN && Y_MIN_ENDSTOP_HIT_STATE != _HIT_STATE
#if _HIT_STATE
#error "SENSORLESS_HOMING requires Y_MIN_ENDSTOP_HIT_STATE HIGH for Y MIN homing with TMC2209."
#error "SENSORLESS_HOMING requires Y_MIN_ENDSTOP_HIT_STATE HIGH for Y MIN homing with TMC2209/2240."
#else
#error "SENSORLESS_HOMING requires Y_MIN_ENDSTOP_HIT_STATE LOW for Y MIN homing."
#endif
#elif Y_HOME_TO_MAX && Y_MAX_ENDSTOP_HIT_STATE != _HIT_STATE
#if _HIT_STATE
#error "SENSORLESS_HOMING requires Y_MAX_ENDSTOP_HIT_STATE HIGH for Y MAX homing with TMC2209."
#error "SENSORLESS_HOMING requires Y_MAX_ENDSTOP_HIT_STATE HIGH for Y MAX homing with TMC2209/2240."
#else
#error "SENSORLESS_HOMING requires Y_MAX_ENDSTOP_HIT_STATE LOW for Y MAX homing."
#endif
@ -3417,16 +3417,16 @@ static_assert(NUM_SERVOS <= NUM_SERVO_PLUGS, "NUM_SERVOS (or some servo index) i
#endif
#if Z_SENSORLESS
#define _HIT_STATE AXIS_DRIVER_TYPE(Z,TMC2209)
#define _HIT_STATE (AXIS_DRIVER_TYPE(Z,TMC2209) || AXIS_DRIVER_TYPE(Z,TMC2240))
#if Z_HOME_TO_MIN && Z_MIN_ENDSTOP_HIT_STATE != _HIT_STATE
#if _HIT_STATE
#error "SENSORLESS_HOMING requires Z_MIN_ENDSTOP_HIT_STATE HIGH for Z MIN homing with TMC2209."
#error "SENSORLESS_HOMING requires Z_MIN_ENDSTOP_HIT_STATE HIGH for Z MIN homing with TMC2209/2240."
#else
#error "SENSORLESS_HOMING requires Z_MIN_ENDSTOP_HIT_STATE LOW for Z MIN homing."
#endif
#elif Z_HOME_TO_MAX && Z_MAX_ENDSTOP_HIT_STATE != _HIT_STATE
#if _HIT_STATE
#error "SENSORLESS_HOMING requires Z_MAX_ENDSTOP_HIT_STATE HIGH for Z MAX homing with TMC2209."
#error "SENSORLESS_HOMING requires Z_MAX_ENDSTOP_HIT_STATE HIGH for Z MAX homing with TMC2209/2240."
#else
#error "SENSORLESS_HOMING requires Z_MAX_ENDSTOP_HIT_STATE LOW for Z MAX homing."
#endif
@ -3435,16 +3435,16 @@ static_assert(NUM_SERVOS <= NUM_SERVO_PLUGS, "NUM_SERVOS (or some servo index) i
#endif
#if I_SENSORLESS
#define _HIT_STATE AXIS_DRIVER_TYPE(I,TMC2209)
#define _HIT_STATE (AXIS_DRIVER_TYPE(I,TMC2209) || AXIS_DRIVER_TYPE(I,TMC2240))
#if I_HOME_TO_MIN && I_MIN_ENDSTOP_HIT_STATE != _HIT_STATE
#if _HIT_STATE
#error "SENSORLESS_HOMING requires I_MIN_ENDSTOP_HIT_STATE HIGH for I MIN homing with TMC2209."
#error "SENSORLESS_HOMING requires I_MIN_ENDSTOP_HIT_STATE HIGH for I MIN homing with TMC2209/2240."
#else
#error "SENSORLESS_HOMING requires I_MIN_ENDSTOP_HIT_STATE LOW for I MIN homing."
#endif
#elif I_HOME_TO_MAX && I_MAX_ENDSTOP_HIT_STATE != _HIT_STATE
#if _HIT_STATE
#error "SENSORLESS_HOMING requires I_MAX_ENDSTOP_HIT_STATE HIGH for I MAX homing with TMC2209."
#error "SENSORLESS_HOMING requires I_MAX_ENDSTOP_HIT_STATE HIGH for I MAX homing with TMC2209/2240."
#else
#error "SENSORLESS_HOMING requires I_MAX_ENDSTOP_HIT_STATE LOW for I MAX homing."
#endif
@ -3453,16 +3453,16 @@ static_assert(NUM_SERVOS <= NUM_SERVO_PLUGS, "NUM_SERVOS (or some servo index) i
#endif
#if J_SENSORLESS
#define _HIT_STATE AXIS_DRIVER_TYPE(J,TMC2209)
#define _HIT_STATE (AXIS_DRIVER_TYPE(J,TMC2209) || AXIS_DRIVER_TYPE(J,TMC2240))
#if J_HOME_TO_MIN && J_MIN_ENDSTOP_HIT_STATE != _HIT_STATE
#if _HIT_STATE
#error "SENSORLESS_HOMING requires J_MIN_ENDSTOP_HIT_STATE HIGH for J MIN homing with TMC2209."
#error "SENSORLESS_HOMING requires J_MIN_ENDSTOP_HIT_STATE HIGH for J MIN homing with TMC2209/2240."
#else
#error "SENSORLESS_HOMING requires J_MIN_ENDSTOP_HIT_STATE LOW for J MIN homing."
#endif
#elif J_HOME_TO_MAX && J_MAX_ENDSTOP_HIT_STATE != _HIT_STATE
#if _HIT_STATE
#error "SENSORLESS_HOMING requires J_MAX_ENDSTOP_HIT_STATE HIGH for J MAX homing with TMC2209."
#error "SENSORLESS_HOMING requires J_MAX_ENDSTOP_HIT_STATE HIGH for J MAX homing with TMC2209/2240."
#else
#error "SENSORLESS_HOMING requires J_MAX_ENDSTOP_HIT_STATE LOW for J MAX homing."
#endif
@ -3471,16 +3471,16 @@ static_assert(NUM_SERVOS <= NUM_SERVO_PLUGS, "NUM_SERVOS (or some servo index) i
#endif
#if K_SENSORLESS
#define _HIT_STATE AXIS_DRIVER_TYPE(K,TMC2209)
#define _HIT_STATE (AXIS_DRIVER_TYPE(K,TMC2209) || AXIS_DRIVER_TYPE(K,TMC2240))
#if K_HOME_TO_MIN && K_MIN_ENDSTOP_HIT_STATE != _HIT_STATE
#if _HIT_STATE
#error "SENSORLESS_HOMING requires K_MIN_ENDSTOP_HIT_STATE HIGH for K MIN homing with TMC2209."
#error "SENSORLESS_HOMING requires K_MIN_ENDSTOP_HIT_STATE HIGH for K MIN homing with TMC2209/2240."
#else
#error "SENSORLESS_HOMING requires K_MIN_ENDSTOP_HIT_STATE LOW for K MIN homing."
#endif
#elif K_HOME_TO_MAX && K_MAX_ENDSTOP_HIT_STATE != _HIT_STATE
#if _HIT_STATE
#error "SENSORLESS_HOMING requires K_MAX_ENDSTOP_HIT_STATE HIGH for K MAX homing with TMC2209."
#error "SENSORLESS_HOMING requires K_MAX_ENDSTOP_HIT_STATE HIGH for K MAX homing with TMC2209/2240."
#else
#error "SENSORLESS_HOMING requires K_MAX_ENDSTOP_HIT_STATE LOW for K MAX homing."
#endif
@ -3489,16 +3489,16 @@ static_assert(NUM_SERVOS <= NUM_SERVO_PLUGS, "NUM_SERVOS (or some servo index) i
#endif
#if U_SENSORLESS
#define _HIT_STATE AXIS_DRIVER_TYPE(U,TMC2209)
#define _HIT_STATE (AXIS_DRIVER_TYPE(U,TMC2209) || AXIS_DRIVER_TYPE(U,TMC2240))
#if U_HOME_TO_MIN && U_MIN_ENDSTOP_HIT_STATE != _HIT_STATE
#if _HIT_STATE
#error "SENSORLESS_HOMING requires U_MIN_ENDSTOP_HIT_STATE HIGH for U MIN homing with TMC2209."
#error "SENSORLESS_HOMING requires U_MIN_ENDSTOP_HIT_STATE HIGH for U MIN homing with TMC2209/2240."
#else
#error "SENSORLESS_HOMING requires U_MIN_ENDSTOP_HIT_STATE LOW for U MIN homing."
#endif
#elif U_HOME_TO_MAX && U_MAX_ENDSTOP_HIT_STATE != _HIT_STATE
#if _HIT_STATE
#error "SENSORLESS_HOMING requires U_MAX_ENDSTOP_HIT_STATE HIGH for U MAX homing with TMC2209."
#error "SENSORLESS_HOMING requires U_MAX_ENDSTOP_HIT_STATE HIGH for U MAX homing with TMC2209/2240."
#else
#error "SENSORLESS_HOMING requires U_MAX_ENDSTOP_HIT_STATE LOW for U MAX homing."
#endif
@ -3507,16 +3507,16 @@ static_assert(NUM_SERVOS <= NUM_SERVO_PLUGS, "NUM_SERVOS (or some servo index) i
#endif
#if V_SENSORLESS
#define _HIT_STATE AXIS_DRIVER_TYPE(V,TMC2209)
#define _HIT_STATE (AXIS_DRIVER_TYPE(V,TMC2209) || AXIS_DRIVER_TYPE(V,TMC2240))
#if V_HOME_TO_MIN && V_MIN_ENDSTOP_HIT_STATE != _HIT_STATE
#if _HIT_STATE
#error "SENSORLESS_HOMING requires V_MIN_ENDSTOP_HIT_STATE HIGH for V MIN homing with TMC2209."
#error "SENSORLESS_HOMING requires V_MIN_ENDSTOP_HIT_STATE HIGH for V MIN homing with TMC2209/2240."
#else
#error "SENSORLESS_HOMING requires V_MIN_ENDSTOP_HIT_STATE LOW for V MIN homing."
#endif
#elif V_HOME_TO_MAX && V_MAX_ENDSTOP_HIT_STATE != _HIT_STATE
#if _HIT_STATE
#error "SENSORLESS_HOMING requires V_MAX_ENDSTOP_HIT_STATE HIGH for V MAX homing with TMC2209."
#error "SENSORLESS_HOMING requires V_MAX_ENDSTOP_HIT_STATE HIGH for V MAX homing with TMC2209/2240."
#else
#error "SENSORLESS_HOMING requires V_MAX_ENDSTOP_HIT_STATE LOW for V MAX homing."
#endif
@ -3525,16 +3525,16 @@ static_assert(NUM_SERVOS <= NUM_SERVO_PLUGS, "NUM_SERVOS (or some servo index) i
#endif
#if W_SENSORLESS
#define _HIT_STATE AXIS_DRIVER_TYPE(W,TMC2209)
#define _HIT_STATE (AXIS_DRIVER_TYPE(W,TMC2209) || AXIS_DRIVER_TYPE(W,TMC2240))
#if W_HOME_TO_MIN && W_MIN_ENDSTOP_HIT_STATE != _HIT_STATE
#if _HIT_STATE
#error "SENSORLESS_HOMING requires W_MIN_ENDSTOP_HIT_STATE HIGH for W MIN homing with TMC2209."
#error "SENSORLESS_HOMING requires W_MIN_ENDSTOP_HIT_STATE HIGH for W MIN homing with TMC2209/2240."
#else
#error "SENSORLESS_HOMING requires W_MIN_ENDSTOP_HIT_STATE LOW for W MIN homing."
#endif
#elif W_HOME_TO_MAX && W_MAX_ENDSTOP_HIT_STATE != _HIT_STATE
#if _HIT_STATE
#error "SENSORLESS_HOMING requires W_MAX_ENDSTOP_HIT_STATE HIGH for W MAX homing with TMC2209."
#error "SENSORLESS_HOMING requires W_MAX_ENDSTOP_HIT_STATE HIGH for W MAX homing with TMC2209/2240."
#else
#error "SENSORLESS_HOMING requires W_MAX_ENDSTOP_HIT_STATE LOW for W MAX homing."
#endif
@ -3631,11 +3631,11 @@ static_assert(NUM_SERVOS <= NUM_SERVO_PLUGS, "NUM_SERVOS (or some servo index) i
// Other TMC feature requirements
#if ENABLED(SENSORLESS_HOMING) && !HAS_STALLGUARD
#error "SENSORLESS_HOMING requires TMC2130, TMC2160, TMC2209, TMC2660, or TMC5160 stepper drivers."
#error "SENSORLESS_HOMING requires TMC2130, TMC2160, TMC2209, TMC2240, TMC2660, or TMC5160 stepper drivers."
#elif ENABLED(SENSORLESS_PROBING) && !HAS_STALLGUARD
#error "SENSORLESS_PROBING requires TMC2130, TMC2160, TMC2209, TMC2660, or TMC5160 stepper drivers."
#error "SENSORLESS_PROBING requires TMC2130, TMC2160, TMC2209, TMC2240, TMC2660, or TMC5160 stepper drivers."
#elif STEALTHCHOP_ENABLED && !HAS_STEALTHCHOP
#error "STEALTHCHOP requires TMC2130, TMC2160, TMC2208, TMC2209, or TMC5160 stepper drivers."
#error "STEALTHCHOP requires TMC2130, TMC2160, TMC2208, TMC2209, TMC2240, or TMC5160 stepper drivers."
#endif
/**
@ -3723,7 +3723,7 @@ static_assert(NUM_SERVOS <= NUM_SERVO_PLUGS, "NUM_SERVOS (or some servo index) i
* Check per-axis initializers for errors
*/
#define __PLUS_TEST(I,A) && (sanity_arr_##A[_MIN(I,signed(COUNT(sanity_arr_##A)-1))] > 0)
#define __PLUS_TEST(I,A) && (sanity_arr_##A[ALIM(I,sanity_arr_##A)] > 0)
#define _PLUS_TEST(A) (1 REPEAT2(14,__PLUS_TEST,A))
#if HAS_MULTI_EXTRUDER
#define _EXTRA_NOTE " (Did you forget to enable DISTINCT_E_FACTORS?)"

2
Marlin/src/inc/Version.h
View file

@ -42,7 +42,7 @@
* version was tagged.
*/
#ifndef STRING_DISTRIBUTION_DATE
#define STRING_DISTRIBUTION_DATE "2025-05-04"
#define STRING_DISTRIBUTION_DATE "2025-06-05"
#endif
/**

2
Marlin/src/lcd/HD44780/marlinui_HD44780.cpp
View file

@ -1001,7 +1001,7 @@ void MarlinUI::draw_status_screen() {
#if LCD_WIDTH < 20
#if HAS_PRINT_PROGRESS
TERN_(SHOW_PROGRESS_PERCENT, setPercentPos(0, 2));
TERN_(SHOW_PROGRESS_PERCENT, setPercentPos(0, 1));
rotate_progress();
#endif

2
Marlin/src/lcd/dogm/marlinui_DOGM.cpp
View file

@ -197,7 +197,7 @@ bool MarlinUI::detected() { return true; }
#endif
{
#if ENABLED(CUSTOM_BOOTSCREEN_ANIMATED_FRAME_TIME)
const uint8_t fr = _MIN(f, COUNT(custom_bootscreen_animation) - 1);
const uint8_t fr = ALIM(f, custom_bootscreen_animation);
const millis_t frame_time = pgm_read_word(&custom_bootscreen_animation[fr].duration);
#endif
u8g.firstPage();

17
Marlin/src/lcd/e3v2/common/encoder.cpp
View file

@ -137,9 +137,8 @@ EncoderState encoderReceiveAnalyze() {
// LED write data
void LED_WriteData() {
uint8_t tempCounter_LED, tempCounter_Bit;
for (tempCounter_LED = 0; tempCounter_LED < LED_NUM; tempCounter_LED++) {
for (tempCounter_Bit = 0; tempCounter_Bit < 24; tempCounter_Bit++) {
for (uint8_t tempCounter_LED = 0; tempCounter_LED < LED_NUM; tempCounter_LED++) {
for (uint8_t tempCounter_Bit = 0; tempCounter_Bit < 24; tempCounter_Bit++) {
if (LED_DataArray[tempCounter_LED] & (0x800000 >> tempCounter_Bit)) {
LED_DATA_HIGH;
DELAY_NS(300);
@ -190,20 +189,22 @@ EncoderState encoderReceiveAnalyze() {
}
}
struct { bool g, r, b; } led_flag = { false, false, false };
struct { bool g, r, b; } led_flag;
for (uint8_t i = 0; i < LED_NUM; i++) {
led_flag = { false, false, false };
while (1) {
const uint8_t g = uint8_t(LED_DataArray[i] >> 16),
r = uint8_t(LED_DataArray[i] >> 8),
b = uint8_t(LED_DataArray[i]);
if (g == led_data[i].g) led_flag.g = true;
else LED_DataArray[i] += (g > led_data[i].g) ? -0x010000 : 0x010000;
else LED_DataArray[i] += (g > led_data[i].g) ? -_BV32(16) : _BV32(16);
if (r == led_data[i].r) led_flag.r = true;
else LED_DataArray[i] += (r > led_data[i].r) ? -0x000100 : 0x000100;
else LED_DataArray[i] += (r > led_data[i].r) ? -_BV32(8) : _BV32(8);
if (b == led_data[i].b) led_flag.b = true;
else LED_DataArray[i] += (b > led_data[i].b) ? -0x000001 : 0x000001;
else LED_DataArray[i] += (b > led_data[i].b) ? -_BV32(0) : _BV32(0);
LED_WriteData();
if (led_flag.r && led_flag.g && led_flag.b) break;
if (led_flag.g && led_flag.r && led_flag.b) break;
delay(change_Interval);
}
}

25
Marlin/src/lcd/e3v2/jyersui/dwin.cpp
View file

@ -2398,10 +2398,13 @@ void JyersDWIN::menuItemHandler(const uint8_t menu, const uint8_t item, bool dra
case MOTION_LA:
if (draw) {
drawMenuItem(row, ICON_MaxAccelerated, GET_TEXT_F(MSG_ADVANCE_K));
drawFloat(planner.extruder_advance_K[0], row, false, 100);
drawFloat(planner.get_advance_k(), row, false, 100);
}
else
modifyValue(planner.extruder_advance_K[0], 0, 10, 100);
else {
static float k = planner.get_advance_k();
modifyValue(k, 0, 10, 100, []{ planner.set_advance_k(k); });
}
break;
#endif
}
@ -2914,10 +2917,12 @@ void JyersDWIN::menuItemHandler(const uint8_t menu, const uint8_t item, bool dra
case ADVANCED_LA:
if (draw) {
drawMenuItem(row, ICON_MaxAccelerated, GET_TEXT_F(MSG_ADVANCE_K));
drawFloat(planner.extruder_advance_K[0], row, false, 100);
drawFloat(planner.get_advance_k(), row, false, 100);
}
else {
static float k = planner.get_advance_k();
modifyValue(k, 0, 10, 100, []{ planner.set_advance_k(k); });
}
else
modifyValue(planner.extruder_advance_K[0], 0, 10, 100);
break;
#endif
@ -3925,10 +3930,12 @@ void JyersDWIN::menuItemHandler(const uint8_t menu, const uint8_t item, bool dra
case TUNE_LA:
if (draw) {
drawMenuItem(row, ICON_MaxAccelerated, GET_TEXT_F(MSG_ADVANCE_K));
drawFloat(planner.extruder_advance_K[0], row, false, 100);
drawFloat(planner.get_advance_k(), row, false, 100);
}
else {
static float k = planner.get_advance_k();
modifyValue(k, 0, 10, 100, []{ planner.set_advance_k(k); });
}
else
modifyValue(planner.extruder_advance_K[0], 0, 10, 100);
break;
#endif

54
Marlin/src/lcd/e3v2/proui/dwin.cpp
View file

@ -1278,7 +1278,7 @@ void hmiWaitForUser() {
if (!wait_for_user) {
switch (checkkey) {
case ID_PrintDone: select_page.reset(); gotoMainMenu(); break;
default: hmiReturnScreen(); break;
default: ui.reset_status(true); hmiReturnScreen(); break;
}
}
}
@ -1959,8 +1959,11 @@ void MarlinUI::update() {
#if HAS_LCD_BRIGHTNESS
void MarlinUI::_set_brightness() {
if (!backlight) wait_for_user = true;
dwinLCDBrightness(backlight ? brightness : 0);
if (!backlight)
wait_for_user = true;
else if (checkkey != ID_PrintDone)
wait_for_user = false;
}
#endif
@ -2380,6 +2383,7 @@ void setMoveZ() { hmiValue.axis = Z_AXIS; setPFloatOnClick(Z_MIN_POS, Z_MAX_POS,
#endif
void setSpeed() { setPIntOnClick(SPEED_EDIT_MIN, SPEED_EDIT_MAX); }
void setFlow() { setPIntOnClick(FLOW_EDIT_MIN, FLOW_EDIT_MAX, []{ planner.refresh_e_factor(0); }); }
#if HAS_HOTEND
void applyHotendTemp() { thermalManager.setTargetHotend(menuData.value, 0); }
@ -2424,8 +2428,6 @@ void setSpeed() { setPIntOnClick(SPEED_EDIT_MIN, SPEED_EDIT_MAX); }
#endif // ADVANCED_PAUSE_FEATURE
void setFlow() { setPIntOnClick(FLOW_EDIT_MIN, FLOW_EDIT_MAX, []{ planner.refresh_e_factor(0); }); }
// Bed Tramming
#if ENABLED(LCD_BED_TRAMMING)
@ -2594,23 +2596,25 @@ void setFlow() { setPIntOnClick(FLOW_EDIT_MIN, FLOW_EDIT_MAX, []{ planner.refres
#if ENABLED(MESH_BED_LEVELING)
#define MESH_Z_FDIGITS 2
void manualMeshStart() {
LCD_MESSAGE(MSG_UBL_BUILD_MESH_MENU);
gcode.process_subcommands_now(F("G28XYO\nG28Z\nM211S0\nG29S1"));
#ifdef MANUAL_PROBE_START_Z
const uint8_t line = currentMenu->line(mMeshMoveZItem->pos);
DWINUI::drawSignedFloat(hmiData.colorText, hmiData.colorBackground, 3, 2, VALX - 2 * DWINUI::fontWidth(DWIN_FONT_MENU), MBASE(line), MANUAL_PROBE_START_Z);
DWINUI::drawSignedFloat(hmiData.colorText, hmiData.colorBackground, 3, MESH_Z_FDIGITS, VALX - 2 * DWINUI::fontWidth(DWIN_FONT_MENU), MBASE(line), MANUAL_PROBE_START_Z);
#endif
}
void liveMeshMoveZ() {
*menuData.floatPtr = menuData.value / POW(10, 2);
*menuData.floatPtr = menuData.value / POW(10, MESH_Z_FDIGITS);
if (!planner.is_full()) {
planner.synchronize();
planner.buffer_line(current_position, manual_feedrate_mm_s[Z_AXIS]);
}
}
void setMMeshMoveZ() { setPFloatOnClick(-1, 1, 2, planner.synchronize, liveMeshMoveZ); }
void setMMeshMoveZ() { setPFloatOnClick(-1, 1, MESH_Z_FDIGITS, planner.synchronize, liveMeshMoveZ); }
void manualMeshContinue() {
gcode.process_subcommands_now(F("G29S2"));
@ -2684,7 +2688,9 @@ void applyMaxAccel() { planner.set_max_acceleration(hmiValue.axis, menuData.valu
#endif
#if ENABLED(LIN_ADVANCE)
void setLA_K() { setPFloatOnClick(0, 10, 3); }
#define LA_FDIGITS 3
void applyLA_K() { planner.set_advance_k(menuData.value / POW(10, LA_FDIGITS)); }
void setLA_K() { setPFloatOnClick(0, 10, LA_FDIGITS, applyLA_K); }
#endif
#if HAS_X_AXIS
@ -3519,6 +3525,7 @@ void drawTuneMenu() {
if (SET_MENU_R(tuneMenu, selrect({73, 2, 28, 12}), MSG_TUNE, items)) {
BACK_ITEM(gotoPrintProcess);
EDIT_ITEM(ICON_Speed, MSG_SPEED, onDrawSpeedItem, setSpeed, &feedrate_percentage);
EDIT_ITEM(ICON_Flow, MSG_FLOW, onDrawPIntMenu, setFlow, &planner.flow_percentage[0]);
#if HAS_HOTEND
hotendTargetItem = EDIT_ITEM(ICON_HotendTemp, MSG_UBL_SET_TEMP_HOTEND, onDrawHotendTemp, setHotendTemp, &thermalManager.temp_hotend[0].target);
#endif
@ -3533,7 +3540,6 @@ void drawTuneMenu() {
#elif ALL(HAS_ZOFFSET_ITEM, MESH_BED_LEVELING, BABYSTEPPING)
EDIT_ITEM(ICON_Zoffset, MSG_HOME_OFFSET_Z, onDrawPFloat2Menu, setZOffset, &BABY_Z_VAR);
#endif
EDIT_ITEM(ICON_Flow, MSG_FLOW, onDrawPIntMenu, setFlow, &planner.flow_percentage[0]);
#if ENABLED(ADVANCED_PAUSE_FEATURE)
MENU_ITEM(ICON_FilMan, MSG_FILAMENTCHANGE, onDrawMenuItem, changeFilament);
#endif
@ -3550,7 +3556,8 @@ void drawTuneMenu() {
EDIT_ITEM(ICON_JDmm, MSG_JUNCTION_DEVIATION, onDrawPFloat3Menu, setJDmm, &planner.junction_deviation_mm);
#endif
#if ENABLED(PROUI_ITEM_ADVK)
EDIT_ITEM(ICON_MaxAccelerated, MSG_ADVANCE_K, onDrawPFloat3Menu, setLA_K, &planner.extruder_advance_K[0]);
float editable_k = planner.get_advance_k();
EDIT_ITEM(ICON_MaxAccelerated, MSG_ADVANCE_K, onDrawPFloat3Menu, setLA_K, &editable_k);
#endif
#if HAS_LOCKSCREEN
MENU_ITEM(ICON_Lock, MSG_LOCKSCREEN, onDrawMenuItem, dwinLockScreen);
@ -3688,7 +3695,8 @@ void drawMotionMenu() {
MENU_ITEM(ICON_Homing, MSG_HOMING_FEEDRATE, onDrawSubMenu, drawHomingFRMenu);
#endif
#if ENABLED(LIN_ADVANCE)
EDIT_ITEM(ICON_MaxAccelerated, MSG_ADVANCE_K, onDrawPFloat3Menu, setLA_K, &planner.extruder_advance_K[0]);
float editable_k = planner.get_advance_k();
EDIT_ITEM(ICON_MaxAccelerated, MSG_ADVANCE_K, onDrawPFloat3Menu, setLA_K, &editable_k);
#endif
#if ENABLED(SHAPING_MENU)
MENU_ITEM(ICON_InputShaping, MSG_INPUT_SHAPING, onDrawSubMenu, drawInputShaping_menu);
@ -3696,8 +3704,8 @@ void drawMotionMenu() {
#if ENABLED(ADAPTIVE_STEP_SMOOTHING_TOGGLE)
EDIT_ITEM(ICON_UBLActive, MSG_STEP_SMOOTHING, onDrawChkbMenu, setAdaptiveStepSmoothing, &stepper.adaptive_step_smoothing_enabled);
#endif
EDIT_ITEM(ICON_Speed, MSG_SPEED, onDrawSpeedItem, setSpeed, &feedrate_percentage);
EDIT_ITEM(ICON_Flow, MSG_FLOW, onDrawPIntMenu, setFlow, &planner.flow_percentage[0]);
EDIT_ITEM(ICON_Speed, MSG_SPEED, onDrawPIntMenu, setSpeed, &feedrate_percentage);
}
updateMenu(motionMenu);
}
@ -4030,9 +4038,10 @@ void drawMaxAccelMenu() {
void setSensorResponse() { setPFloatOnClick(0, 1, 4); }
void setAmbientXfer() { setPFloatOnClick(0, 1, 4); }
#if ENABLED(MPC_INCLUDE_FAN)
void onDrawFanAdj(MenuItem* menuitem, int8_t line) { onDrawFloatMenu(menuitem, line, 4, thermalManager.temp_hotend[0].fanCoefficient()); }
void applyFanAdj() { thermalManager.temp_hotend[0].applyFanAdjustment(menuData.value / POW(10, 4)); }
void setFanAdj() { setFloatOnClick(0, 1, 4, thermalManager.temp_hotend[0].fanCoefficient(), applyFanAdj); }
#define MPC_FAN_FDIGITS 4
void onDrawFanAdj(MenuItem* menuitem, int8_t line) { onDrawFloatMenu(menuitem, line, MPC_FAN_FDIGITS, thermalManager.temp_hotend[0].fanCoefficient()); }
void applyFanAdj() { thermalManager.temp_hotend[0].applyFanAdjustment(menuData.value / POW(10, MPC_FAN_FDIGITS)); }
void setFanAdj() { setFloatOnClick(0, 1, MPC_FAN_FDIGITS, thermalManager.temp_hotend[0].fanCoefficient(), applyFanAdj); }
#endif
#endif
@ -4076,27 +4085,28 @@ void drawMaxAccelMenu() {
#endif
#if ENABLED(PID_EDIT_MENU)
void setKp() { setPFloatOnClick(0, 1000, 2); }
#define PID_FDIGITS 2
void setKp() { setPFloatOnClick(0, 1000, PID_FDIGITS); }
void applyPIDi() {
*menuData.floatPtr = scalePID_i(menuData.value / POW(10, 2));
*menuData.floatPtr = scalePID_i(menuData.value / POW(10, PID_FDIGITS));
TERN_(PIDTEMP, thermalManager.updatePID());
}
void applyPIDd() {
*menuData.floatPtr = scalePID_d(menuData.value / POW(10, 2));
*menuData.floatPtr = scalePID_d(menuData.value / POW(10, PID_FDIGITS));
TERN_(PIDTEMP, thermalManager.updatePID());
}
void setKi() {
menuData.floatPtr = (float*)static_cast<MenuItemPtr*>(currentMenu->selectedItem())->value;
const float value = unscalePID_i(*menuData.floatPtr);
setFloatOnClick(0, 1000, 2, value, applyPIDi);
setFloatOnClick(0, 1000, PID_FDIGITS, value, applyPIDi);
}
void setKd() {
menuData.floatPtr = (float*)static_cast<MenuItemPtr*>(currentMenu->selectedItem())->value;
const float value = unscalePID_d(*menuData.floatPtr);
setFloatOnClick(0, 1000, 2, value, applyPIDd);
setFloatOnClick(0, 1000, PID_FDIGITS, value, applyPIDd);
}
void onDrawPIDi(MenuItem* menuitem, int8_t line) { onDrawFloatMenu(menuitem, line, 2, unscalePID_i(*(float*)static_cast<MenuItemPtr*>(menuitem)->value)); }
void onDrawPIDd(MenuItem* menuitem, int8_t line) { onDrawFloatMenu(menuitem, line, 2, unscalePID_d(*(float*)static_cast<MenuItemPtr*>(menuitem)->value)); }
void onDrawPIDi(MenuItem* menuitem, int8_t line) { onDrawFloatMenu(menuitem, line, PID_FDIGITS, unscalePID_i(*(float*)static_cast<MenuItemPtr*>(menuitem)->value)); }
void onDrawPIDd(MenuItem* menuitem, int8_t line) { onDrawFloatMenu(menuitem, line, PID_FDIGITS, unscalePID_d(*(float*)static_cast<MenuItemPtr*>(menuitem)->value)); }
#endif // PID_EDIT_MENU
#endif // HAS_PID_HEATING

4
Marlin/src/lcd/extui/ftdi_eve_touch_ui/generic/max_acceleration_screen.cpp
View file

@ -39,7 +39,7 @@ void MaxAccelerationScreen::onRedraw(draw_mode_t what) {
w.color(z_axis) .adjuster( 6, GET_TEXT_F(MSG_AMAX_Z), getAxisMaxAcceleration_mm_s2(Z) );
#if DISTINCT_E == 1
w.color(e_axis).adjuster( 8, GET_TEXT_F(MSG_AMAX_E), getAxisMaxAcceleration_mm_s2(E0) );
#elif DISTINCT_E > 1
#elif ENABLED(DISTINCT_E_FACTORS)
w.heading(GET_TEXT_F(MSG_AMAX_E));
w.color(e_axis).adjuster( 8, F(STR_E0), getAxisMaxAcceleration_mm_s2(E0) );
w.color(e_axis).adjuster(10, F(STR_E1), getAxisMaxAcceleration_mm_s2(E1) );
@ -64,7 +64,7 @@ bool MaxAccelerationScreen::onTouchHeld(uint8_t tag) {
case 7: UI_INCREMENT(AxisMaxAcceleration_mm_s2, Z ); break;
case 8: UI_DECREMENT(AxisMaxAcceleration_mm_s2, E0); break;
case 9: UI_INCREMENT(AxisMaxAcceleration_mm_s2, E0); break;
#if DISTINCT_E > 1
#if ENABLED(DISTINCT_E_FACTORS)
case 10: UI_DECREMENT(AxisMaxAcceleration_mm_s2, E1); break;
case 11: UI_INCREMENT(AxisMaxAcceleration_mm_s2, E1); break;
#if DISTINCT_E > 2

2
Marlin/src/lcd/extui/ftdi_eve_touch_ui/generic/max_velocity_screen.cpp
View file

@ -66,7 +66,7 @@ bool MaxVelocityScreen::onTouchHeld(uint8_t tag) {
#if DISTINCT_E
case 8: UI_DECREMENT(AxisMaxFeedrate_mm_s, E0); break;
case 9: UI_INCREMENT(AxisMaxFeedrate_mm_s, E0); break;
#if DISTINCT_E > 1
#if ENABLED(DISTINCT_E_FACTORS)
case 10: UI_DECREMENT(AxisMaxFeedrate_mm_s, E1); break;
case 11: UI_INCREMENT(AxisMaxFeedrate_mm_s, E1); break;
#if DISTINCT_E > 2

4
Marlin/src/lcd/extui/mks_ui/draw_number_key.cpp
View file

@ -243,10 +243,10 @@ static void set_value_confirm() {
#if HAS_Z_AXIS
case ZMaxFeedRate: planner.settings.max_feedrate_mm_s[Z_AXIS] = atof(key_value); break;
#endif
#if HAS_E0_AXIS
#if HAS_EXTRUDERS
case E0MaxFeedRate: planner.settings.max_feedrate_mm_s[E_AXIS] = atof(key_value); break;
#endif
#if HAS_E1_AXIS
#if HAS_MULTI_EXTRUDER
case E1MaxFeedRate: planner.settings.max_feedrate_mm_s[E_AXIS_N(1)] = atof(key_value); break;
#endif

21
Marlin/src/lcd/extui/mks_ui/draw_ui.cpp
View file

@ -579,7 +579,7 @@ char *creat_title_text() {
update_spi_flash();
}
card.closefile();
#endif
#endif // HAS_MEDIA
}
void gcode_preview(char *path, int xpos_pixel, int ypos_pixel) {
@ -662,27 +662,27 @@ char *creat_title_text() {
}
void draw_default_preview(int xpos_pixel, int ypos_pixel, uint8_t sel) {
int index;
static constexpr uint16_t draw_col_count = 40; // Number of rows displayed each time, determines the size of bmp_public_buf
static constexpr int draw_count = 200 / draw_col_count; // Total number of times to be displayed
static constexpr uint32_t pixel_count = (DEFAULT_VIEW_MAX_SIZE) / draw_count; // Number of pixels read per time (uint8_t)
int y_off = 0;
W25QXX.init(SPI_QUARTER_SPEED);
for (index = 0; index < 10; index++) { // 200*200
for (int index = 0; index < draw_count; index++) { // 200*200
#if HAS_BAK_VIEW_IN_FLASH
if (sel == 1) {
flash_view_Read(bmp_public_buf, 8000); // 20k
flash_view_Read(bmp_public_buf, pixel_count); // 16k
}
else {
default_view_Read(bmp_public_buf, DEFAULT_VIEW_MAX_SIZE / 10); // 8k
default_view_Read(bmp_public_buf, pixel_count); // 16k
}
#else
default_view_Read(bmp_public_buf, DEFAULT_VIEW_MAX_SIZE / 10); // 8k
default_view_Read(bmp_public_buf, pixel_count); // 8k
#endif
SPI_TFT.setWindow(xpos_pixel, y_off * 20 + ypos_pixel, 200, 20); // 200*200
SPI_TFT.tftio.writeSequence((uint16_t*)(bmp_public_buf), DEFAULT_VIEW_MAX_SIZE / 20);
SPI_TFT.setWindow(xpos_pixel, y_off * draw_col_count + ypos_pixel, 200, draw_col_count); // 200 * draw_col_count
SPI_TFT.tftio.writeSequence((uint16_t*)(bmp_public_buf), uint16_t(pixel_count / 2));
y_off++;
}
W25QXX.init(SPI_QUARTER_SPEED);
}
void disp_pre_gcode(int xpos_pixel, int ypos_pixel) {
@ -700,6 +700,7 @@ char *creat_title_text() {
}
#endif
}
#endif // HAS_GCODE_PREVIEW
void print_time_run() {

133
Marlin/src/lcd/extui/mks_ui/pic_manager.cpp
View file

@ -35,6 +35,10 @@
#include <string.h>
#if ENABLED(USE_HASH_TABLE)
#include "uthash.h"
#endif
extern uint16_t DeviceCode;
#if HAS_MEDIA
@ -92,7 +96,7 @@ static FSTR_P const assets[] = {
F("bmp_file.bin"),
// Move motor screen
// TODO: 6 equal icons, just in diffenct rotation... it may be optimized too
// TODO: 6 equal icons, just in different rotation... it may be optimized too
F("bmp_xAdd.bin"),
F("bmp_xDec.bin"),
F("bmp_yAdd.bin"),
@ -223,42 +227,98 @@ static FSTR_P const assets[] = {
static FSTR_P const fonts[] = { F("FontUNIGBK.bin") };
#endif
uint8_t currentFlashPage = 0;
#if HAS_SPI_FLASH_COMPRESSION
uint8_t currentFlashPage = 0;
#endif
uint32_t lv_get_pic_addr(uint8_t *Pname) {
uint8_t Pic_cnt;
uint8_t i, j;
PIC_MSG PIC;
uint32_t tmp_cnt = 0;
uint32_t addr = 0;
#if ENABLED(USE_HASH_TABLE)
currentFlashPage = 0;
typedef struct {
char name[PIC_NAME_MAX_LEN - PIC_NAME_OFFSET]; /* key */
uint32_t addr;
UT_hash_handle hh; /* makes this structure hashable */
} PicHashEntry;
#if ENABLED(MARLIN_DEV_MODE)
SERIAL_ECHOLNPGM("Getting picture SPI Flash Address: ", (const char*)Pname);
#endif
PicHashEntry* pic_hash = NULL;
W25QXX.init(SPI_QUARTER_SPEED);
// Initialize the image address hash table
void init_img_map() {
uint8_t Pic_cnt;
W25QXX.SPI_FLASH_BufferRead(&Pic_cnt, PIC_COUNTER_ADDR, 1);
if (Pic_cnt == 0xFF) Pic_cnt = 0;
W25QXX.SPI_FLASH_BufferRead(&Pic_cnt, PIC_COUNTER_ADDR, 1);
if (Pic_cnt == 0xFF) Pic_cnt = 0;
for (i = 0; i < Pic_cnt; i++) {
j = 0;
do {
W25QXX.SPI_FLASH_BufferRead(&PIC.name[j], PIC_NAME_ADDR + tmp_cnt, 1);
tmp_cnt++;
} while (PIC.name[j++] != '\0');
uint32_t tmp_cnt = 0;
for (uint8_t i = 0; i < Pic_cnt; i++) {
char name[PIC_NAME_MAX_LEN - PIC_NAME_OFFSET];
uint8_t j = 0;
do {
W25QXX.SPI_FLASH_BufferRead((uint8_t*)&name[j], PIC_NAME_ADDR + tmp_cnt, 1);
tmp_cnt++;
} while (name[j++] != '\0');
if ((strcasecmp((char*)Pname, (char*)PIC.name)) == 0) {
uint32_t addr;
if (DeviceCode == 0x9488 || DeviceCode == 0x5761)
addr = PIC_DATA_ADDR_TFT35 + i * PER_PIC_MAX_SPACE_TFT35;
else
addr = PIC_DATA_ADDR_TFT32 + i * PER_PIC_MAX_SPACE_TFT32;
return addr;
// Add to hash table, don't save "bmp_"
PicHashEntry* entry = (PicHashEntry*)malloc(sizeof(*entry));
strncpy(entry->name, (name + PIC_NAME_OFFSET), sizeof(name));
entry->addr = addr;
HASH_ADD_STR(pic_hash, name, entry);
}
#if ENABLED(MARLIN_DEV_MODE)
SERIAL_ECHOLNPGM("Image Hash Table Count: ", HASH_COUNT(pic_hash), ", Size(Bytes): ", HASH_OVERHEAD(hh, pic_hash));
#endif
}
return addr;
}
uint32_t lv_get_pic_addr(uint8_t *Pname) {
#if ENABLED(MARLIN_DEV_MODE)
SERIAL_ECHOLNPGM("Getting picture SPI Flash Address: ", (const char*)Pname);
#endif
PicHashEntry* entry;
HASH_FIND_STR(pic_hash, (char*)(Pname + PIC_NAME_OFFSET), entry);
return entry ? entry->addr : 0;
}
#else // !USE_HASH_TABLE
uint32_t lv_get_pic_addr(uint8_t *Pname) {
uint8_t Pic_cnt;
uint8_t i, j;
PIC_MSG PIC;
uint32_t tmp_cnt = 0;
uint32_t addr = 0;
#if ENABLED(MARLIN_DEV_MODE)
SERIAL_ECHOLNPGM("Getting picture SPI Flash Address: ", (const char*)Pname);
#endif
W25QXX.init(SPI_QUARTER_SPEED);
W25QXX.SPI_FLASH_BufferRead(&Pic_cnt, PIC_COUNTER_ADDR, 1);
if (Pic_cnt == 0xFF) Pic_cnt = 0;
for (i = 0; i < Pic_cnt; i++) {
j = 0;
do {
W25QXX.SPI_FLASH_BufferRead(&PIC.name[j], PIC_NAME_ADDR + tmp_cnt, 1);
tmp_cnt++;
} while (PIC.name[j++] != '\0');
if ((strcasecmp((char*)Pname, (char*)PIC.name)) == 0) {
if (DeviceCode == 0x9488 || DeviceCode == 0x5761)
addr = PIC_DATA_ADDR_TFT35 + i * PER_PIC_MAX_SPACE_TFT35;
else
addr = PIC_DATA_ADDR_TFT32 + i * PER_PIC_MAX_SPACE_TFT32;
break;
}
}
return addr;
}
#endif // !USE_HASH_TABLE
const char *assetsPath = "assets";
const char *bakPath = "_assets";
@ -309,8 +369,8 @@ uint8_t picLogoWrite(uint8_t *LogoName, uint8_t *Logo_Wbuff, uint32_t LogoWriteS
uint32_t TitleLogoWrite_Addroffset = 0;
uint8_t picTitleLogoWrite(uint8_t *TitleLogoName, uint8_t *TitleLogo_Wbuff, uint32_t TitleLogoWriteSize) {
if (TitleLogoWriteSize <= 0)
return 0;
if (TitleLogoWriteSize <= 0) return 0;
if ((DeviceCode == 0x9488) || (DeviceCode == 0x5761))
W25QXX.SPI_FLASH_BufferWrite(TitleLogo_Wbuff, PIC_ICON_LOGO_ADDR_TFT35 + TitleLogoWrite_Addroffset, TitleLogoWriteSize);
else
@ -341,9 +401,7 @@ uint32_t picInfoWrite(uint8_t *P_name, uint32_t P_size) {
union union32 size_tmp;
W25QXX.SPI_FLASH_BufferRead(&pic_counter, PIC_COUNTER_ADDR, 1);
if (pic_counter == 0xFF)
pic_counter = 0;
if (pic_counter == 0xFF) pic_counter = 0;
if ((DeviceCode == 0x9488) || (DeviceCode == 0x5761))
picSaveAddr = PIC_DATA_ADDR_TFT35 + pic_counter * PER_PIC_MAX_SPACE_TFT35;
@ -416,6 +474,7 @@ uint32_t picInfoWrite(uint8_t *P_name, uint32_t P_size) {
}
hal.watchdog_refresh();
disp_string(100, 165, FTOP(F(" ")), 0xFFFF, 0x0000); // clean string
disp_assets_update_progress(fn);
W25QXX.init(SPI_QUARTER_SPEED);
@ -449,16 +508,18 @@ uint32_t picInfoWrite(uint8_t *P_name, uint32_t P_size) {
}
else if (assetType == ASSET_TYPE_ICON) {
Pic_Write_Addr = picInfoWrite((uint8_t*)fn, pfileSize);
SPIFlash.beginWrite(Pic_Write_Addr);
#if HAS_SPI_FLASH_COMPRESSION
SPIFlash.beginWrite(Pic_Write_Addr);
do {
hal.watchdog_refresh();
pbr = file.read(public_buf, SPI_FLASH_PageSize);
TERN_(MARLIN_DEV_MODE, totalSizes += pbr);
SPIFlash.writeData(public_buf, SPI_FLASH_PageSize);
} while (pbr >= SPI_FLASH_PageSize);
SPIFlash.endWrite();
#else
do {
hal.watchdog_refresh();
pbr = file.read(public_buf, BMP_WRITE_BUF_LEN);
W25QXX.SPI_FLASH_BufferWrite(public_buf, Pic_Write_Addr, pbr);
Pic_Write_Addr += pbr;
@ -468,7 +529,6 @@ uint32_t picInfoWrite(uint8_t *P_name, uint32_t P_size) {
SERIAL_ECHOLNPGM("Space used: ", fn, " - ", (SPIFlash.getCurrentPage() + 1) * SPI_FLASH_PageSize / 1024, "KB");
totalCompressed += (SPIFlash.getCurrentPage() + 1) * SPI_FLASH_PageSize;
#endif
SPIFlash.endWrite();
}
else if (assetType == ASSET_TYPE_FONT) {
Pic_Write_Addr = UNIGBK_FLASH_ADDR;
@ -557,8 +617,7 @@ void picRead(uint8_t *Pname, uint8_t *P_Rbuff) {
PIC_MSG PIC;
W25QXX.SPI_FLASH_BufferRead(&Pic_cnt, PIC_COUNTER_ADDR, 1);
if (Pic_cnt == 0xFF)
Pic_cnt = 0;
if (Pic_cnt == 0xFF) Pic_cnt = 0;
for (i = 0; i < Pic_cnt; i++) {
j = 0;
@ -578,12 +637,12 @@ void picRead(uint8_t *Pname, uint8_t *P_Rbuff) {
void lv_pic_test(uint8_t *P_Rbuff, uint32_t addr, uint32_t size) {
#if HAS_SPI_FLASH_COMPRESSION
if (currentFlashPage == 0)
if (currentFlashPage == 0) {
currentFlashPage = 1;
SPIFlash.beginRead(addr);
}
SPIFlash.readData(P_Rbuff, size);
currentFlashPage++;
#else
W25QXX.init(SPI_QUARTER_SPEED);
W25QXX.SPI_FLASH_BufferRead((uint8_t *)P_Rbuff, addr, size);
#endif
}

15
Marlin/src/lcd/extui/mks_ui/pic_manager.h
View file

@ -29,6 +29,9 @@
#include <stdint.h>
#include <string.h>
#include "SPIFlashStorage.h"
#define USE_HASH_TABLE
#ifndef HAS_SPI_FLASH_FONT
#define HAS_SPI_FLASH_FONT 1 // Disabled until fix the font load code
@ -53,7 +56,8 @@
#endif
#define PIC_MAX_CN 100 // Maximum number of pictures
#define PIC_NAME_MAX_LEN 50 // Picture name maximum length
#define PIC_NAME_MAX_LEN 30 // Picture name maximum length
#define PIC_NAME_OFFSET 4 // Same picture filename section
#define LOGO_MAX_SIZE_TFT35 (300 * 1024)
#define LOGO_MAX_SIZE_TFT32 (150 * 1024)
@ -61,7 +65,11 @@
#define DEFAULT_VIEW_MAX_SIZE (200 * 200 * 2)
#define FLASH_VIEW_MAX_SIZE (200 * 200 * 2)
#define PER_PIC_MAX_SPACE_TFT35 (9 * 1024)
#if HAS_SPI_FLASH_COMPRESSION
#define PER_PIC_MAX_SPACE_TFT35 ( 9 * 1024)
#else
#define PER_PIC_MAX_SPACE_TFT35 (32 * 1024)
#endif
#define PER_PIC_MAX_SPACE_TFT32 (16 * 1024)
#define PER_FONT_MAX_SPACE (16 * 1024)
@ -154,6 +162,9 @@ typedef struct pic_msg PIC_MSG;
#define PIC_SIZE_xM 6
#define FONT_SIZE_xM 2
#if ENABLED(USE_HASH_TABLE)
void init_img_map();
#endif
void picRead(uint8_t *Pname, uint8_t *P_Rbuff);
void picLogoRead(uint8_t *LogoName, uint8_t *Logo_Rbuff, uint32_t LogoReadsize);
void lv_pic_test(uint8_t *P_Rbuff, uint32_t addr, uint32_t size);

27
Marlin/src/lcd/extui/mks_ui/tft_lvgl_configuration.cpp
View file

@ -85,7 +85,7 @@ lv_group_t* g;
uint16_t DeviceCode = 0x9488;
extern uint8_t sel_id;
uint8_t bmp_public_buf[14 * 1024];
uint8_t bmp_public_buf[16 * 1024];
uint8_t public_buf[513];
extern bool flash_preview_begin, default_preview_flg, gcode_preview_over;
@ -149,9 +149,14 @@ void tft_lvgl_init() {
touch.init();
#if ENABLED(USE_HASH_TABLE)
init_img_map(); // Initialize the image address hash table
hal.watchdog_refresh(); // Hash table init takes time
#endif
lv_init();
lv_disp_buf_init(&disp_buf, bmp_public_buf, nullptr, LV_HOR_RES_MAX * 14); // Initialize the display buffer
lv_disp_buf_init(&disp_buf, bmp_public_buf, nullptr, LV_HOR_RES_MAX * 17); // Initialize the display buffer
lv_disp_drv_t disp_drv; // Descriptor of a display driver
lv_disp_drv_init(&disp_drv); // Basic initialization
@ -268,8 +273,6 @@ void my_disp_flush(lv_disp_drv_t * disp, const lv_area_t * area, lv_color_t * co
SPI_TFT.tftio.writeSequence((uint16_t*)color_p, width * height);
lv_disp_flush_ready(disp_drv_p); // Indicate you are ready with the flushing
#endif
W25QXX.init(SPI_QUARTER_SPEED);
}
#if ENABLED(USE_SPI_DMA_TC)
@ -327,20 +330,26 @@ bool my_mousewheel_read(lv_indev_drv_t * indev_drv, lv_indev_data_t * data) {
return false; // No more data to read so return false
}
extern uint8_t currentFlashPage;
#if HAS_SPI_FLASH_COMPRESSION
extern uint8_t currentFlashPage;
#endif
// spi_flash
uint32_t pic_read_base_addr = 0, pic_read_addr_offset = 0;
lv_fs_res_t spi_flash_open_cb (lv_fs_drv_t * drv, void * file_p, const char * path, lv_fs_mode_t mode) {
static char last_path_name[30];
#if HAS_SPI_FLASH_COMPRESSION
currentFlashPage = 0;
#endif
if (strcasecmp(last_path_name, path) != 0) {
pic_read_base_addr = lv_get_pic_addr((uint8_t *)path);
// clean lvgl image cache
char cache_path_name[30 + 3] = {0};
strcat(cache_path_name, "F:/");
strcat(cache_path_name, (const char *)last_path_name);
lv_img_cache_invalidate_src(cache_path_name);
strcpy(last_path_name, path);
}
else {
W25QXX.init(SPI_QUARTER_SPEED);
currentFlashPage = 0;
}
pic_read_addr_offset = pic_read_base_addr;
return LV_FS_RES_OK;
}

2
Marlin/src/lcd/extui/mks_ui/tft_lvgl_configuration.h
View file

@ -32,7 +32,7 @@
#include <lvgl.h>
extern uint8_t bmp_public_buf[14 * 1024];
extern uint8_t bmp_public_buf[16 * 1024];
extern uint8_t public_buf[513];
void tft_lvgl_init();

1137
Marlin/src/lcd/extui/mks_ui/uthash.h Normal file
View file

File diff suppressed because it is too large Load diff

8
Marlin/src/lcd/extui/ui_api.cpp
View file

@ -643,12 +643,12 @@ namespace ExtUI {
#if ENABLED(LIN_ADVANCE)
float getLinearAdvance_mm_mm_s(const extruder_t extruder) {
return (extruder < EXTRUDERS) ? planner.extruder_advance_K[E_INDEX_N(extruder - E0)] : 0;
return (extruder < EXTRUDERS) ? planner.get_advance_k(E_INDEX_N(extruder - E0)) : 0;
}
void setLinearAdvance_mm_mm_s(const_float_t value, const extruder_t extruder) {
if (extruder < EXTRUDERS)
planner.extruder_advance_K[E_INDEX_N(extruder - E0)] = constrain(value, 0, 10);
planner.set_advance_k(constrain(value, 0, 10), E_INDEX_N(extruder - E0));
}
#endif
@ -887,14 +887,14 @@ namespace ExtUI {
y_target = MESH_MIN_Y + pos.y * (MESH_Y_DIST);
if (x_target != current_position.x || y_target != current_position.y) {
// If moving across bed, raise nozzle to safe height over bed
feedrate_mm_s = MMM_TO_MMS(Z_PROBE_FEEDRATE_FAST);
feedrate_mm_s = z_probe_fast_mm_s;
destination.set(current_position.x, current_position.y, Z_CLEARANCE_BETWEEN_PROBES);
prepare_line_to_destination();
if (XY_PROBE_FEEDRATE_MM_S) feedrate_mm_s = XY_PROBE_FEEDRATE_MM_S;
destination.set(x_target, y_target);
prepare_line_to_destination();
}
feedrate_mm_s = MMM_TO_MMS(Z_PROBE_FEEDRATE_FAST);
feedrate_mm_s = z_probe_fast_mm_s;
destination.z = z;
prepare_line_to_destination();
#else

7
Marlin/src/lcd/language/language_cz.h
View file

@ -45,13 +45,14 @@ namespace LanguageNarrow_cz {
LSTR MSG_YES = _UxGT("ANO");
LSTR MSG_NO = _UxGT("NE");
LSTR MSG_BACK = _UxGT("Zpět");
LSTR MSG_MEDIA_ABORTING = _UxGT("Rušení...");
LSTR MSG_MEDIA_INSERTED = _UxGT("Médium vloženo");
LSTR MSG_MEDIA_REMOVED = _UxGT("Médium vyjmuto");
LSTR MSG_MEDIA_WAITING = _UxGT("Čekání na médium");
LSTR MSG_MEDIA_READ_ERROR = _UxGT("Chyba čtení média");
LSTR MSG_MEDIA_USB_REMOVED = _UxGT("USB odstraněno");
LSTR MSG_MEDIA_USB_FAILED = _UxGT("Chyba USB");
LSTR MSG_USB_FD_DEVICE_REMOVED = _UxGT("USB odstraněno");
LSTR MSG_USB_FD_USB_FAILED = _UxGT("Chyba USB");
LSTR MSG_LCD_ENDSTOPS = _UxGT("Endstopy"); // max 8 znaku
LSTR MSG_LCD_SOFT_ENDSTOPS = _UxGT("Soft Endstopy");
LSTR MSG_MAIN_MENU = _UxGT("Hlavní nabídka");

7
Marlin/src/lcd/language/language_de.h
View file

@ -41,15 +41,16 @@ namespace LanguageNarrow_de {
LSTR MSG_LOW = _UxGT("RUNTER");
LSTR MSG_BACK = _UxGT("Zurück");
LSTR MSG_ERROR = _UxGT("Fehler");
LSTR MSG_MEDIA_ABORTING = _UxGT("Abbruch...");
LSTR MSG_MEDIA_INSERTED = _UxGT("Medium erkannt");
LSTR MSG_MEDIA_REMOVED = _UxGT("Medium entfernt");
LSTR MSG_MEDIA_WAITING = _UxGT("Warten auf Medium");
LSTR MSG_MEDIA_INIT_FAIL = _UxGT("Medium Init fehlgesch.");
LSTR MSG_MEDIA_READ_ERROR = _UxGT("Medium Lesefehler");
LSTR MSG_MEDIA_USB_REMOVED = _UxGT("USB Gerät entfernt");
LSTR MSG_MEDIA_USB_FAILED = _UxGT("USB Start fehlge.");
LSTR MSG_USB_FD_DEVICE_REMOVED = _UxGT("USB Gerät entfernt");
LSTR MSG_USB_FD_USB_FAILED = _UxGT("USB Start fehlge.");
LSTR MSG_KILL_SUBCALL_OVERFLOW = _UxGT("Subcall überschritten");
LSTR MSG_LCD_ENDSTOPS = _UxGT("Endstopp"); // Max length 8 characters
LSTR MSG_LCD_SOFT_ENDSTOPS = _UxGT("Software-Endstopp");
LSTR MSG_MAIN_MENU = _UxGT("Hauptmenü");

8
Marlin/src/lcd/language/language_el.h
View file

@ -45,12 +45,12 @@ namespace LanguageNarrow_el {
LSTR MSG_MEDIA_INSERTED = _UxGT("Κάρτα εισήχθη");
LSTR MSG_MEDIA_REMOVED = _UxGT("Κάρτα αφαιρέθη");
LSTR MSG_MEDIA_WAITING = _UxGT("Αναμονή για κάρτα");
LSTR MSG_MEDIA_ABORTING = _UxGT("Ματαίωση...");
LSTR MSG_MEDIA_READ_ERROR = MEDIA_TYPE_EN _UxGT(" σφάλμα ανάγνωσης");
LSTR MSG_MEDIA_USB_REMOVED = _UxGT("USB αφαιρέθη");
LSTR MSG_MEDIA_USB_FAILED = _UxGT("Αποτυχία εκκίνησης USB");
LSTR MSG_MEDIA_INIT_FAIL = _UxGT("Αποτυχία αρχικοποίησης SD");
LSTR MSG_MEDIA_READ_ERROR = MEDIA_TYPE_EN _UxGT(" σφάλμα ανάγνωσης");
LSTR MSG_USB_FD_DEVICE_REMOVED = _UxGT("USB αφαιρέθη");
LSTR MSG_USB_FD_USB_FAILED = _UxGT("Αποτυχία εκκίνησης USB");
LSTR MSG_MAIN_MENU = _UxGT("Αρχική Οθόνη");
LSTR MSG_DISABLE_STEPPERS = _UxGT("Απενεργοποίηση μοτέρ");
LSTR MSG_AUTO_HOME = _UxGT("Αυτόμ. επαναφορά XYZ");

13
Marlin/src/lcd/language/language_en.h
View file

@ -90,17 +90,16 @@ namespace LanguageNarrow_en {
LSTR MSG_MEDIA_REMOVED = MEDIA_TYPE_EN _UxGT(" Removed");
LSTR MSG_MEDIA_REMOVED_SD = _UxGT("SD Card Removed");
LSTR MSG_MEDIA_REMOVED_USB = _UxGT("USB Drive Removed");
LSTR MSG_MEDIA_WAITING = _UxGT("Waiting for ") MEDIA_TYPE_EN;
LSTR MSG_MEDIA_WAITING_SD = _UxGT("Waiting for SD Card");
LSTR MSG_MEDIA_WAITING_USB = _UxGT("Waiting for USB Drive");
LSTR MSG_MEDIA_INIT_FAIL = MEDIA_TYPE_EN _UxGT(" Init Fail");
LSTR MSG_MEDIA_INIT_FAIL_SD = _UxGT("SD Card Init Fail");
LSTR MSG_MEDIA_INIT_FAIL_USB = _UxGT("USB Drive Init Fail");
LSTR MSG_MEDIA_READ_ERROR = MEDIA_TYPE_EN _UxGT(" read error");
LSTR MSG_MEDIA_USB_REMOVED = _UxGT("USB device removed");
LSTR MSG_MEDIA_USB_FAILED = _UxGT("USB start failed");
LSTR MSG_MEDIA_SORT = _UxGT("Sort ") MEDIA_TYPE_EN;
LSTR MSG_MEDIA_UPDATE = MEDIA_TYPE_EN _UxGT(" Update");
LSTR MSG_USB_FD_WAITING_FOR_MEDIA = _UxGT("Wait for USB Drive");
LSTR MSG_USB_FD_MEDIA_REMOVED = _UxGT("USB Drive Removed");
LSTR MSG_USB_FD_DEVICE_REMOVED = _UxGT("USB device removed");
LSTR MSG_USB_FD_USB_FAILED = _UxGT("USB start failed");
LSTR MSG_KILL_SUBCALL_OVERFLOW = _UxGT("Subcall Overflow");
LSTR MSG_LCD_ENDSTOPS = _UxGT("Endstops"); // Max length 8 characters
@ -365,7 +364,7 @@ namespace LanguageNarrow_en {
LSTR MSG_MOVE_N_MM = _UxGT("Move $mm");
LSTR MSG_MOVE_N_IN = _UxGT("Move $in");
LSTR MSG_MOVE_N_DEG = _UxGT("Move $") LCD_STR_DEGREE;
LSTR MSG_LIVE_MOVE = _UxGT("Live Move");
LSTR MSG_LIVE_MOVE = _UxGT("Live Movement");
LSTR MSG_SPEED = _UxGT("Speed");
LSTR MSG_MESH_Z_OFFSET = _UxGT("Bed Z");
LSTR MSG_NOZZLE = _UxGT("Nozzle");
@ -510,6 +509,7 @@ namespace LanguageNarrow_en {
LSTR MSG_ADVANCE_TAU = _UxGT("Advance Tau");
LSTR MSG_ADVANCE_K_E = _UxGT("Advance K *");
LSTR MSG_ADVANCE_TAU_E = _UxGT("Advance Tau *");
LSTR MSG_NLE_ON = _UxGT("NLE enabled");
LSTR MSG_CONTRAST = _UxGT("LCD Contrast");
LSTR MSG_BRIGHTNESS = _UxGT("LCD Brightness");
LSTR MSG_SCREEN_TIMEOUT = _UxGT("LCD Timeout (m)");
@ -1125,7 +1125,6 @@ namespace LanguageNarrow_en {
namespace LanguageWide_en {
using namespace LanguageNarrow_en;
#if LCD_WIDTH >= 20 || HAS_DWIN_E3V2
LSTR MSG_LIVE_MOVE = _UxGT("Live Movement");
LSTR MSG_HOST_START_PRINT = _UxGT("Start Host Print");
LSTR MSG_PRINTING_OBJECT = _UxGT("Printing Object");
LSTR MSG_CANCEL_OBJECT = _UxGT("Cancel Object");

7
Marlin/src/lcd/language/language_es.h
View file

@ -46,15 +46,16 @@ namespace LanguageNarrow_es {
LSTR MSG_YES = _UxGT("SI");
LSTR MSG_NO = _UxGT("NO");
LSTR MSG_BACK = _UxGT("Atrás");
LSTR MSG_MEDIA_ABORTING = _UxGT("Cancelando...");
LSTR MSG_MEDIA_INSERTED = MEDIA_TYPE_ES _UxGT(" insertado");
LSTR MSG_MEDIA_REMOVED = MEDIA_TYPE_ES _UxGT(" retirado");
LSTR MSG_MEDIA_WAITING = _UxGT("Esperando al ") MEDIA_TYPE_ES;
LSTR MSG_MEDIA_INIT_FAIL = _UxGT("Fallo al iniciar ") MEDIA_TYPE_ES;
LSTR MSG_MEDIA_READ_ERROR = _UxGT("Error lectura ") MEDIA_TYPE_ES;
LSTR MSG_MEDIA_USB_REMOVED = _UxGT("Disp. USB retirado");
LSTR MSG_MEDIA_USB_FAILED = _UxGT("Inicio USB fallido");
LSTR MSG_USB_FD_DEVICE_REMOVED = _UxGT("Disp. USB retirado");
LSTR MSG_USB_FD_USB_FAILED = _UxGT("Inicio USB fallido");
LSTR MSG_KILL_SUBCALL_OVERFLOW = _UxGT("Desbordamiento de subllamada");
LSTR MSG_LCD_ENDSTOPS = _UxGT("Endstops"); // Max length 8 characters
LSTR MSG_LCD_SOFT_ENDSTOPS = _UxGT("Soft Endstops");
LSTR MSG_MAIN_MENU = _UxGT("Menú principal");

7
Marlin/src/lcd/language/language_fr.h
View file

@ -40,13 +40,14 @@ namespace LanguageNarrow_fr {
LSTR MSG_YES = _UxGT("Oui");
LSTR MSG_NO = _UxGT("Non");
LSTR MSG_BACK = _UxGT("Retour");
LSTR MSG_MEDIA_ABORTING = _UxGT("Annulation...");
LSTR MSG_MEDIA_INSERTED = _UxGT("Média inséré");
LSTR MSG_MEDIA_REMOVED = _UxGT("Média retiré");
LSTR MSG_MEDIA_WAITING = _UxGT("Attente média");
LSTR MSG_MEDIA_READ_ERROR = _UxGT("Err lecture média");
LSTR MSG_MEDIA_USB_REMOVED = _UxGT("USB débranché");
LSTR MSG_MEDIA_USB_FAILED = _UxGT("Erreur média USB");
LSTR MSG_USB_FD_DEVICE_REMOVED = _UxGT("USB débranché");
LSTR MSG_USB_FD_USB_FAILED = _UxGT("Erreur média USB");
LSTR MSG_LCD_ENDSTOPS = _UxGT("Butées");
LSTR MSG_LCD_SOFT_ENDSTOPS = _UxGT("Butées SW");
LSTR MSG_MAIN_MENU = _UxGT("Menu principal");

7
Marlin/src/lcd/language/language_fr_na.h
View file

@ -40,13 +40,14 @@ namespace LanguageNarrow_fr_na {
LSTR MSG_YES = _UxGT("Oui");
LSTR MSG_NO = _UxGT("Non");
LSTR MSG_BACK = _UxGT("Retour");
LSTR MSG_MEDIA_ABORTING = _UxGT("Annulation...");
LSTR MSG_MEDIA_INSERTED = _UxGT("Media insere");
LSTR MSG_MEDIA_REMOVED = _UxGT("Media retire");
LSTR MSG_MEDIA_WAITING = _UxGT("Attente media");
LSTR MSG_MEDIA_READ_ERROR = _UxGT("Err lecture media");
LSTR MSG_MEDIA_USB_REMOVED = _UxGT("USB debranche");
LSTR MSG_MEDIA_USB_FAILED = _UxGT("Erreur media USB");
LSTR MSG_USB_FD_DEVICE_REMOVED = _UxGT("USB debranche");
LSTR MSG_USB_FD_USB_FAILED = _UxGT("Erreur media USB");
LSTR MSG_LCD_ENDSTOPS = _UxGT("Butees");
LSTR MSG_LCD_SOFT_ENDSTOPS = _UxGT("Butees SW");
LSTR MSG_MAIN_MENU = _UxGT("Menu principal");

7
Marlin/src/lcd/language/language_gl.h
View file

@ -48,14 +48,15 @@ namespace LanguageNarrow_gl {
LSTR MSG_YES = _UxGT("SI");
LSTR MSG_NO = _UxGT("NON");
LSTR MSG_BACK = _UxGT("Atrás");
LSTR MSG_MEDIA_ABORTING = _UxGT("Cancelando...");
LSTR MSG_MEDIA_INSERTED = _UxGT("Tarxeta inserida");
LSTR MSG_MEDIA_REMOVED = _UxGT("Tarxeta retirada");
LSTR MSG_MEDIA_WAITING = _UxGT("Agardando ao ") MEDIA_TYPE_GL;
LSTR MSG_MEDIA_READ_ERROR = _UxGT("Erro lectura ") MEDIA_TYPE_GL;
LSTR MSG_MEDIA_USB_REMOVED = _UxGT("Disp. USB retirado");
LSTR MSG_MEDIA_USB_FAILED = _UxGT("Inicio USB fallido");
LSTR MSG_USB_FD_DEVICE_REMOVED = _UxGT("Disp. USB retirado");
LSTR MSG_USB_FD_USB_FAILED = _UxGT("Inicio USB fallido");
LSTR MSG_KILL_SUBCALL_OVERFLOW = _UxGT("Desbord. Subch.");
LSTR MSG_LCD_ENDSTOPS = _UxGT("FinCarro");
LSTR MSG_LCD_SOFT_ENDSTOPS = _UxGT("FinCarro SW");
LSTR MSG_MAIN_MENU = _UxGT("Menú principal");

7
Marlin/src/lcd/language/language_hu.h
View file

@ -43,15 +43,16 @@ namespace LanguageNarrow_hu {
LSTR MSG_YES = _UxGT("IGEN");
LSTR MSG_NO = _UxGT("NEM");
LSTR MSG_BACK = _UxGT("Vissza");
LSTR MSG_MEDIA_ABORTING = _UxGT("Megszakítás...");
LSTR MSG_MEDIA_INSERTED = _UxGT("Tároló behelyezve");
LSTR MSG_MEDIA_REMOVED = _UxGT("Tároló eltávolítva");
LSTR MSG_MEDIA_WAITING = _UxGT("Várakozás a tárolóra");
LSTR MSG_MEDIA_INIT_FAIL = _UxGT("Tároló-kártya hiba");
LSTR MSG_MEDIA_READ_ERROR = _UxGT("Tároló olvasási hiba");
LSTR MSG_MEDIA_USB_REMOVED = _UxGT("USB eltávolítva");
LSTR MSG_MEDIA_USB_FAILED = _UxGT("USB eszköz hiba");
LSTR MSG_USB_FD_DEVICE_REMOVED = _UxGT("USB eltávolítva");
LSTR MSG_USB_FD_USB_FAILED = _UxGT("USB eszköz hiba");
LSTR MSG_KILL_SUBCALL_OVERFLOW = _UxGT("Túlfolyás");
LSTR MSG_LCD_ENDSTOPS = _UxGT("Végállás"); // Maximum 8 karakter
LSTR MSG_LCD_SOFT_ENDSTOPS = _UxGT("Szoft. végállás");
LSTR MSG_MAIN_MENU = _UxGT("<Fömenü>");

120
Marlin/src/lcd/language/language_it.h
View file

@ -59,16 +59,25 @@ namespace LanguageNarrow_it {
LSTR MSG_LOW = _UxGT("BASSO");
LSTR MSG_BACK = _UxGT("Indietro");
LSTR MSG_ERROR = _UxGT("Errore");
LSTR MSG_MEDIA_ABORTING = _UxGT("Annullando...");
LSTR MSG_MEDIA_INSERTED = MEDIA_TYPE_IT _UxGT(" inserito");
LSTR MSG_MEDIA_REMOVED = MEDIA_TYPE_IT _UxGT(" rimosso");
LSTR MSG_MEDIA_WAITING = _UxGT("Aspettando ") MEDIA_TYPE_IT;
LSTR MSG_MEDIA_INSERTED = MEDIA_TYPE_IT _UxGT(" inserita");
LSTR MSG_MEDIA_INSERTED_SD = _UxGT("Scheda SD inserita");
LSTR MSG_MEDIA_INSERTED_USB = _UxGT("Unità USB inserita");
LSTR MSG_MEDIA_REMOVED = MEDIA_TYPE_IT _UxGT(" rimossa");
LSTR MSG_MEDIA_REMOVED_SD = _UxGT("Scheda SD rimossa");
LSTR MSG_MEDIA_REMOVED_USB = _UxGT("Unità USB rimossa");
LSTR MSG_MEDIA_INIT_FAIL = _UxGT("Iniz.") MEDIA_TYPE_IT _UxGT(" fallita");
LSTR MSG_MEDIA_INIT_FAIL_SD = _UxGT("Iniz. SD fallita");
LSTR MSG_MEDIA_INIT_FAIL_USB = _UxGT("Iniz. USB fallita");
LSTR MSG_MEDIA_READ_ERROR = _UxGT("Err.leggendo ") MEDIA_TYPE_IT;
LSTR MSG_MEDIA_USB_REMOVED = _UxGT("Dispos.USB rimosso");
LSTR MSG_MEDIA_USB_FAILED = _UxGT("Avvio USB fallito");
LSTR MSG_MEDIA_SORT = _UxGT("Ordina ") MEDIA_TYPE_IT;
LSTR MSG_MEDIA_UPDATE = _UxGT("Aggiorna ") MEDIA_TYPE_IT;
LSTR MSG_USB_FD_WAITING_FOR_MEDIA = _UxGT("In attesa unità USB");
LSTR MSG_USB_FD_MEDIA_REMOVED = _UxGT("Unità USB rimossa");
LSTR MSG_USB_FD_DEVICE_REMOVED = _UxGT("Unità USB rimossa");
LSTR MSG_USB_FD_USB_FAILED = _UxGT("Iniz. USB fallita");
LSTR MSG_KILL_SUBCALL_OVERFLOW = _UxGT("Overflow sottochiamate");
LSTR MSG_LCD_ENDSTOPS = _UxGT("Finecor."); // Max 8 characters
LSTR MSG_LCD_SOFT_ENDSTOPS = _UxGT("Finecorsa soft");
@ -133,11 +142,12 @@ namespace LanguageNarrow_it {
LSTR MSG_PREHEAT_M = _UxGT("Preriscalda $");
LSTR MSG_PREHEAT_M_H = _UxGT("Preriscalda $ ~");
LSTR MSG_PREHEAT_M_END = _UxGT("Preris.$ ugello");
LSTR MSG_PREHEAT_M_END_E = _UxGT("Preris.$ ugello ~");
LSTR MSG_PREHEAT_M_ALL = _UxGT("Preris.$ tutto");
LSTR MSG_PREHEAT_M_BEDONLY = _UxGT("Preris.$ piatto");
LSTR MSG_PREHEAT_M_SETTINGS = _UxGT("Preris.$ conf");
LSTR MSG_PREHEAT_M_END = _UxGT("Preris.ugello $");
LSTR MSG_PREHEAT_M_END_E = _UxGT("Preris.ugello ~ $");
LSTR MSG_PREHEAT_M_ALL = _UxGT("Preris.tutto $");
LSTR MSG_PREHEAT_M_BEDONLY = _UxGT("Preris.piatto $");
LSTR MSG_PREHEAT_M_CHAMBER = _UxGT("Preris.camera $");
LSTR MSG_PREHEAT_M_SETTINGS = _UxGT("Preris.conf $");
LSTR MSG_PREHEAT_HOTEND = _UxGT("Prerisc.ugello");
LSTR MSG_PREHEAT_CUSTOM = _UxGT("Prerisc.personal.");
@ -161,6 +171,7 @@ namespace LanguageNarrow_it {
LSTR MSG_SPINDLE_REVERSE = _UxGT("Inverti mandrino");
LSTR MSG_SWITCH_PS_ON = _UxGT("Accendi aliment.");
LSTR MSG_SWITCH_PS_OFF = _UxGT("Spegni aliment.");
LSTR MSG_POWER_EDM_FAULT = _UxGT("Anomalia alim.EDM");
LSTR MSG_EXTRUDE = _UxGT("Estrudi");
LSTR MSG_RETRACT = _UxGT("Ritrai");
LSTR MSG_MOVE_AXIS = _UxGT("Muovi asse");
@ -178,6 +189,7 @@ namespace LanguageNarrow_it {
LSTR MSG_MESH_VIEWER = _UxGT("Visualiz. mesh");
LSTR MSG_EDIT_MESH = _UxGT("Modifica mesh");
LSTR MSG_MESH_VIEW = _UxGT("Visualizza mesh");
LSTR MSG_MESH_VIEW_GRID = _UxGT("Vis.mesh (griglia)");
LSTR MSG_EDITING_STOPPED = _UxGT("Modif. mesh fermata");
LSTR MSG_NO_VALID_MESH = _UxGT("Mesh non valida");
LSTR MSG_ACTIVATE_MESH = _UxGT("Attiva livellamento");
@ -201,7 +213,9 @@ namespace LanguageNarrow_it {
LSTR MSG_M48_TEST = _UxGT("Test sonda M48");
LSTR MSG_M48_POINT = _UxGT("Punto M48");
LSTR MSG_M48_OUT_OF_BOUNDS = _UxGT("Sonda oltre i limiti");
LSTR MSG_M48_DEV = _UxGT("Dev");
LSTR MSG_M48_DEVIATION = _UxGT("Deviazione");
LSTR MSG_M48_MAX_DELTA = _UxGT("Delta max");
LSTR MSG_IDEX_MENU = _UxGT("Modo IDEX");
LSTR MSG_OFFSETS_MENU = _UxGT("Strumenti offsets");
LSTR MSG_IDEX_MODE_AUTOPARK = _UxGT("Auto-Park");
@ -327,7 +341,7 @@ namespace LanguageNarrow_it {
LSTR MSG_MOVE_N_MM = _UxGT("Muovi di $mm");
LSTR MSG_MOVE_N_IN = _UxGT("Muovi di $in");
LSTR MSG_MOVE_N_DEG = _UxGT("Muovi di $") LCD_STR_DEGREE;
LSTR MSG_LIVE_MOVE = _UxGT("Modalità live");
LSTR MSG_LIVE_MOVE = _UxGT("Movimento live");
LSTR MSG_SPEED = _UxGT("Velocità");
LSTR MSG_MESH_Z_OFFSET = _UxGT("Piatto Z");
LSTR MSG_NOZZLE = _UxGT("Ugello");
@ -428,6 +442,7 @@ namespace LanguageNarrow_it {
LSTR MSG_AMAX_EN = _UxGT("Acc.massima *");
LSTR MSG_A_RETRACT = _UxGT("A-Ritrazione");
LSTR MSG_A_TRAVEL = _UxGT("A-Spostamento");
LSTR MSG_A_SPINDLE = _UxGT("Acc.mandrino");
LSTR MSG_INPUT_SHAPING = _UxGT("Input shaping");
LSTR MSG_SHAPING_ENABLE_N = _UxGT("Abilita shaping @");
LSTR MSG_SHAPING_DISABLE_N = _UxGT("Disabil. shaping @");
@ -466,8 +481,10 @@ namespace LanguageNarrow_it {
LSTR MSG_DRAW_MAX_Y = _UxGT("Max Y area disegno");
LSTR MSG_MAX_BELT_LEN = _UxGT("Lungh.max cinghia");
LSTR MSG_LINEAR_ADVANCE = _UxGT("Avanzam.lineare");
LSTR MSG_ADVANCE_K = _UxGT("K Avanzamento");
LSTR MSG_ADVANCE_K_E = _UxGT("K Avanzamento *");
LSTR MSG_ADVANCE_K = _UxGT("K advance");
LSTR MSG_ADVANCE_TAU = _UxGT("Tau advance");
LSTR MSG_ADVANCE_K_E = _UxGT("K advance *");
LSTR MSG_ADVANCE_TAU_E = _UxGT("Tau advance *");
LSTR MSG_CONTRAST = _UxGT("Contrasto LCD");
LSTR MSG_BRIGHTNESS = _UxGT("Luminosità LCD");
LSTR MSG_SCREEN_TIMEOUT = _UxGT("Timeout LCD (m)");
@ -532,10 +549,8 @@ namespace LanguageNarrow_it {
LSTR MSG_CANCEL_OBJECT = _UxGT("Cancella oggetto");
LSTR MSG_CANCEL_OBJECT_N = _UxGT("Canc. oggetto {");
LSTR MSG_CONTINUE_PRINT_JOB = _UxGT("Cont.proc.stampa");
LSTR MSG_MEDIA_MENU = _UxGT("Stampa da ") MEDIA_TYPE_IT;
LSTR MSG_TURN_OFF = _UxGT("Spegni stampante");
LSTR MSG_END_LOOPS = _UxGT("Fine cicli di rip.");
LSTR MSG_NO_MEDIA = MEDIA_TYPE_IT _UxGT(" non presente");
LSTR MSG_DWELL = _UxGT("Sospensione...");
LSTR MSG_USERWAIT = _UxGT("Premi tasto..");
LSTR MSG_PRINT_PAUSED = _UxGT("Stampa sospesa");
@ -589,10 +604,20 @@ namespace LanguageNarrow_it {
LSTR MSG_ATTACH_MEDIA = _UxGT("Collega ") MEDIA_TYPE_IT;
LSTR MSG_ATTACH_SD = _UxGT("Collega scheda SD");
LSTR MSG_ATTACH_USB = _UxGT("Collega penna USB");
LSTR MSG_CHANGE_MEDIA = _UxGT("Cambia ") MEDIA_TYPE_IT;
LSTR MSG_ATTACH_USB = _UxGT("Collega unità USB");
LSTR MSG_RELEASE_MEDIA = _UxGT("Rilascia ") MEDIA_TYPE_IT;
LSTR MSG_RUN_AUTOFILES = _UxGT("Esegui files auto");
LSTR MSG_RELEASE_SD = _UxGT("Rilascia scheda SD");
LSTR MSG_RELEASE_USB = _UxGT("Rilascia unità USB");
LSTR MSG_CHANGE_MEDIA = _UxGT("Selez.") MEDIA_TYPE_IT;
LSTR MSG_CHANGE_SD = _UxGT("Selez. scheda SD");
LSTR MSG_CHANGE_USB = _UxGT("Selez. unità USB");
LSTR MSG_RUN_AUTOFILES = _UxGT("Esegui Autofiles");
LSTR MSG_RUN_AUTOFILES_SD = _UxGT("Esegui Autofiles SD");
LSTR MSG_RUN_AUTOFILES_USB = _UxGT("Esegui Autofiles USB");
LSTR MSG_MEDIA_MENU = _UxGT("Stampa da ") MEDIA_TYPE_IT;
LSTR MSG_MEDIA_MENU_SD = _UxGT("Selez. da SD");
LSTR MSG_MEDIA_MENU_USB = _UxGT("Selez. da USB");
LSTR MSG_NO_MEDIA = MEDIA_TYPE_IT _UxGT(" non rilevato");
LSTR MSG_ZPROBE_OUT = _UxGT("Z probe fuori piatto");
LSTR MSG_SKEW_FACTOR = _UxGT("Fattore distorsione");
@ -848,6 +873,7 @@ namespace LanguageNarrow_it {
LSTR MSG_FILAMENT_CHANGE_PURGE = _UxGT(MSG_1_LINE("Spurgo filamento"));
LSTR MSG_FILAMENT_CHANGE_CONT_PURGE = _UxGT(MSG_1_LINE("Premi x terminare"));
LSTR MSG_FILAMENT_CHANGE_RESUME = _UxGT(MSG_1_LINE("Ripresa..."));
LSTR MSG_TMC_DRIVERS = _UxGT("Driver TMC");
LSTR MSG_TMC_CURRENT = _UxGT("Corrente driver");
LSTR MSG_TMC_ACURRENT = _UxGT("Corrente driver ") STR_A;
@ -858,6 +884,7 @@ namespace LanguageNarrow_it {
LSTR MSG_TMC_HOMING_THRS = _UxGT("Sensorless homing");
LSTR MSG_TMC_STEPPING_MODE = _UxGT("Modo Stepping");
LSTR MSG_TMC_STEALTHCHOP = _UxGT("StealthChop");
LSTR MSG_TMC_HOMING_CURRENT = _UxGT("Corrente homing");
LSTR MSG_SERVICE_RESET = _UxGT("Resetta");
LSTR MSG_SERVICE_IN = _UxGT(" tra:");
@ -897,6 +924,7 @@ namespace LanguageNarrow_it {
LSTR MSG_BOTTOM_LEFT = _UxGT("Basso sinistra");
LSTR MSG_TOP_RIGHT = _UxGT("Alto destra");
LSTR MSG_BOTTOM_RIGHT = _UxGT("Basso destra");
LSTR MSG_TOUCH_CALIBRATION = _UxGT("Calibrazione touch");
LSTR MSG_CALIBRATION_COMPLETED = _UxGT("Calibrazione completata");
LSTR MSG_CALIBRATION_FAILED = _UxGT("Calibrazione fallita");
@ -907,7 +935,7 @@ namespace LanguageNarrow_it {
LSTR MSG_HOST_SHUTDOWN = _UxGT("Arresta host");
// DGUS-Specific message strings, not used elsewhere
// DGUS-Specific message strings, not used elsewhere
LSTR DGUS_MSG_NOT_WHILE_PRINTING = _UxGT("Non ammesso durante la stampa");
LSTR DGUS_MSG_NOT_WHILE_IDLE = _UxGT("Non ammesso mentre è in riposo");
LSTR DGUS_MSG_NO_FILE_SELECTED = _UxGT("Nessun file selezionato");
@ -939,17 +967,55 @@ namespace LanguageNarrow_it {
LSTR MSG_BTN_STOP = _UxGT("Stop");
LSTR MSG_BTN_DISABLE_MMU = _UxGT("Disabilita");
LSTR MSG_BTN_MORE = _UxGT("Più info");
// Prusa MMU
LSTR MSG_DONE = _UxGT("Eseguito");
LSTR MSG_FINISHING_MOVEMENTS = _UxGT("Termina movimenti");
LSTR MSG_LOADING_FILAMENT = _UxGT("Carica. filamento");
LSTR MSG_UNLOADING_FILAMENT = _UxGT("Scarico filamento");
LSTR MSG_TESTING_FILAMENT = _UxGT("Testando filamento");
LSTR MSG_EJECT_FROM_MMU = _UxGT("Espelli da MMU");
LSTR MSG_CUT_FILAMENT = _UxGT("Taglia filamento");
LSTR MSG_OFF = _UxGT("Off");
LSTR MSG_ON = _UxGT("On");
LSTR MSG_PROGRESS_OK = _UxGT("OK");
LSTR MSG_PROGRESS_ENGAGE_IDLER = _UxGT("Innesto idler");
LSTR MSG_PROGRESS_DISENGAGE_IDLER = _UxGT("Disinnesto idler");
LSTR MSG_PROGRESS_UNLOAD_FINDA = _UxGT("Scarico a FINDA");
LSTR MSG_PROGRESS_UNLOAD_PULLEY = _UxGT("Scarico a puleggia");
LSTR MSG_PROGRESS_FEED_FINDA = _UxGT("Alim. a FINDA");
LSTR MSG_PROGRESS_FEED_EXTRUDER = _UxGT("Alim. all'estrusore");
LSTR MSG_PROGRESS_FEED_NOZZLE = _UxGT("Alim. all'ugello");
LSTR MSG_PROGRESS_AVOID_GRIND = _UxGT("Evita grind");
LSTR MSG_PROGRESS_WAIT_USER = _UxGT("ERR attesa utente");
LSTR MSG_PROGRESS_ERR_INTERNAL = _UxGT("ERR interno");
LSTR MSG_PROGRESS_ERR_HELP_FIL = _UxGT("ERR aiuto filamento");
LSTR MSG_PROGRESS_ERR_TMC = _UxGT("ERR anomalia TMC");
LSTR MSG_PROGRESS_SELECT_SLOT = _UxGT("Selez.slot filam.");
LSTR MSG_PROGRESS_PREPARE_BLADE = _UxGT("Preparaz.lama");
LSTR MSG_PROGRESS_PUSH_FILAMENT = _UxGT("Spinta fialmento");
LSTR MSG_PROGRESS_PERFORM_CUT = _UxGT("Esecuzione taglio");
LSTR MSG_PROGRESSPSTRETURN_SELECTOR = _UxGT("Ritorno selettore");
LSTR MSG_PROGRESS_PARK_SELECTOR = _UxGT("Parcheggio selettore");
LSTR MSG_PROGRESS_EJECT_FILAMENT = _UxGT("Esplusione filamento");
LSTR MSG_PROGRESSPSTRETRACT_FINDA = _UxGT("Ritrai a FINDA");
LSTR MSG_PROGRESS_HOMING = _UxGT("Homing");
LSTR MSG_PROGRESS_MOVING_SELECTOR = _UxGT("Movim. selettore");
LSTR MSG_PROGRESS_FEED_FSENSOR = _UxGT("Alim. a FSensor");
}
namespace LanguageWide_it {
using namespace LanguageNarrow_it;
#if LCD_WIDTH >= 20 || HAS_DWIN_E3V2
LSTR MSG_HOST_START_PRINT = _UxGT("Avvio stampa host");
LSTR MSG_PRINTING_OBJECT = _UxGT("Sto stampando l'oggetto");
LSTR MSG_CANCEL_OBJECT = _UxGT("Cancella l'oggetto");
LSTR MSG_CANCEL_OBJECT_N = _UxGT("Cancella l'oggetto {");
LSTR MSG_PRINTING_OBJECT = _UxGT("Stampa oggetto");
LSTR MSG_CANCEL_OBJECT = _UxGT("Cancella oggetto");
LSTR MSG_CANCEL_OBJECT_N = _UxGT("Cancella oggetto {");
LSTR MSG_CONTINUE_PRINT_JOB = _UxGT("Continua il job di stampa");
LSTR MSG_MEDIA_MENU = _UxGT("Selez.da supporto");
LSTR MSG_MEDIA_MENU = _UxGT("Seleziona da ") MEDIA_TYPE_IT;
LSTR MSG_MEDIA_MENU_SD = _UxGT("Seleziona da scheda SD");
LSTR MSG_MEDIA_MENU_USB = _UxGT("Seleziona da unità USB");
LSTR MSG_NO_MEDIA = MEDIA_TYPE_EN _UxGT(" non trovato");
LSTR MSG_TURN_OFF = _UxGT("Spegni la stampante");
LSTR MSG_END_LOOPS = _UxGT("Termina i cicli di ripetizione");
LSTR MSG_MEDIA_NOT_INSERTED = _UxGT("Nessun supporto inserito."); // ProUI
@ -959,7 +1025,13 @@ namespace LanguageWide_it {
LSTR MSG_INFO_PRINT_TIME = _UxGT("Tempo totale");
LSTR MSG_INFO_PRINT_LONGEST = _UxGT("Lavoro più lungo");
LSTR MSG_INFO_PRINT_FILAMENT = _UxGT("Totale estruso");
LSTR MSG_TEMP_TOO_LOW = _UxGT("Temperatura troppo bassa");
LSTR MSG_HOMING_FEEDRATE_N = _UxGT("Velocità @ di homing");
LSTR MSG_HOMING_FEEDRATE_X = _UxGT("Velocità X di homing");
LSTR MSG_HOMING_FEEDRATE_Y = _UxGT("Velocità Y di homing");
LSTR MSG_HOMING_FEEDRATE_Z = _UxGT("Velocità Z di homing");
LSTR MSG_EEPROM_INITIALIZED = _UxGT("Ripristinate impostazioni predefinite");
LSTR MSG_PREHEAT_M_CHAMBER = _UxGT("Preriscalda camera per $");
LSTR MSG_PREHEAT_M_SETTINGS = _UxGT("Configurazioni preriscaldo $");
#endif
}

7
Marlin/src/lcd/language/language_pl.h
View file

@ -48,14 +48,15 @@ namespace LanguageNarrow_pl {
LSTR MSG_YES = _UxGT("TAK");
LSTR MSG_NO = _UxGT("NIE");
LSTR MSG_BACK = _UxGT("Wstecz");
LSTR MSG_MEDIA_ABORTING = _UxGT("Przerywanie...");
LSTR MSG_MEDIA_INSERTED = _UxGT("Karta włożona");
LSTR MSG_MEDIA_REMOVED = _UxGT("Karta usunięta");
LSTR MSG_MEDIA_WAITING = _UxGT("Oczekiwanie na kartę");
LSTR MSG_MEDIA_INIT_FAIL = _UxGT("Błąd inicializacji karty");
LSTR MSG_MEDIA_READ_ERROR = _UxGT("Bład odczytu karty");
LSTR MSG_MEDIA_USB_REMOVED = _UxGT("Urządzenie USB usunięte");
LSTR MSG_MEDIA_USB_FAILED = _UxGT("Błąd uruchomienia USB");
LSTR MSG_USB_FD_DEVICE_REMOVED = _UxGT("Urządzenie USB usunięte");
LSTR MSG_USB_FD_USB_FAILED = _UxGT("Błąd uruchomienia USB");
LSTR MSG_LCD_ENDSTOPS = _UxGT("Krańców."); // Max length 8 characters
LSTR MSG_LCD_SOFT_ENDSTOPS = _UxGT("Progr. Krańcówki");
LSTR MSG_MAIN_MENU = _UxGT("Menu główne");

7
Marlin/src/lcd/language/language_pt_br.h
View file

@ -38,13 +38,14 @@ namespace LanguageNarrow_pt_br {
LSTR MSG_YES = _UxGT("SIM");
LSTR MSG_NO = _UxGT("NÃO");
LSTR MSG_BACK = _UxGT("Voltar");
LSTR MSG_MEDIA_ABORTING = _UxGT("Abortando...");
LSTR MSG_MEDIA_INSERTED = _UxGT("Cartão inserido");
LSTR MSG_MEDIA_REMOVED = _UxGT("Cartão removido");
LSTR MSG_MEDIA_WAITING = _UxGT("Aguardando cartão");
LSTR MSG_MEDIA_READ_ERROR = _UxGT("Erro de leitura");
LSTR MSG_MEDIA_USB_REMOVED = _UxGT("USB removido");
LSTR MSG_MEDIA_USB_FAILED = _UxGT("USB falhou");
LSTR MSG_USB_FD_DEVICE_REMOVED = _UxGT("USB removido");
LSTR MSG_USB_FD_USB_FAILED = _UxGT("USB falhou");
LSTR MSG_LCD_ENDSTOPS = _UxGT("Fins de curso");
LSTR MSG_LCD_SOFT_ENDSTOPS = _UxGT("Soft Fins curso");
LSTR MSG_MAIN_MENU = _UxGT("Menu principal");

7
Marlin/src/lcd/language/language_ro.h
View file

@ -39,14 +39,15 @@ namespace LanguageNarrow_ro {
LSTR MSG_YES = _UxGT("DA");
LSTR MSG_NO = _UxGT("NU");
LSTR MSG_BACK = _UxGT("Inapoi");
LSTR MSG_MEDIA_ABORTING = _UxGT("Abandon...");
LSTR MSG_MEDIA_INSERTED = _UxGT("Media Introdus");
LSTR MSG_MEDIA_REMOVED = _UxGT("Media Inlaturat");
LSTR MSG_MEDIA_WAITING = _UxGT("Astept Media");
LSTR MSG_MEDIA_READ_ERROR = _UxGT("Eroare Citire Media");
LSTR MSG_MEDIA_USB_REMOVED = _UxGT("Dispozitiv USB Inlaturat");
LSTR MSG_MEDIA_USB_FAILED = _UxGT("Pornire USB Esuata");
LSTR MSG_USB_FD_DEVICE_REMOVED = _UxGT("Dispozitiv USB Inlaturat");
LSTR MSG_USB_FD_USB_FAILED = _UxGT("Pornire USB Esuata");
LSTR MSG_KILL_SUBCALL_OVERFLOW = _UxGT("Eroare:Subcall Overflow");
LSTR MSG_LCD_ENDSTOPS = _UxGT("Endstops"); // Max length 8 characters
LSTR MSG_LCD_SOFT_ENDSTOPS = _UxGT("Soft Endstops");
LSTR MSG_MAIN_MENU = _UxGT("Principal");

7
Marlin/src/lcd/language/language_ru.h
View file

@ -39,16 +39,17 @@ namespace LanguageNarrow_ru {
LSTR MSG_YES = _UxGT("Да");
LSTR MSG_NO = _UxGT("Нет");
LSTR MSG_BACK = _UxGT("Назад");
LSTR MSG_MEDIA_ABORTING = _UxGT("Прерывание...");
LSTR MSG_MEDIA_INSERTED = _UxGT("SD карта вставлена");
LSTR MSG_MEDIA_REMOVED = _UxGT("SD карта извлечена");
LSTR MSG_MEDIA_WAITING = _UxGT("Вставьте SD карту");
LSTR MSG_MEDIA_INIT_FAIL = _UxGT("Сбой инициализ. SD");
LSTR MSG_ADVANCED_SETTINGS = _UxGT("Расшир. настройки");
LSTR MSG_KILL_SUBCALL_OVERFLOW = _UxGT("Переполн. вызова");
LSTR MSG_MEDIA_READ_ERROR = _UxGT("Ошибка чтения");
LSTR MSG_MEDIA_USB_REMOVED = _UxGT("USB диск удалён");
LSTR MSG_MEDIA_USB_FAILED = _UxGT("Ошибка USB диска");
LSTR MSG_USB_FD_DEVICE_REMOVED = _UxGT("USB диск удалён");
LSTR MSG_USB_FD_USB_FAILED = _UxGT("Ошибка USB диска");
LSTR MSG_LCD_SOFT_ENDSTOPS = _UxGT("Прогр. концевики");
LSTR MSG_LCD_ENDSTOPS = _UxGT("Концевик"); // Max length 8 characters
LSTR MSG_MAIN_MENU = _UxGT("Главное меню");

7
Marlin/src/lcd/language/language_sk.h
View file

@ -54,14 +54,15 @@ namespace LanguageNarrow_sk {
LSTR MSG_LOW = _UxGT("NÍZKA");
LSTR MSG_BACK = _UxGT("Naspäť");
LSTR MSG_ERROR = _UxGT("Chyba");
LSTR MSG_MEDIA_ABORTING = _UxGT("Ruším...");
LSTR MSG_MEDIA_INSERTED = _UxGT("Karta vložená");
LSTR MSG_MEDIA_REMOVED = _UxGT("Karta vybraná");
LSTR MSG_MEDIA_WAITING = _UxGT("Čakám na kartu");
LSTR MSG_MEDIA_INIT_FAIL = _UxGT("Inicial.karty zlyhala");
LSTR MSG_MEDIA_READ_ERROR = _UxGT("Chyba čítania karty");
LSTR MSG_MEDIA_USB_REMOVED = _UxGT("USB zaria. odstrán.");
LSTR MSG_MEDIA_USB_FAILED = _UxGT("Chyba spúšťania USB");
LSTR MSG_USB_FD_DEVICE_REMOVED = _UxGT("USB zaria. odstrán.");
LSTR MSG_USB_FD_USB_FAILED = _UxGT("Chyba spúšťania USB");
LSTR MSG_KILL_SUBCALL_OVERFLOW = _UxGT("Preteč. podprogramu");
LSTR MSG_LCD_ENDSTOPS = _UxGT("Endstopy"); // max 8 znakov
LSTR MSG_LCD_SOFT_ENDSTOPS = _UxGT("Soft. endstopy");

7
Marlin/src/lcd/language/language_sv.h
View file

@ -40,15 +40,16 @@ namespace LanguageNarrow_sv {
LSTR MSG_YES = _UxGT("JA");
LSTR MSG_NO = _UxGT("NEJ");
LSTR MSG_BACK = _UxGT("Bakåt");
LSTR MSG_MEDIA_ABORTING = _UxGT("Avbryter...");
LSTR MSG_MEDIA_INSERTED = _UxGT("Media Instatt");
LSTR MSG_MEDIA_REMOVED = _UxGT("Media Borttaget");
LSTR MSG_MEDIA_WAITING = _UxGT("Väntar på media");
LSTR MSG_MEDIA_INIT_FAIL = _UxGT("Media init misslyckades");
LSTR MSG_MEDIA_READ_ERROR = _UxGT("Media läsningsfel");
LSTR MSG_MEDIA_USB_REMOVED = _UxGT("USB enhet borttagen");
LSTR MSG_MEDIA_USB_FAILED = _UxGT("USB start misslyckad");
LSTR MSG_USB_FD_DEVICE_REMOVED = _UxGT("USB enhet borttagen");
LSTR MSG_USB_FD_USB_FAILED = _UxGT("USB start misslyckad");
LSTR MSG_KILL_SUBCALL_OVERFLOW = _UxGT("Underanrop överskriden");
LSTR MSG_LCD_ENDSTOPS = _UxGT("Slutstop"); // Max length 8 characters
LSTR MSG_LCD_SOFT_ENDSTOPS = _UxGT("Mjuk slutstopp");
LSTR MSG_MAIN_MENU = _UxGT("Huvud");

8
Marlin/src/lcd/language/language_tr.h
View file

@ -52,17 +52,18 @@ namespace LanguageNarrow_tr {
LSTR MSG_LOW = _UxGT("DÜŞÜK");
LSTR MSG_BACK = _UxGT("Geri");
LSTR MSG_ERROR = _UxGT("Hata");
LSTR MSG_MEDIA_ABORTING = _UxGT("Durduruluyor...");
LSTR MSG_MEDIA_INSERTED = _UxGT("SD K. Yerleştirildi.");
LSTR MSG_MEDIA_REMOVED = _UxGT("SD Kart Çıkarıldı.");
LSTR MSG_MEDIA_WAITING = _UxGT("SD Kart Bekleniyor");
LSTR MSG_MEDIA_INIT_FAIL = _UxGT("SD K. Başlatma Hatası");
LSTR MSG_MEDIA_READ_ERROR = _UxGT("Kart Okuma Hatası");
LSTR MSG_MEDIA_USB_REMOVED = _UxGT("USB Çıkarıldı");
LSTR MSG_MEDIA_USB_FAILED = _UxGT("USB Başlat. Hatası");
LSTR MSG_USB_FD_DEVICE_REMOVED = _UxGT("USB Çıkarıldı");
LSTR MSG_USB_FD_USB_FAILED = _UxGT("USB Başlat. Hatası");
LSTR MSG_MEDIA_SORT = _UxGT("Medyayı Sırala");
LSTR MSG_MEDIA_UPDATE = _UxGT("Medyayı Güncelle");
LSTR MSG_KILL_SUBCALL_OVERFLOW = _UxGT("Subcall Overflow");
LSTR MSG_LCD_ENDSTOPS = _UxGT("Endstops"); // Max length 8 characters
LSTR MSG_LCD_SOFT_ENDSTOPS = _UxGT("Soft Endstops");
LSTR MSG_MAIN_MENU = _UxGT("Ana");
@ -890,7 +891,6 @@ namespace LanguageNarrow_tr {
namespace LanguageWide_tr {
using namespace LanguageNarrow_tr;
#if LCD_WIDTH >= 20 || HAS_DWIN_E3V2
LSTR MSG_LIVE_MOVE = _UxGT("Canlı Hareket");
LSTR MSG_HOST_START_PRINT = _UxGT("Host Baskıyı başlat");
LSTR MSG_PRINTING_OBJECT = _UxGT("Yazdırma Nesnesi");
LSTR MSG_CANCEL_OBJECT = _UxGT("Nesneyi İptal Et");

7
Marlin/src/lcd/language/language_uk.h
View file

@ -40,15 +40,16 @@ namespace LanguageNarrow_uk {
LSTR MSG_YES = _UxGT("ТАК");
LSTR MSG_NO = _UxGT("НІ");
LSTR MSG_BACK = _UxGT("Назад");
LSTR MSG_MEDIA_ABORTING = _UxGT("Переривання...");
LSTR MSG_MEDIA_INSERTED = _UxGT("SD-картка вставлена");
LSTR MSG_MEDIA_REMOVED = _UxGT("SD-картка видалена");
LSTR MSG_MEDIA_WAITING = _UxGT("Вставте SD-картку");
LSTR MSG_MEDIA_INIT_FAIL = _UxGT("Збій ініціаліз. SD");
LSTR MSG_MEDIA_READ_ERROR = _UxGT("Помилка зчитування");
LSTR MSG_MEDIA_USB_REMOVED = _UxGT("USB диск видалений");
LSTR MSG_MEDIA_USB_FAILED = _UxGT("Помилка USB диску");
LSTR MSG_USB_FD_DEVICE_REMOVED = _UxGT("USB диск видалений");
LSTR MSG_USB_FD_USB_FAILED = _UxGT("Помилка USB диску");
LSTR MSG_KILL_SUBCALL_OVERFLOW = _UxGT("Переповн. виклику");
LSTR MSG_LCD_SOFT_ENDSTOPS = _UxGT("Прогр.кінцевики");
LSTR MSG_LCD_ENDSTOPS = _UxGT("Кінцевик"); // Max length 8 characters
LSTR MSG_MAIN_MENU = _UxGT("Основне меню");

Some files were not shown because too many files have changed in this diff Show more