diff --git a/.travis.yml b/.travis.yml
index 613155fab8edc376a47e2bc1936c2dd1d39e6486..4f128613a3c78e88f1d368e6c3d5b1b004229004 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -84,7 +84,7 @@ script:
- opt_set TEMP_SENSOR_4 999
- opt_set TEMP_SENSOR_BED 1
- opt_enable AUTO_BED_LEVELING_UBL RESTORE_LEVELING_AFTER_G28 DEBUG_LEVELING_FEATURE G26_MESH_EDITING ENABLE_LEVELING_FADE_HEIGHT EEPROM_SETTINGS EEPROM_CHITCHAT G3D_PANEL SKEW_CORRECTION
- - opt_enable_adv CUSTOM_USER_MENUS I2C_POSITION_ENCODERS BABYSTEPPING BABYSTEP_XY LIN_ADVANCE NANODLP_Z_SYNC QUICK_HOME
+ - opt_enable_adv CUSTOM_USER_MENUS I2C_POSITION_ENCODERS BABYSTEPPING BABYSTEP_XY LIN_ADVANCE NANODLP_Z_SYNC QUICK_HOME JUNCTION_DEVIATION
- build_marlin_pio ${TRAVIS_BUILD_DIR} ${TEST_PLATFORM}
#
# Add a Sled Z Probe, use UBL Cartesian moves, use Japanese language
diff --git a/Marlin/Configuration_adv.h b/Marlin/Configuration_adv.h
index caad96a406e0464d6f7ff0d37cc0a69fcfb43c26..68ed4eb957ca14c2c518215fc7e29ee016961c3b 100644
--- a/Marlin/Configuration_adv.h
+++ b/Marlin/Configuration_adv.h
@@ -431,6 +431,15 @@
// if unwanted behavior is observed on a user's machine when running at very slow speeds.
#define MINIMUM_PLANNER_SPEED 0.05 // (mm/sec)
+//
+// Use Junction Deviation instead of traditional Jerk Limiting
+//
+//#define JUNCTION_DEVIATION
+#if ENABLED(JUNCTION_DEVIATION)
+ #define JUNCTION_DEVIATION_FACTOR 0.02
+ //#define JUNCTION_DEVIATION_INCLUDE_E
+#endif
+
// Microstep setting (Only functional when stepper driver microstep pins are connected to MCU.
#define MICROSTEP_MODES {16,16,16,16,16} // [1,2,4,8,16]
diff --git a/Marlin/src/HAL/HAL_AVR/math_AVR.h b/Marlin/src/HAL/HAL_AVR/math_AVR.h
index e0feab034f8eec0229420867680579dfa1fab588..7d2517520bc1661cc0508033c03df37fae757a66 100644
--- a/Marlin/src/HAL/HAL_AVR/math_AVR.h
+++ b/Marlin/src/HAL/HAL_AVR/math_AVR.h
@@ -23,6 +23,8 @@
#ifndef _MATH_AVR_H_
#define _MATH_AVR_H_
+#define a(CODE) " " CODE "\n\t"
+
/**
* Optimized math functions for AVR
*/
@@ -39,41 +41,41 @@
//
#define MultiU24X32toH16(intRes, longIn1, longIn2) \
asm volatile ( \
- "clr r26 \n\t" \
- "mul %A1, %B2 \n\t" \
- "mov r27, r1 \n\t" \
- "mul %B1, %C2 \n\t" \
- "movw %A0, r0 \n\t" \
- "mul %C1, %C2 \n\t" \
- "add %B0, r0 \n\t" \
- "mul %C1, %B2 \n\t" \
- "add %A0, r0 \n\t" \
- "adc %B0, r1 \n\t" \
- "mul %A1, %C2 \n\t" \
- "add r27, r0 \n\t" \
- "adc %A0, r1 \n\t" \
- "adc %B0, r26 \n\t" \
- "mul %B1, %B2 \n\t" \
- "add r27, r0 \n\t" \
- "adc %A0, r1 \n\t" \
- "adc %B0, r26 \n\t" \
- "mul %C1, %A2 \n\t" \
- "add r27, r0 \n\t" \
- "adc %A0, r1 \n\t" \
- "adc %B0, r26 \n\t" \
- "mul %B1, %A2 \n\t" \
- "add r27, r1 \n\t" \
- "adc %A0, r26 \n\t" \
- "adc %B0, r26 \n\t" \
- "lsr r27 \n\t" \
- "adc %A0, r26 \n\t" \
- "adc %B0, r26 \n\t" \
- "mul %D2, %A1 \n\t" \
- "add %A0, r0 \n\t" \
- "adc %B0, r1 \n\t" \
- "mul %D2, %B1 \n\t" \
- "add %B0, r0 \n\t" \
- "clr r1 \n\t" \
+ A("clr r26") \
+ A("mul %A1, %B2") \
+ A("mov r27, r1") \
+ A("mul %B1, %C2") \
+ A("movw %A0, r0") \
+ A("mul %C1, %C2") \
+ A("add %B0, r0") \
+ A("mul %C1, %B2") \
+ A("add %A0, r0") \
+ A("adc %B0, r1") \
+ A("mul %A1, %C2") \
+ A("add r27, r0") \
+ A("adc %A0, r1") \
+ A("adc %B0, r26") \
+ A("mul %B1, %B2") \
+ A("add r27, r0") \
+ A("adc %A0, r1") \
+ A("adc %B0, r26") \
+ A("mul %C1, %A2") \
+ A("add r27, r0") \
+ A("adc %A0, r1") \
+ A("adc %B0, r26") \
+ A("mul %B1, %A2") \
+ A("add r27, r1") \
+ A("adc %A0, r26") \
+ A("adc %B0, r26") \
+ A("lsr r27") \
+ A("adc %A0, r26") \
+ A("adc %B0, r26") \
+ A("mul %D2, %A1") \
+ A("add %A0, r0") \
+ A("adc %B0, r1") \
+ A("mul %D2, %B1") \
+ A("add %B0, r0") \
+ A("clr r1") \
: \
"=&r" (intRes) \
: \
@@ -89,16 +91,16 @@
// r27 to store the byte 1 of the 24 bit result
#define MultiU16X8toH16(intRes, charIn1, intIn2) \
asm volatile ( \
- "clr r26 \n\t" \
- "mul %A1, %B2 \n\t" \
- "movw %A0, r0 \n\t" \
- "mul %A1, %A2 \n\t" \
- "add %A0, r1 \n\t" \
- "adc %B0, r26 \n\t" \
- "lsr r0 \n\t" \
- "adc %A0, r26 \n\t" \
- "adc %B0, r26 \n\t" \
- "clr r1 \n\t" \
+ A("clr r26") \
+ A("mul %A1, %B2") \
+ A("movw %A0, r0") \
+ A("mul %A1, %A2") \
+ A("add %A0, r1") \
+ A("adc %B0, r26") \
+ A("lsr r0") \
+ A("adc %A0, r26") \
+ A("adc %B0, r26") \
+ A("clr r1") \
: \
"=&r" (intRes) \
: \
diff --git a/Marlin/src/HAL/HAL_DUE/DebugMonitor_Due.cpp b/Marlin/src/HAL/HAL_DUE/DebugMonitor_Due.cpp
index f6ee7363aac8d62310baced8959cdbde86c05697..a2322e27e6b38ce03707adac068321150dfeb510 100644
--- a/Marlin/src/HAL/HAL_DUE/DebugMonitor_Due.cpp
+++ b/Marlin/src/HAL/HAL_DUE/DebugMonitor_Due.cpp
@@ -36,7 +36,7 @@
// state we are when running them
// A SW memory barrier, to ensure GCC does not overoptimize loops
-#define sw_barrier() asm volatile("": : :"memory");
+#define sw_barrier() __asm__ volatile("": : :"memory");
// (re)initialize UART0 as a monitor output to 250000,n,8,1
static void TXBegin(void) {
@@ -230,106 +230,106 @@ void HardFault_HandlerC(unsigned long *sp, unsigned long lr, unsigned long cause
__attribute__((naked)) void NMI_Handler(void) {
__asm__ __volatile__ (
- ".syntax unified \n"
- " tst lr, #4 \n"
- " ite eq \n"
- " mrseq r0, msp \n"
- " mrsne r0, psp \n"
- " mov r1,lr \n"
- " mov r2,#0 \n"
- " b HardFault_HandlerC \n"
+ ".syntax unified" "\n\t"
+ A("tst lr, #4")
+ A("ite eq")
+ A("mrseq r0, msp")
+ A("mrsne r0, psp")
+ A("mov r1,lr")
+ A("mov r2,#0")
+ A("b HardFault_HandlerC")
);
}
__attribute__((naked)) void HardFault_Handler(void) {
__asm__ __volatile__ (
- ".syntax unified \n"
- " tst lr, #4 \n"
- " ite eq \n"
- " mrseq r0, msp \n"
- " mrsne r0, psp \n"
- " mov r1,lr \n"
- " mov r2,#1 \n"
- " b HardFault_HandlerC \n"
+ ".syntax unified" "\n\t"
+ A("tst lr, #4")
+ A("ite eq")
+ A("mrseq r0, msp")
+ A("mrsne r0, psp")
+ A("mov r1,lr")
+ A("mov r2,#1")
+ A("b HardFault_HandlerC")
);
}
__attribute__((naked)) void MemManage_Handler(void) {
__asm__ __volatile__ (
- ".syntax unified \n"
- " tst lr, #4 \n"
- " ite eq \n"
- " mrseq r0, msp \n"
- " mrsne r0, psp \n"
- " mov r1,lr \n"
- " mov r2,#2 \n"
- " b HardFault_HandlerC \n"
+ ".syntax unified" "\n\t"
+ A("tst lr, #4")
+ A("ite eq")
+ A("mrseq r0, msp")
+ A("mrsne r0, psp")
+ A("mov r1,lr")
+ A("mov r2,#2")
+ A("b HardFault_HandlerC")
);
}
__attribute__((naked)) void BusFault_Handler(void) {
__asm__ __volatile__ (
- ".syntax unified \n"
- " tst lr, #4 \n"
- " ite eq \n"
- " mrseq r0, msp \n"
- " mrsne r0, psp \n"
- " mov r1,lr \n"
- " mov r2,#3 \n"
- " b HardFault_HandlerC \n"
+ ".syntax unified" "\n\t"
+ A("tst lr, #4")
+ A("ite eq")
+ A("mrseq r0, msp")
+ A("mrsne r0, psp")
+ A("mov r1,lr")
+ A("mov r2,#3")
+ A("b HardFault_HandlerC")
);
}
__attribute__((naked)) void UsageFault_Handler(void) {
__asm__ __volatile__ (
- ".syntax unified \n"
- " tst lr, #4 \n"
- " ite eq \n"
- " mrseq r0, msp \n"
- " mrsne r0, psp \n"
- " mov r1,lr \n"
- " mov r2,#4 \n"
- " b HardFault_HandlerC \n"
+ ".syntax unified" "\n\t"
+ A("tst lr, #4")
+ A("ite eq")
+ A("mrseq r0, msp")
+ A("mrsne r0, psp")
+ A("mov r1,lr")
+ A("mov r2,#4")
+ A("b HardFault_HandlerC")
);
}
__attribute__((naked)) void DebugMon_Handler(void) {
__asm__ __volatile__ (
- ".syntax unified \n"
- " tst lr, #4 \n"
- " ite eq \n"
- " mrseq r0, msp \n"
- " mrsne r0, psp \n"
- " mov r1,lr \n"
- " mov r2,#5 \n"
- " b HardFault_HandlerC \n"
+ ".syntax unified" "\n\t"
+ A("tst lr, #4")
+ A("ite eq")
+ A("mrseq r0, msp")
+ A("mrsne r0, psp")
+ A("mov r1,lr")
+ A("mov r2,#5")
+ A("b HardFault_HandlerC")
);
}
/* This is NOT an exception, it is an interrupt handler - Nevertheless, the framing is the same */
__attribute__((naked)) void WDT_Handler(void) {
__asm__ __volatile__ (
- ".syntax unified \n"
- " tst lr, #4 \n"
- " ite eq \n"
- " mrseq r0, msp \n"
- " mrsne r0, psp \n"
- " mov r1,lr \n"
- " mov r2,#6 \n"
- " b HardFault_HandlerC \n"
+ ".syntax unified" "\n\t"
+ A("tst lr, #4")
+ A("ite eq")
+ A("mrseq r0, msp")
+ A("mrsne r0, psp")
+ A("mov r1,lr")
+ A("mov r2,#6")
+ A("b HardFault_HandlerC")
);
}
__attribute__((naked)) void RSTC_Handler(void) {
__asm__ __volatile__ (
- ".syntax unified \n"
- " tst lr, #4 \n"
- " ite eq \n"
- " mrseq r0, msp \n"
- " mrsne r0, psp \n"
- " mov r1,lr \n"
- " mov r2,#7 \n"
- " b HardFault_HandlerC \n"
+ ".syntax unified" "\n\t"
+ A("tst lr, #4")
+ A("ite eq")
+ A("mrseq r0, msp")
+ A("mrsne r0, psp")
+ A("mov r1,lr")
+ A("mov r2,#7")
+ A("b HardFault_HandlerC")
);
}
diff --git a/Marlin/src/HAL/HAL_DUE/HAL_spi_Due.cpp b/Marlin/src/HAL/HAL_DUE/HAL_spi_Due.cpp
index 8cbdb97e350246604e10a11fc88c762352ccde53..360d04bfff62e8d5cf291ee4d7262e87564d01b9 100644
--- a/Marlin/src/HAL/HAL_DUE/HAL_spi_Due.cpp
+++ b/Marlin/src/HAL/HAL_DUE/HAL_spi_Due.cpp
@@ -77,10 +77,10 @@
__asm__ __volatile__(
".syntax unified" "\n\t" // is to prevent CM0,CM1 non-unified syntax
- "loop%=:" "\n\t"
- " subs %[cnt],#1" "\n\t"
- EXTRA_NOP_CYCLES "\n\t"
- " bne loop%=" "\n\t"
+ L("loop%=")
+ A("subs %[cnt],#1")
+ A(EXTRA_NOP_CYCLES)
+ A("bne loop%=")
: [cnt]"+r"(cy) // output: +r means input+output
: // input:
: "cc" // clobbers:
@@ -141,54 +141,54 @@
".syntax unified" "\n\t" // is to prevent CM0,CM1 non-unified syntax
/* Bit 7 */
- " ubfx %[idx],%[txval],#7,#1" "\n\t" /* Place bit 7 in bit 0 of idx*/
+ A("ubfx %[idx],%[txval],#7,#1") /* Place bit 7 in bit 0 of idx*/
- " str %[mosi_mask],[%[mosi_port], %[idx],LSL #2]" "\n\t" /* Access the proper SODR or CODR registers based on that bit */
- " str %[sck_mask],[%[sck_port]]" "\n\t" /* SODR */
- " ubfx %[idx],%[txval],#6,#1" "\n\t" /* Place bit 6 in bit 0 of idx*/
- " str %[sck_mask],[%[sck_port],#0x4]" "\n\t" /* CODR */
+ A("str %[mosi_mask],[%[mosi_port], %[idx],LSL #2]") /* Access the proper SODR or CODR registers based on that bit */
+ A("str %[sck_mask],[%[sck_port]]") /* SODR */
+ A("ubfx %[idx],%[txval],#6,#1") /* Place bit 6 in bit 0 of idx*/
+ A("str %[sck_mask],[%[sck_port],#0x4]") /* CODR */
/* Bit 6 */
- " str %[mosi_mask],[%[mosi_port], %[idx],LSL #2]" "\n\t" /* Access the proper SODR or CODR registers based on that bit */
- " str %[sck_mask],[%[sck_port]]" "\n\t" /* SODR */
- " ubfx %[idx],%[txval],#5,#1" "\n\t" /* Place bit 5 in bit 0 of idx*/
- " str %[sck_mask],[%[sck_port],#0x4]" "\n\t" /* CODR */
+ A("str %[mosi_mask],[%[mosi_port], %[idx],LSL #2]") /* Access the proper SODR or CODR registers based on that bit */
+ A("str %[sck_mask],[%[sck_port]]") /* SODR */
+ A("ubfx %[idx],%[txval],#5,#1") /* Place bit 5 in bit 0 of idx*/
+ A("str %[sck_mask],[%[sck_port],#0x4]") /* CODR */
/* Bit 5 */
- " str %[mosi_mask],[%[mosi_port], %[idx],LSL #2]" "\n\t" /* Access the proper SODR or CODR registers based on that bit */
- " str %[sck_mask],[%[sck_port]]" "\n\t" /* SODR */
- " ubfx %[idx],%[txval],#4,#1" "\n\t" /* Place bit 4 in bit 0 of idx*/
- " str %[sck_mask],[%[sck_port],#0x4]" "\n\t" /* CODR */
+ A("str %[mosi_mask],[%[mosi_port], %[idx],LSL #2]") /* Access the proper SODR or CODR registers based on that bit */
+ A("str %[sck_mask],[%[sck_port]]") /* SODR */
+ A("ubfx %[idx],%[txval],#4,#1") /* Place bit 4 in bit 0 of idx*/
+ A("str %[sck_mask],[%[sck_port],#0x4]") /* CODR */
/* Bit 4 */
- " str %[mosi_mask],[%[mosi_port], %[idx],LSL #2]" "\n\t" /* Access the proper SODR or CODR registers based on that bit */
- " str %[sck_mask],[%[sck_port]]" "\n\t" /* SODR */
- " ubfx %[idx],%[txval],#3,#1" "\n\t" /* Place bit 3 in bit 0 of idx*/
- " str %[sck_mask],[%[sck_port],#0x4]" "\n\t" /* CODR */
+ A("str %[mosi_mask],[%[mosi_port], %[idx],LSL #2]") /* Access the proper SODR or CODR registers based on that bit */
+ A("str %[sck_mask],[%[sck_port]]") /* SODR */
+ A("ubfx %[idx],%[txval],#3,#1") /* Place bit 3 in bit 0 of idx*/
+ A("str %[sck_mask],[%[sck_port],#0x4]") /* CODR */
/* Bit 3 */
- " str %[mosi_mask],[%[mosi_port], %[idx],LSL #2]" "\n\t" /* Access the proper SODR or CODR registers based on that bit */
- " str %[sck_mask],[%[sck_port]]" "\n\t" /* SODR */
- " ubfx %[idx],%[txval],#2,#1" "\n\t" /* Place bit 2 in bit 0 of idx*/
- " str %[sck_mask],[%[sck_port],#0x4]" "\n\t" /* CODR */
+ A("str %[mosi_mask],[%[mosi_port], %[idx],LSL #2]") /* Access the proper SODR or CODR registers based on that bit */
+ A("str %[sck_mask],[%[sck_port]]") /* SODR */
+ A("ubfx %[idx],%[txval],#2,#1") /* Place bit 2 in bit 0 of idx*/
+ A("str %[sck_mask],[%[sck_port],#0x4]") /* CODR */
/* Bit 2 */
- " str %[mosi_mask],[%[mosi_port], %[idx],LSL #2]" "\n\t" /* Access the proper SODR or CODR registers based on that bit */
- " str %[sck_mask],[%[sck_port]]" "\n\t" /* SODR */
- " ubfx %[idx],%[txval],#1,#1" "\n\t" /* Place bit 1 in bit 0 of idx*/
- " str %[sck_mask],[%[sck_port],#0x4]" "\n\t" /* CODR */
+ A("str %[mosi_mask],[%[mosi_port], %[idx],LSL #2]") /* Access the proper SODR or CODR registers based on that bit */
+ A("str %[sck_mask],[%[sck_port]]") /* SODR */
+ A("ubfx %[idx],%[txval],#1,#1") /* Place bit 1 in bit 0 of idx*/
+ A("str %[sck_mask],[%[sck_port],#0x4]") /* CODR */
/* Bit 1 */
- " str %[mosi_mask],[%[mosi_port], %[idx],LSL #2]" "\n\t" /* Access the proper SODR or CODR registers based on that bit */
- " str %[sck_mask],[%[sck_port]]" "\n\t" /* SODR */
- " ubfx %[idx],%[txval],#0,#1" "\n\t" /* Place bit 0 in bit 0 of idx*/
- " str %[sck_mask],[%[sck_port],#0x4]" "\n\t" /* CODR */
+ A("str %[mosi_mask],[%[mosi_port], %[idx],LSL #2]") /* Access the proper SODR or CODR registers based on that bit */
+ A("str %[sck_mask],[%[sck_port]]") /* SODR */
+ A("ubfx %[idx],%[txval],#0,#1") /* Place bit 0 in bit 0 of idx*/
+ A("str %[sck_mask],[%[sck_port],#0x4]") /* CODR */
/* Bit 0 */
- " str %[mosi_mask],[%[mosi_port], %[idx],LSL #2]" "\n\t" /* Access the proper SODR or CODR registers based on that bit */
- " str %[sck_mask],[%[sck_port]]" "\n\t" /* SODR */
- " nop" "\n\t" /* Result will be 0 */
- " str %[sck_mask],[%[sck_port],#0x4]" "\n\t" /* CODR */
+ A("str %[mosi_mask],[%[mosi_port], %[idx],LSL #2]") /* Access the proper SODR or CODR registers based on that bit */
+ A("str %[sck_mask],[%[sck_port]]") /* SODR */
+ A("nop") /* Result will be 0 */
+ A("str %[sck_mask],[%[sck_port],#0x4]") /* CODR */
: [idx]"+r"( idx )
: [txval]"r"( bout ) ,
@@ -222,52 +222,52 @@
".syntax unified" "\n\t" // is to prevent CM0,CM1 non-unified syntax
/* bit 7 */
- " str %[sck_mask],[%[sck_port]]" "\n\t" /* SODR */
- " ldr %[work],[%[bitband_miso_port]]" "\n\t" /* PDSR on bitband area for required bit: work will be 1 or 0 based on port */
- " str %[sck_mask],[%[sck_port],#0x4]" "\n\t" /* CODR */
- " bfi %[bin],%[work],#7,#1" "\n\t" /* Store read bit as the bit 7 */
+ A("str %[sck_mask],[%[sck_port]]") /* SODR */
+ A("ldr %[work],[%[bitband_miso_port]]") /* PDSR on bitband area for required bit: work will be 1 or 0 based on port */
+ A("str %[sck_mask],[%[sck_port],#0x4]") /* CODR */
+ A("bfi %[bin],%[work],#7,#1") /* Store read bit as the bit 7 */
/* bit 6 */
- " str %[sck_mask],[%[sck_port]]" "\n\t" /* SODR */
- " ldr %[work],[%[bitband_miso_port]]" "\n\t" /* PDSR on bitband area for required bit: work will be 1 or 0 based on port */
- " str %[sck_mask],[%[sck_port],#0x4]" "\n\t" /* CODR */
- " bfi %[bin],%[work],#6,#1" "\n\t" /* Store read bit as the bit 6 */
+ A("str %[sck_mask],[%[sck_port]]") /* SODR */
+ A("ldr %[work],[%[bitband_miso_port]]") /* PDSR on bitband area for required bit: work will be 1 or 0 based on port */
+ A("str %[sck_mask],[%[sck_port],#0x4]") /* CODR */
+ A("bfi %[bin],%[work],#6,#1") /* Store read bit as the bit 6 */
/* bit 5 */
- " str %[sck_mask],[%[sck_port]]" "\n\t" /* SODR */
- " ldr %[work],[%[bitband_miso_port]]" "\n\t" /* PDSR on bitband area for required bit: work will be 1 or 0 based on port */
- " str %[sck_mask],[%[sck_port],#0x4]" "\n\t" /* CODR */
- " bfi %[bin],%[work],#5,#1" "\n\t" /* Store read bit as the bit 5 */
+ A("str %[sck_mask],[%[sck_port]]") /* SODR */
+ A("ldr %[work],[%[bitband_miso_port]]") /* PDSR on bitband area for required bit: work will be 1 or 0 based on port */
+ A("str %[sck_mask],[%[sck_port],#0x4]") /* CODR */
+ A("bfi %[bin],%[work],#5,#1") /* Store read bit as the bit 5 */
/* bit 4 */
- " str %[sck_mask],[%[sck_port]]" "\n\t" /* SODR */
- " ldr %[work],[%[bitband_miso_port]]" "\n\t" /* PDSR on bitband area for required bit: work will be 1 or 0 based on port */
- " str %[sck_mask],[%[sck_port],#0x4]" "\n\t" /* CODR */
- " bfi %[bin],%[work],#4,#1" "\n\t" /* Store read bit as the bit 4 */
+ A("str %[sck_mask],[%[sck_port]]") /* SODR */
+ A("ldr %[work],[%[bitband_miso_port]]") /* PDSR on bitband area for required bit: work will be 1 or 0 based on port */
+ A("str %[sck_mask],[%[sck_port],#0x4]") /* CODR */
+ A("bfi %[bin],%[work],#4,#1") /* Store read bit as the bit 4 */
/* bit 3 */
- " str %[sck_mask],[%[sck_port]]" "\n\t" /* SODR */
- " ldr %[work],[%[bitband_miso_port]]" "\n\t" /* PDSR on bitband area for required bit: work will be 1 or 0 based on port */
- " str %[sck_mask],[%[sck_port],#0x4]" "\n\t" /* CODR */
- " bfi %[bin],%[work],#3,#1" "\n\t" /* Store read bit as the bit 3 */
+ A("str %[sck_mask],[%[sck_port]]") /* SODR */
+ A("ldr %[work],[%[bitband_miso_port]]") /* PDSR on bitband area for required bit: work will be 1 or 0 based on port */
+ A("str %[sck_mask],[%[sck_port],#0x4]") /* CODR */
+ A("bfi %[bin],%[work],#3,#1") /* Store read bit as the bit 3 */
/* bit 2 */
- " str %[sck_mask],[%[sck_port]]" "\n\t" /* SODR */
- " ldr %[work],[%[bitband_miso_port]]" "\n\t" /* PDSR on bitband area for required bit: work will be 1 or 0 based on port */
- " str %[sck_mask],[%[sck_port],#0x4]" "\n\t" /* CODR */
- " bfi %[bin],%[work],#2,#1" "\n\t" /* Store read bit as the bit 2 */
+ A("str %[sck_mask],[%[sck_port]]") /* SODR */
+ A("ldr %[work],[%[bitband_miso_port]]") /* PDSR on bitband area for required bit: work will be 1 or 0 based on port */
+ A("str %[sck_mask],[%[sck_port],#0x4]") /* CODR */
+ A("bfi %[bin],%[work],#2,#1") /* Store read bit as the bit 2 */
/* bit 1 */
- " str %[sck_mask],[%[sck_port]]" "\n\t" /* SODR */
- " ldr %[work],[%[bitband_miso_port]]" "\n\t" /* PDSR on bitband area for required bit: work will be 1 or 0 based on port */
- " str %[sck_mask],[%[sck_port],#0x4]" "\n\t" /* CODR */
- " bfi %[bin],%[work],#1,#1" "\n\t" /* Store read bit as the bit 1 */
+ A("str %[sck_mask],[%[sck_port]]") /* SODR */
+ A("ldr %[work],[%[bitband_miso_port]]") /* PDSR on bitband area for required bit: work will be 1 or 0 based on port */
+ A("str %[sck_mask],[%[sck_port],#0x4]") /* CODR */
+ A("bfi %[bin],%[work],#1,#1") /* Store read bit as the bit 1 */
/* bit 0 */
- " str %[sck_mask],[%[sck_port]]" "\n\t" /* SODR */
- " ldr %[work],[%[bitband_miso_port]]" "\n\t" /* PDSR on bitband area for required bit: work will be 1 or 0 based on port */
- " str %[sck_mask],[%[sck_port],#0x4]" "\n\t" /* CODR */
- " bfi %[bin],%[work],#0,#1" "\n\t" /* Store read bit as the bit 0 */
+ A("str %[sck_mask],[%[sck_port]]") /* SODR */
+ A("ldr %[work],[%[bitband_miso_port]]") /* PDSR on bitband area for required bit: work will be 1 or 0 based on port */
+ A("str %[sck_mask],[%[sck_port],#0x4]") /* CODR */
+ A("bfi %[bin],%[work],#0,#1") /* Store read bit as the bit 0 */
: [bin]"+r"(bin),
[work]"+r"(work)
@@ -335,60 +335,60 @@
__asm__ __volatile__(
".syntax unified" "\n\t" // is to prevent CM0,CM1 non-unified syntax
- " loop%=:" "\n\t"
- " ldrb.w %[txval], [%[ptr]], #1" "\n\t" /* Load value to send, increment buffer */
- " mvn %[txval],%[txval]" "\n\t" /* Negate value */
+ L("loop%=")
+ A("ldrb.w %[txval], [%[ptr]], #1") /* Load value to send, increment buffer */
+ A("mvn %[txval],%[txval]") /* Negate value */
/* Bit 7 */
- " ubfx %[work],%[txval],#7,#1" "\n\t" /* Place bit 7 in bit 0 of work*/
+ A("ubfx %[work],%[txval],#7,#1") /* Place bit 7 in bit 0 of work*/
- " str %[mosi_mask],[%[mosi_port], %[work],LSL #2]" "\n\t" /* Access the proper SODR or CODR registers based on that bit */
- " str %[sck_mask],[%[sck_port]]" "\n\t" /* SODR */
- " ubfx %[work],%[txval],#6,#1" "\n\t" /* Place bit 6 in bit 0 of work*/
- " str %[sck_mask],[%[sck_port],#0x4]" "\n\t" /* CODR */
+ A("str %[mosi_mask],[%[mosi_port], %[work],LSL #2]") /* Access the proper SODR or CODR registers based on that bit */
+ A("str %[sck_mask],[%[sck_port]]") /* SODR */
+ A("ubfx %[work],%[txval],#6,#1") /* Place bit 6 in bit 0 of work*/
+ A("str %[sck_mask],[%[sck_port],#0x4]") /* CODR */
/* Bit 6 */
- " str %[mosi_mask],[%[mosi_port], %[work],LSL #2]" "\n\t" /* Access the proper SODR or CODR registers based on that bit */
- " str %[sck_mask],[%[sck_port]]" "\n\t" /* SODR */
- " ubfx %[work],%[txval],#5,#1" "\n\t" /* Place bit 5 in bit 0 of work*/
- " str %[sck_mask],[%[sck_port],#0x4]" "\n\t" /* CODR */
+ A("str %[mosi_mask],[%[mosi_port], %[work],LSL #2]") /* Access the proper SODR or CODR registers based on that bit */
+ A("str %[sck_mask],[%[sck_port]]") /* SODR */
+ A("ubfx %[work],%[txval],#5,#1") /* Place bit 5 in bit 0 of work*/
+ A("str %[sck_mask],[%[sck_port],#0x4]") /* CODR */
/* Bit 5 */
- " str %[mosi_mask],[%[mosi_port], %[work],LSL #2]" "\n\t" /* Access the proper SODR or CODR registers based on that bit */
- " str %[sck_mask],[%[sck_port]]" "\n\t" /* SODR */
- " ubfx %[work],%[txval],#4,#1" "\n\t" /* Place bit 4 in bit 0 of work*/
- " str %[sck_mask],[%[sck_port],#0x4]" "\n\t" /* CODR */
+ A("str %[mosi_mask],[%[mosi_port], %[work],LSL #2]") /* Access the proper SODR or CODR registers based on that bit */
+ A("str %[sck_mask],[%[sck_port]]") /* SODR */
+ A("ubfx %[work],%[txval],#4,#1") /* Place bit 4 in bit 0 of work*/
+ A("str %[sck_mask],[%[sck_port],#0x4]") /* CODR */
/* Bit 4 */
- " str %[mosi_mask],[%[mosi_port], %[work],LSL #2]" "\n\t" /* Access the proper SODR or CODR registers based on that bit */
- " str %[sck_mask],[%[sck_port]]" "\n\t" /* SODR */
- " ubfx %[work],%[txval],#3,#1" "\n\t" /* Place bit 3 in bit 0 of work*/
- " str %[sck_mask],[%[sck_port],#0x4]" "\n\t" /* CODR */
+ A("str %[mosi_mask],[%[mosi_port], %[work],LSL #2]") /* Access the proper SODR or CODR registers based on that bit */
+ A("str %[sck_mask],[%[sck_port]]") /* SODR */
+ A("ubfx %[work],%[txval],#3,#1") /* Place bit 3 in bit 0 of work*/
+ A("str %[sck_mask],[%[sck_port],#0x4]") /* CODR */
/* Bit 3 */
- " str %[mosi_mask],[%[mosi_port], %[work],LSL #2]" "\n\t" /* Access the proper SODR or CODR registers based on that bit */
- " str %[sck_mask],[%[sck_port]]" "\n\t" /* SODR */
- " ubfx %[work],%[txval],#2,#1" "\n\t" /* Place bit 2 in bit 0 of work*/
- " str %[sck_mask],[%[sck_port],#0x4]" "\n\t" /* CODR */
+ A("str %[mosi_mask],[%[mosi_port], %[work],LSL #2]") /* Access the proper SODR or CODR registers based on that bit */
+ A("str %[sck_mask],[%[sck_port]]") /* SODR */
+ A("ubfx %[work],%[txval],#2,#1") /* Place bit 2 in bit 0 of work*/
+ A("str %[sck_mask],[%[sck_port],#0x4]") /* CODR */
/* Bit 2 */
- " str %[mosi_mask],[%[mosi_port], %[work],LSL #2]" "\n\t" /* Access the proper SODR or CODR registers based on that bit */
- " str %[sck_mask],[%[sck_port]]" "\n\t" /* SODR */
- " ubfx %[work],%[txval],#1,#1" "\n\t" /* Place bit 1 in bit 0 of work*/
- " str %[sck_mask],[%[sck_port],#0x4]" "\n\t" /* CODR */
+ A("str %[mosi_mask],[%[mosi_port], %[work],LSL #2]") /* Access the proper SODR or CODR registers based on that bit */
+ A("str %[sck_mask],[%[sck_port]]") /* SODR */
+ A("ubfx %[work],%[txval],#1,#1") /* Place bit 1 in bit 0 of work*/
+ A("str %[sck_mask],[%[sck_port],#0x4]") /* CODR */
/* Bit 1 */
- " str %[mosi_mask],[%[mosi_port], %[work],LSL #2]" "\n\t" /* Access the proper SODR or CODR registers based on that bit */
- " str %[sck_mask],[%[sck_port]]" "\n\t" /* SODR */
- " ubfx %[work],%[txval],#0,#1" "\n\t" /* Place bit 0 in bit 0 of work*/
- " str %[sck_mask],[%[sck_port],#0x4]" "\n\t" /* CODR */
+ A("str %[mosi_mask],[%[mosi_port], %[work],LSL #2]") /* Access the proper SODR or CODR registers based on that bit */
+ A("str %[sck_mask],[%[sck_port]]") /* SODR */
+ A("ubfx %[work],%[txval],#0,#1") /* Place bit 0 in bit 0 of work*/
+ A("str %[sck_mask],[%[sck_port],#0x4]") /* CODR */
/* Bit 0 */
- " str %[mosi_mask],[%[mosi_port], %[work],LSL #2]" "\n\t" /* Access the proper SODR or CODR registers based on that bit */
- " str %[sck_mask],[%[sck_port]]" "\n\t" /* SODR */
- " subs %[todo],#1" "\n\t" /* Decrement count of pending words to send, update status */
- " str %[sck_mask],[%[sck_port],#0x4]" "\n\t" /* CODR */
- " bne.n loop%=" "\n\t" /* Repeat until done */
+ A("str %[mosi_mask],[%[mosi_port], %[work],LSL #2]") /* Access the proper SODR or CODR registers based on that bit */
+ A("str %[sck_mask],[%[sck_port]]") /* SODR */
+ A("subs %[todo],#1") /* Decrement count of pending words to send, update status */
+ A("str %[sck_mask],[%[sck_port],#0x4]") /* CODR */
+ A("bne.n loop%=") /* Repeat until done */
: [ptr]"+r" ( ptr ) ,
[todo]"+r" ( todo ) ,
@@ -413,59 +413,59 @@
__asm__ __volatile__(
".syntax unified" "\n\t" // is to prevent CM0,CM1 non-unified syntax
- " loop%=:" "\n\t"
+ L("loop%=")
/* bit 7 */
- " str %[sck_mask],[%[sck_port]]" "\n\t" /* SODR */
- " ldr %[work],[%[bitband_miso_port]]" "\n\t" /* PDSR on bitband area for required bit: work will be 1 or 0 based on port */
- " str %[sck_mask],[%[sck_port],#0x4]" "\n\t" /* CODR */
- " bfi %[bin],%[work],#7,#1" "\n\t" /* Store read bit as the bit 7 */
+ A("str %[sck_mask],[%[sck_port]]") /* SODR */
+ A("ldr %[work],[%[bitband_miso_port]]") /* PDSR on bitband area for required bit: work will be 1 or 0 based on port */
+ A("str %[sck_mask],[%[sck_port],#0x4]") /* CODR */
+ A("bfi %[bin],%[work],#7,#1") /* Store read bit as the bit 7 */
/* bit 6 */
- " str %[sck_mask],[%[sck_port]]" "\n\t" /* SODR */
- " ldr %[work],[%[bitband_miso_port]]" "\n\t" /* PDSR on bitband area for required bit: work will be 1 or 0 based on port */
- " str %[sck_mask],[%[sck_port],#0x4]" "\n\t" /* CODR */
- " bfi %[bin],%[work],#6,#1" "\n\t" /* Store read bit as the bit 6 */
+ A("str %[sck_mask],[%[sck_port]]") /* SODR */
+ A("ldr %[work],[%[bitband_miso_port]]") /* PDSR on bitband area for required bit: work will be 1 or 0 based on port */
+ A("str %[sck_mask],[%[sck_port],#0x4]") /* CODR */
+ A("bfi %[bin],%[work],#6,#1") /* Store read bit as the bit 6 */
/* bit 5 */
- " str %[sck_mask],[%[sck_port]]" "\n\t" /* SODR */
- " ldr %[work],[%[bitband_miso_port]]" "\n\t" /* PDSR on bitband area for required bit: work will be 1 or 0 based on port */
- " str %[sck_mask],[%[sck_port],#0x4]" "\n\t" /* CODR */
- " bfi %[bin],%[work],#5,#1" "\n\t" /* Store read bit as the bit 5 */
+ A("str %[sck_mask],[%[sck_port]]") /* SODR */
+ A("ldr %[work],[%[bitband_miso_port]]") /* PDSR on bitband area for required bit: work will be 1 or 0 based on port */
+ A("str %[sck_mask],[%[sck_port],#0x4]") /* CODR */
+ A("bfi %[bin],%[work],#5,#1") /* Store read bit as the bit 5 */
/* bit 4 */
- " str %[sck_mask],[%[sck_port]]" "\n\t" /* SODR */
- " ldr %[work],[%[bitband_miso_port]]" "\n\t" /* PDSR on bitband area for required bit: work will be 1 or 0 based on port */
- " str %[sck_mask],[%[sck_port],#0x4]" "\n\t" /* CODR */
- " bfi %[bin],%[work],#4,#1" "\n\t" /* Store read bit as the bit 4 */
+ A("str %[sck_mask],[%[sck_port]]") /* SODR */
+ A("ldr %[work],[%[bitband_miso_port]]") /* PDSR on bitband area for required bit: work will be 1 or 0 based on port */
+ A("str %[sck_mask],[%[sck_port],#0x4]") /* CODR */
+ A("bfi %[bin],%[work],#4,#1") /* Store read bit as the bit 4 */
/* bit 3 */
- " str %[sck_mask],[%[sck_port]]" "\n\t" /* SODR */
- " ldr %[work],[%[bitband_miso_port]]" "\n\t" /* PDSR on bitband area for required bit: work will be 1 or 0 based on port */
- " str %[sck_mask],[%[sck_port],#0x4]" "\n\t" /* CODR */
- " bfi %[bin],%[work],#3,#1" "\n\t" /* Store read bit as the bit 3 */
+ A("str %[sck_mask],[%[sck_port]]") /* SODR */
+ A("ldr %[work],[%[bitband_miso_port]]") /* PDSR on bitband area for required bit: work will be 1 or 0 based on port */
+ A("str %[sck_mask],[%[sck_port],#0x4]") /* CODR */
+ A("bfi %[bin],%[work],#3,#1") /* Store read bit as the bit 3 */
/* bit 2 */
- " str %[sck_mask],[%[sck_port]]" "\n\t" /* SODR */
- " ldr %[work],[%[bitband_miso_port]]" "\n\t" /* PDSR on bitband area for required bit: work will be 1 or 0 based on port */
- " str %[sck_mask],[%[sck_port],#0x4]" "\n\t" /* CODR */
- " bfi %[bin],%[work],#2,#1" "\n\t" /* Store read bit as the bit 2 */
+ A("str %[sck_mask],[%[sck_port]]") /* SODR */
+ A("ldr %[work],[%[bitband_miso_port]]") /* PDSR on bitband area for required bit: work will be 1 or 0 based on port */
+ A("str %[sck_mask],[%[sck_port],#0x4]") /* CODR */
+ A("bfi %[bin],%[work],#2,#1") /* Store read bit as the bit 2 */
/* bit 1 */
- " str %[sck_mask],[%[sck_port]]" "\n\t" /* SODR */
- " ldr %[work],[%[bitband_miso_port]]" "\n\t" /* PDSR on bitband area for required bit: work will be 1 or 0 based on port */
- " str %[sck_mask],[%[sck_port],#0x4]" "\n\t" /* CODR */
- " bfi %[bin],%[work],#1,#1" "\n\t" /* Store read bit as the bit 1 */
+ A("str %[sck_mask],[%[sck_port]]") /* SODR */
+ A("ldr %[work],[%[bitband_miso_port]]") /* PDSR on bitband area for required bit: work will be 1 or 0 based on port */
+ A("str %[sck_mask],[%[sck_port],#0x4]") /* CODR */
+ A("bfi %[bin],%[work],#1,#1") /* Store read bit as the bit 1 */
/* bit 0 */
- " str %[sck_mask],[%[sck_port]]" "\n\t" /* SODR */
- " ldr %[work],[%[bitband_miso_port]]" "\n\t" /* PDSR on bitband area for required bit: work will be 1 or 0 based on port */
- " str %[sck_mask],[%[sck_port],#0x4]" "\n\t" /* CODR */
- " bfi %[bin],%[work],#0,#1" "\n\t" /* Store read bit as the bit 0 */
-
- " subs %[todo],#1" "\n\t" /* Decrement count of pending words to send, update status */
- " strb.w %[bin], [%[ptr]], #1" "\n\t" /* Store read value into buffer, increment buffer pointer */
- " bne.n loop%=" "\n\t" /* Repeat until done */
+ A("str %[sck_mask],[%[sck_port]]") /* SODR */
+ A("ldr %[work],[%[bitband_miso_port]]") /* PDSR on bitband area for required bit: work will be 1 or 0 based on port */
+ A("str %[sck_mask],[%[sck_port],#0x4]") /* CODR */
+ A("bfi %[bin],%[work],#0,#1") /* Store read bit as the bit 0 */
+
+ A("subs %[todo],#1") /* Decrement count of pending words to send, update status */
+ A("strb.w %[bin], [%[ptr]], #1") /* Store read value into buffer, increment buffer pointer */
+ A("bne.n loop%=") /* Repeat until done */
: [ptr]"+r"(ptr),
[todo]"+r"(todo),
diff --git a/Marlin/src/HAL/HAL_DUE/u8g_com_HAL_DUE_st7920_sw_spi.cpp b/Marlin/src/HAL/HAL_DUE/u8g_com_HAL_DUE_st7920_sw_spi.cpp
index 7f46e5c9c81922c050fb8a85af9f487be434f4b6..e8335788d53441f6ae50a750f44079eadb02b284 100644
--- a/Marlin/src/HAL/HAL_DUE/u8g_com_HAL_DUE_st7920_sw_spi.cpp
+++ b/Marlin/src/HAL/HAL_DUE/u8g_com_HAL_DUE_st7920_sw_spi.cpp
@@ -71,8 +71,6 @@ void u8g_SetPILevel_DUE(u8g_t *u8g, uint8_t pin_index, uint8_t level) {
else port->PIO_CODR = mask;
}
-#define nop() __asm__ __volatile__("nop;\n\t":::)
-
void __delay_4cycles(uint32_t cy) __attribute__ ((weak));
FORCE_INLINE void __delay_4cycles(uint32_t cy) { // +1 cycle
@@ -85,10 +83,10 @@ FORCE_INLINE void __delay_4cycles(uint32_t cy) { // +1 cycle
__asm__ __volatile__(
".syntax unified" "\n\t" // is to prevent CM0,CM1 non-unified syntax
- "loop%=:" "\n\t"
- " subs %[cnt],#1" "\n\t"
- EXTRA_NOP_CYCLES "\n\t"
- " bne loop%=" "\n\t"
+ L("loop%=")
+ A("subs %[cnt],#1")
+ A(EXTRA_NOP_CYCLES)
+ A("bne loop%=")
: [cnt]"+r"(cy) // output: +r means input+output
: // input:
: "cc" // clobbers:
diff --git a/Marlin/src/backtrace/unwarmbytab.cpp b/Marlin/src/backtrace/unwarmbytab.cpp
index f3b36ee23638b3bddb58013886aaf9d8bc34af6d..607b426723f72fbf913ab9868eb215056141d3a3 100644
--- a/Marlin/src/backtrace/unwarmbytab.cpp
+++ b/Marlin/src/backtrace/unwarmbytab.cpp
@@ -291,7 +291,7 @@ static inline __attribute__((always_inline)) uint32_t read_psp(void) {
/* Read the current PSP and return its value as a pointer */
uint32_t psp;
- __asm volatile (
+ __asm__ volatile (
" mrs %0, psp \n"
: "=r" (psp) : :
);
diff --git a/Marlin/src/config/default/Configuration_adv.h b/Marlin/src/config/default/Configuration_adv.h
index caad96a406e0464d6f7ff0d37cc0a69fcfb43c26..68ed4eb957ca14c2c518215fc7e29ee016961c3b 100644
--- a/Marlin/src/config/default/Configuration_adv.h
+++ b/Marlin/src/config/default/Configuration_adv.h
@@ -431,6 +431,15 @@
// if unwanted behavior is observed on a user's machine when running at very slow speeds.
#define MINIMUM_PLANNER_SPEED 0.05 // (mm/sec)
+//
+// Use Junction Deviation instead of traditional Jerk Limiting
+//
+//#define JUNCTION_DEVIATION
+#if ENABLED(JUNCTION_DEVIATION)
+ #define JUNCTION_DEVIATION_FACTOR 0.02
+ //#define JUNCTION_DEVIATION_INCLUDE_E
+#endif
+
// Microstep setting (Only functional when stepper driver microstep pins are connected to MCU.
#define MICROSTEP_MODES {16,16,16,16,16} // [1,2,4,8,16]
diff --git a/Marlin/src/config/examples/AlephObjects/TAZ4/Configuration_adv.h b/Marlin/src/config/examples/AlephObjects/TAZ4/Configuration_adv.h
index 1e4f1b89f7e4e3eedd086d0f86e35da2acdd1dfa..bab4103e6d4210ebb76c5aea01432eed32ace1f7 100644
--- a/Marlin/src/config/examples/AlephObjects/TAZ4/Configuration_adv.h
+++ b/Marlin/src/config/examples/AlephObjects/TAZ4/Configuration_adv.h
@@ -431,6 +431,15 @@
// if unwanted behavior is observed on a user's machine when running at very slow speeds.
#define MINIMUM_PLANNER_SPEED 0.05 // (mm/sec)
+//
+// Use Junction Deviation instead of traditional Jerk Limiting
+//
+//#define JUNCTION_DEVIATION
+#if ENABLED(JUNCTION_DEVIATION)
+ #define JUNCTION_DEVIATION_FACTOR 0.02
+ //#define JUNCTION_DEVIATION_INCLUDE_E
+#endif
+
// Microstep setting (Only functional when stepper driver microstep pins are connected to MCU.
#define MICROSTEP_MODES {16,16,4,16,16} // [1,2,4,8,16]
diff --git a/Marlin/src/config/examples/Anet/A6/Configuration_adv.h b/Marlin/src/config/examples/Anet/A6/Configuration_adv.h
index 6c23503f98d4218eec7851ee8d48aafdbccff30f..fdc67aed14a7a02160e8d0c81f3ae103ec0da76d 100644
--- a/Marlin/src/config/examples/Anet/A6/Configuration_adv.h
+++ b/Marlin/src/config/examples/Anet/A6/Configuration_adv.h
@@ -431,6 +431,15 @@
// if unwanted behavior is observed on a user's machine when running at very slow speeds.
#define MINIMUM_PLANNER_SPEED 0.05 // (mm/sec)
+//
+// Use Junction Deviation instead of traditional Jerk Limiting
+//
+//#define JUNCTION_DEVIATION
+#if ENABLED(JUNCTION_DEVIATION)
+ #define JUNCTION_DEVIATION_FACTOR 0.02
+ //#define JUNCTION_DEVIATION_INCLUDE_E
+#endif
+
// Microstep setting (Only functional when stepper driver microstep pins are connected to MCU.
#define MICROSTEP_MODES {16,16,16,16,16} // [1,2,4,8,16]
diff --git a/Marlin/src/config/examples/Anet/A8/Configuration_adv.h b/Marlin/src/config/examples/Anet/A8/Configuration_adv.h
index c1bcbe82f22764e2bd77d8139085ad720cb20d7c..a841baf4c8f8837eb2252383543602b63c1073d3 100644
--- a/Marlin/src/config/examples/Anet/A8/Configuration_adv.h
+++ b/Marlin/src/config/examples/Anet/A8/Configuration_adv.h
@@ -431,6 +431,15 @@
// if unwanted behavior is observed on a user's machine when running at very slow speeds.
#define MINIMUM_PLANNER_SPEED 0.05 // (mm/sec)
+//
+// Use Junction Deviation instead of traditional Jerk Limiting
+//
+//#define JUNCTION_DEVIATION
+#if ENABLED(JUNCTION_DEVIATION)
+ #define JUNCTION_DEVIATION_FACTOR 0.02
+ //#define JUNCTION_DEVIATION_INCLUDE_E
+#endif
+
// Microstep setting (Only functional when stepper driver microstep pins are connected to MCU.
#define MICROSTEP_MODES {16,16,16,16,16} // [1,2,4,8,16]
diff --git a/Marlin/src/config/examples/Azteeg/X5GT/Configuration_adv.h b/Marlin/src/config/examples/Azteeg/X5GT/Configuration_adv.h
index caad96a406e0464d6f7ff0d37cc0a69fcfb43c26..68ed4eb957ca14c2c518215fc7e29ee016961c3b 100644
--- a/Marlin/src/config/examples/Azteeg/X5GT/Configuration_adv.h
+++ b/Marlin/src/config/examples/Azteeg/X5GT/Configuration_adv.h
@@ -431,6 +431,15 @@
// if unwanted behavior is observed on a user's machine when running at very slow speeds.
#define MINIMUM_PLANNER_SPEED 0.05 // (mm/sec)
+//
+// Use Junction Deviation instead of traditional Jerk Limiting
+//
+//#define JUNCTION_DEVIATION
+#if ENABLED(JUNCTION_DEVIATION)
+ #define JUNCTION_DEVIATION_FACTOR 0.02
+ //#define JUNCTION_DEVIATION_INCLUDE_E
+#endif
+
// Microstep setting (Only functional when stepper driver microstep pins are connected to MCU.
#define MICROSTEP_MODES {16,16,16,16,16} // [1,2,4,8,16]
diff --git a/Marlin/src/config/examples/BIBO/TouchX/cyclops/Configuration_adv.h b/Marlin/src/config/examples/BIBO/TouchX/cyclops/Configuration_adv.h
index b49895859bf1561a1dacd267d3b5d81277e77dde..07fb3ec5ac4824ee4cf55682ff44ecca5eea7f71 100644
--- a/Marlin/src/config/examples/BIBO/TouchX/cyclops/Configuration_adv.h
+++ b/Marlin/src/config/examples/BIBO/TouchX/cyclops/Configuration_adv.h
@@ -431,6 +431,15 @@
// if unwanted behavior is observed on a user's machine when running at very slow speeds.
#define MINIMUM_PLANNER_SPEED 0.05 // (mm/sec)
+//
+// Use Junction Deviation instead of traditional Jerk Limiting
+//
+//#define JUNCTION_DEVIATION
+#if ENABLED(JUNCTION_DEVIATION)
+ #define JUNCTION_DEVIATION_FACTOR 0.02
+ //#define JUNCTION_DEVIATION_INCLUDE_E
+#endif
+
// Microstep setting (Only functional when stepper driver microstep pins are connected to MCU.
#define MICROSTEP_MODES {16,16,16,16,16} // [1,2,4,8,16]
diff --git a/Marlin/src/config/examples/BIBO/TouchX/default/Configuration_adv.h b/Marlin/src/config/examples/BIBO/TouchX/default/Configuration_adv.h
index 1d0563338a69b5aeb310c9d530524eafec65fda0..9e66d061d3ea01edbd1c4dbf82074025cd743c5a 100644
--- a/Marlin/src/config/examples/BIBO/TouchX/default/Configuration_adv.h
+++ b/Marlin/src/config/examples/BIBO/TouchX/default/Configuration_adv.h
@@ -431,6 +431,15 @@
// if unwanted behavior is observed on a user's machine when running at very slow speeds.
#define MINIMUM_PLANNER_SPEED 0.05 // (mm/sec)
+//
+// Use Junction Deviation instead of traditional Jerk Limiting
+//
+//#define JUNCTION_DEVIATION
+#if ENABLED(JUNCTION_DEVIATION)
+ #define JUNCTION_DEVIATION_FACTOR 0.02
+ //#define JUNCTION_DEVIATION_INCLUDE_E
+#endif
+
// Microstep setting (Only functional when stepper driver microstep pins are connected to MCU.
#define MICROSTEP_MODES {16,16,16,16,16} // [1,2,4,8,16]
diff --git a/Marlin/src/config/examples/BQ/Hephestos/Configuration_adv.h b/Marlin/src/config/examples/BQ/Hephestos/Configuration_adv.h
index 00bd738c8a420e1fb1e552210ec1bad6f2b722bd..f0846504cf43ea8a9533760f81855ec3ce80aa92 100644
--- a/Marlin/src/config/examples/BQ/Hephestos/Configuration_adv.h
+++ b/Marlin/src/config/examples/BQ/Hephestos/Configuration_adv.h
@@ -431,6 +431,15 @@
// if unwanted behavior is observed on a user's machine when running at very slow speeds.
#define MINIMUM_PLANNER_SPEED 0.05 // (mm/sec)
+//
+// Use Junction Deviation instead of traditional Jerk Limiting
+//
+//#define JUNCTION_DEVIATION
+#if ENABLED(JUNCTION_DEVIATION)
+ #define JUNCTION_DEVIATION_FACTOR 0.02
+ //#define JUNCTION_DEVIATION_INCLUDE_E
+#endif
+
// Microstep setting (Only functional when stepper driver microstep pins are connected to MCU.
#define MICROSTEP_MODES {16,16,16,16,16} // [1,2,4,8,16]
diff --git a/Marlin/src/config/examples/BQ/Hephestos_2/Configuration_adv.h b/Marlin/src/config/examples/BQ/Hephestos_2/Configuration_adv.h
index 3db011d77da4d52cb0dd09aac9fce7747cb5b1e8..fe906c7c5a11e0802e9aebe42ee88c3df2a6f4a6 100644
--- a/Marlin/src/config/examples/BQ/Hephestos_2/Configuration_adv.h
+++ b/Marlin/src/config/examples/BQ/Hephestos_2/Configuration_adv.h
@@ -431,6 +431,15 @@
// if unwanted behavior is observed on a user's machine when running at very slow speeds.
#define MINIMUM_PLANNER_SPEED 0.05 // (mm/sec)
+//
+// Use Junction Deviation instead of traditional Jerk Limiting
+//
+//#define JUNCTION_DEVIATION
+#if ENABLED(JUNCTION_DEVIATION)
+ #define JUNCTION_DEVIATION_FACTOR 0.02
+ //#define JUNCTION_DEVIATION_INCLUDE_E
+#endif
+
// Microstep setting (Only functional when stepper driver microstep pins are connected to MCU.
#define MICROSTEP_MODES {16,16,16,16,16} // [1,2,4,8,16]
diff --git a/Marlin/src/config/examples/BQ/WITBOX/Configuration_adv.h b/Marlin/src/config/examples/BQ/WITBOX/Configuration_adv.h
index 00bd738c8a420e1fb1e552210ec1bad6f2b722bd..f0846504cf43ea8a9533760f81855ec3ce80aa92 100644
--- a/Marlin/src/config/examples/BQ/WITBOX/Configuration_adv.h
+++ b/Marlin/src/config/examples/BQ/WITBOX/Configuration_adv.h
@@ -431,6 +431,15 @@
// if unwanted behavior is observed on a user's machine when running at very slow speeds.
#define MINIMUM_PLANNER_SPEED 0.05 // (mm/sec)
+//
+// Use Junction Deviation instead of traditional Jerk Limiting
+//
+//#define JUNCTION_DEVIATION
+#if ENABLED(JUNCTION_DEVIATION)
+ #define JUNCTION_DEVIATION_FACTOR 0.02
+ //#define JUNCTION_DEVIATION_INCLUDE_E
+#endif
+
// Microstep setting (Only functional when stepper driver microstep pins are connected to MCU.
#define MICROSTEP_MODES {16,16,16,16,16} // [1,2,4,8,16]
diff --git a/Marlin/src/config/examples/Cartesio/Configuration_adv.h b/Marlin/src/config/examples/Cartesio/Configuration_adv.h
index 814cd413de1ed5e7468ce7dbd2deb2f3e341c512..b8801ec12666f5ae13f4f60d15f8474a12f2186a 100644
--- a/Marlin/src/config/examples/Cartesio/Configuration_adv.h
+++ b/Marlin/src/config/examples/Cartesio/Configuration_adv.h
@@ -431,6 +431,15 @@
// if unwanted behavior is observed on a user's machine when running at very slow speeds.
#define MINIMUM_PLANNER_SPEED 0.05 // (mm/sec)
+//
+// Use Junction Deviation instead of traditional Jerk Limiting
+//
+//#define JUNCTION_DEVIATION
+#if ENABLED(JUNCTION_DEVIATION)
+ #define JUNCTION_DEVIATION_FACTOR 0.02
+ //#define JUNCTION_DEVIATION_INCLUDE_E
+#endif
+
// Microstep setting (Only functional when stepper driver microstep pins are connected to MCU.
#define MICROSTEP_MODES {16,16,16,16,16} // [1,2,4,8,16]
diff --git a/Marlin/src/config/examples/Creality/CR-10/Configuration_adv.h b/Marlin/src/config/examples/Creality/CR-10/Configuration_adv.h
index 1df96fa4b5be1d703d2d14663b65dea64e17394e..35918ab5a386c95b1a71b22d7712392ec302f990 100755
--- a/Marlin/src/config/examples/Creality/CR-10/Configuration_adv.h
+++ b/Marlin/src/config/examples/Creality/CR-10/Configuration_adv.h
@@ -431,6 +431,15 @@
// if unwanted behavior is observed on a user's machine when running at very slow speeds.
#define MINIMUM_PLANNER_SPEED 0.05 // (mm/sec)
+//
+// Use Junction Deviation instead of traditional Jerk Limiting
+//
+//#define JUNCTION_DEVIATION
+#if ENABLED(JUNCTION_DEVIATION)
+ #define JUNCTION_DEVIATION_FACTOR 0.02
+ //#define JUNCTION_DEVIATION_INCLUDE_E
+#endif
+
// Microstep setting (Only functional when stepper driver microstep pins are connected to MCU.
#define MICROSTEP_MODES {16,16,16,16,16} // [1,2,4,8,16]
diff --git a/Marlin/src/config/examples/Creality/CR-10S/Configuration_adv.h b/Marlin/src/config/examples/Creality/CR-10S/Configuration_adv.h
index a3127d35e7435a7f3abab16324362ee3ebb25366..9969ff50644233bc6ee4c05321bae1abc144d5ea 100644
--- a/Marlin/src/config/examples/Creality/CR-10S/Configuration_adv.h
+++ b/Marlin/src/config/examples/Creality/CR-10S/Configuration_adv.h
@@ -431,6 +431,15 @@
// if unwanted behavior is observed on a user's machine when running at very slow speeds.
#define MINIMUM_PLANNER_SPEED 0.05 // (mm/sec)
+//
+// Use Junction Deviation instead of traditional Jerk Limiting
+//
+//#define JUNCTION_DEVIATION
+#if ENABLED(JUNCTION_DEVIATION)
+ #define JUNCTION_DEVIATION_FACTOR 0.02
+ //#define JUNCTION_DEVIATION_INCLUDE_E
+#endif
+
// Microstep setting (Only functional when stepper driver microstep pins are connected to MCU.
#define MICROSTEP_MODES {16,16,16,16,16} // [1,2,4,8,16]
diff --git a/Marlin/src/config/examples/Creality/CR-10mini/Configuration_adv.h b/Marlin/src/config/examples/Creality/CR-10mini/Configuration_adv.h
index 714e69ff87ff5a957159dc8ca7d084e490298f54..cbc731d1efdc2330a68bb7573c0ece07dcc196c8 100644
--- a/Marlin/src/config/examples/Creality/CR-10mini/Configuration_adv.h
+++ b/Marlin/src/config/examples/Creality/CR-10mini/Configuration_adv.h
@@ -431,6 +431,15 @@
// if unwanted behavior is observed on a user's machine when running at very slow speeds.
#define MINIMUM_PLANNER_SPEED 0.05 // (mm/sec)
+//
+// Use Junction Deviation instead of traditional Jerk Limiting
+//
+//#define JUNCTION_DEVIATION
+#if ENABLED(JUNCTION_DEVIATION)
+ #define JUNCTION_DEVIATION_FACTOR 0.02
+ //#define JUNCTION_DEVIATION_INCLUDE_E
+#endif
+
// Microstep setting (Only functional when stepper driver microstep pins are connected to MCU.
#define MICROSTEP_MODES {16,16,16,16,16} // [1,2,4,8,16]
diff --git a/Marlin/src/config/examples/Creality/CR-8/Configuration_adv.h b/Marlin/src/config/examples/Creality/CR-8/Configuration_adv.h
index b6836be99cf9ee00b4454f6ab1b54becebe9cc7c..3c952ae607f272981efb63653ab0d6c463d3e88e 100644
--- a/Marlin/src/config/examples/Creality/CR-8/Configuration_adv.h
+++ b/Marlin/src/config/examples/Creality/CR-8/Configuration_adv.h
@@ -431,6 +431,15 @@
// if unwanted behavior is observed on a user's machine when running at very slow speeds.
#define MINIMUM_PLANNER_SPEED 0.05 // (mm/sec)
+//
+// Use Junction Deviation instead of traditional Jerk Limiting
+//
+//#define JUNCTION_DEVIATION
+#if ENABLED(JUNCTION_DEVIATION)
+ #define JUNCTION_DEVIATION_FACTOR 0.02
+ //#define JUNCTION_DEVIATION_INCLUDE_E
+#endif
+
// Microstep setting (Only functional when stepper driver microstep pins are connected to MCU.
#define MICROSTEP_MODES {16,16,16,16,16} // [1,2,4,8,16]
diff --git a/Marlin/src/config/examples/Creality/Ender-2/Configuration_adv.h b/Marlin/src/config/examples/Creality/Ender-2/Configuration_adv.h
index 6561600eca3741d067949e0fa44c3143ab833205..0cb40fa7f997e5f09ba8e83cce9ab8a1add0d1ef 100644
--- a/Marlin/src/config/examples/Creality/Ender-2/Configuration_adv.h
+++ b/Marlin/src/config/examples/Creality/Ender-2/Configuration_adv.h
@@ -431,6 +431,15 @@
// if unwanted behavior is observed on a user's machine when running at very slow speeds.
#define MINIMUM_PLANNER_SPEED 0.05 // (mm/sec)
+//
+// Use Junction Deviation instead of traditional Jerk Limiting
+//
+//#define JUNCTION_DEVIATION
+#if ENABLED(JUNCTION_DEVIATION)
+ #define JUNCTION_DEVIATION_FACTOR 0.02
+ //#define JUNCTION_DEVIATION_INCLUDE_E
+#endif
+
// Microstep setting (Only functional when stepper driver microstep pins are connected to MCU.
#define MICROSTEP_MODES {16,16,16,16,16} // [1,2,4,8,16]
diff --git a/Marlin/src/config/examples/Creality/Ender-3/Configuration_adv.h b/Marlin/src/config/examples/Creality/Ender-3/Configuration_adv.h
index 097fee297cf629dbdeef9cefe44cce44aca8e195..463c8f120a6bda09cec72355cecea32319f571de 100644
--- a/Marlin/src/config/examples/Creality/Ender-3/Configuration_adv.h
+++ b/Marlin/src/config/examples/Creality/Ender-3/Configuration_adv.h
@@ -431,6 +431,15 @@
// if unwanted behavior is observed on a user's machine when running at very slow speeds.
#define MINIMUM_PLANNER_SPEED 0.05 // (mm/sec)
+//
+// Use Junction Deviation instead of traditional Jerk Limiting
+//
+//#define JUNCTION_DEVIATION
+#if ENABLED(JUNCTION_DEVIATION)
+ #define JUNCTION_DEVIATION_FACTOR 0.02
+ //#define JUNCTION_DEVIATION_INCLUDE_E
+#endif
+
// Microstep setting (Only functional when stepper driver microstep pins are connected to MCU.
#define MICROSTEP_MODES {16,16,16,16,16} // [1,2,4,8,16]
diff --git a/Marlin/src/config/examples/Creality/Ender-4/Configuration_adv.h b/Marlin/src/config/examples/Creality/Ender-4/Configuration_adv.h
index b6836be99cf9ee00b4454f6ab1b54becebe9cc7c..3c952ae607f272981efb63653ab0d6c463d3e88e 100644
--- a/Marlin/src/config/examples/Creality/Ender-4/Configuration_adv.h
+++ b/Marlin/src/config/examples/Creality/Ender-4/Configuration_adv.h
@@ -431,6 +431,15 @@
// if unwanted behavior is observed on a user's machine when running at very slow speeds.
#define MINIMUM_PLANNER_SPEED 0.05 // (mm/sec)
+//
+// Use Junction Deviation instead of traditional Jerk Limiting
+//
+//#define JUNCTION_DEVIATION
+#if ENABLED(JUNCTION_DEVIATION)
+ #define JUNCTION_DEVIATION_FACTOR 0.02
+ //#define JUNCTION_DEVIATION_INCLUDE_E
+#endif
+
// Microstep setting (Only functional when stepper driver microstep pins are connected to MCU.
#define MICROSTEP_MODES {16,16,16,16,16} // [1,2,4,8,16]
diff --git a/Marlin/src/config/examples/Felix/Configuration_adv.h b/Marlin/src/config/examples/Felix/Configuration_adv.h
index b22f4b1e79670a172991d31de5cefc10b31126b5..d39edda378851cf1db6931442abbe7f1d2140691 100644
--- a/Marlin/src/config/examples/Felix/Configuration_adv.h
+++ b/Marlin/src/config/examples/Felix/Configuration_adv.h
@@ -431,6 +431,15 @@
// if unwanted behavior is observed on a user's machine when running at very slow speeds.
#define MINIMUM_PLANNER_SPEED 0.05 // (mm/sec)
+//
+// Use Junction Deviation instead of traditional Jerk Limiting
+//
+//#define JUNCTION_DEVIATION
+#if ENABLED(JUNCTION_DEVIATION)
+ #define JUNCTION_DEVIATION_FACTOR 0.02
+ //#define JUNCTION_DEVIATION_INCLUDE_E
+#endif
+
// Microstep setting (Only functional when stepper driver microstep pins are connected to MCU.
#define MICROSTEP_MODES {16,16,16,16,16} // [1,2,4,8,16]
diff --git a/Marlin/src/config/examples/FolgerTech/i3-2020/Configuration_adv.h b/Marlin/src/config/examples/FolgerTech/i3-2020/Configuration_adv.h
index bdf61b7c76d58c657061dfca7ee6450e4ddee726..4f91773777fbf5aa9624e49a5ca2e95f3914fc0d 100644
--- a/Marlin/src/config/examples/FolgerTech/i3-2020/Configuration_adv.h
+++ b/Marlin/src/config/examples/FolgerTech/i3-2020/Configuration_adv.h
@@ -431,6 +431,15 @@
// if unwanted behavior is observed on a user's machine when running at very slow speeds.
#define MINIMUM_PLANNER_SPEED 0.05 // (mm/sec)
+//
+// Use Junction Deviation instead of traditional Jerk Limiting
+//
+//#define JUNCTION_DEVIATION
+#if ENABLED(JUNCTION_DEVIATION)
+ #define JUNCTION_DEVIATION_FACTOR 0.02
+ //#define JUNCTION_DEVIATION_INCLUDE_E
+#endif
+
// Microstep setting (Only functional when stepper driver microstep pins are connected to MCU.
#define MICROSTEP_MODES {16,16,16,16,16} // [1,2,4,8,16]
diff --git a/Marlin/src/config/examples/Geeetech/Prusa i3 Pro C/Configuration_adv.h b/Marlin/src/config/examples/Geeetech/Prusa i3 Pro C/Configuration_adv.h
index d59b0814edba043ede14fa864e82ef0dc527a241..eea3d10fef5ba832dde69ad3541f62525bb93d95 100644
--- a/Marlin/src/config/examples/Geeetech/Prusa i3 Pro C/Configuration_adv.h
+++ b/Marlin/src/config/examples/Geeetech/Prusa i3 Pro C/Configuration_adv.h
@@ -431,6 +431,15 @@
// if unwanted behavior is observed on a user's machine when running at very slow speeds.
#define MINIMUM_PLANNER_SPEED 0.05 // (mm/sec)
+//
+// Use Junction Deviation instead of traditional Jerk Limiting
+//
+//#define JUNCTION_DEVIATION
+#if ENABLED(JUNCTION_DEVIATION)
+ #define JUNCTION_DEVIATION_FACTOR 0.02
+ //#define JUNCTION_DEVIATION_INCLUDE_E
+#endif
+
// Microstep setting (Only functional when stepper driver microstep pins are connected to MCU.
#define MICROSTEP_MODES {16,16,16,16,16} // [1,2,4,8,16]
diff --git a/Marlin/src/config/examples/Geeetech/Prusa i3 Pro W/Configuration_adv.h b/Marlin/src/config/examples/Geeetech/Prusa i3 Pro W/Configuration_adv.h
index d59b0814edba043ede14fa864e82ef0dc527a241..eea3d10fef5ba832dde69ad3541f62525bb93d95 100644
--- a/Marlin/src/config/examples/Geeetech/Prusa i3 Pro W/Configuration_adv.h
+++ b/Marlin/src/config/examples/Geeetech/Prusa i3 Pro W/Configuration_adv.h
@@ -431,6 +431,15 @@
// if unwanted behavior is observed on a user's machine when running at very slow speeds.
#define MINIMUM_PLANNER_SPEED 0.05 // (mm/sec)
+//
+// Use Junction Deviation instead of traditional Jerk Limiting
+//
+//#define JUNCTION_DEVIATION
+#if ENABLED(JUNCTION_DEVIATION)
+ #define JUNCTION_DEVIATION_FACTOR 0.02
+ //#define JUNCTION_DEVIATION_INCLUDE_E
+#endif
+
// Microstep setting (Only functional when stepper driver microstep pins are connected to MCU.
#define MICROSTEP_MODES {16,16,16,16,16} // [1,2,4,8,16]
diff --git a/Marlin/src/config/examples/Infitary/i3-M508/Configuration_adv.h b/Marlin/src/config/examples/Infitary/i3-M508/Configuration_adv.h
index a5f53e6658c5b8a1f8ca578779017e974476259c..70981e71f1a380265790a052f627255a72ea9d5f 100644
--- a/Marlin/src/config/examples/Infitary/i3-M508/Configuration_adv.h
+++ b/Marlin/src/config/examples/Infitary/i3-M508/Configuration_adv.h
@@ -431,6 +431,15 @@
// if unwanted behavior is observed on a user's machine when running at very slow speeds.
#define MINIMUM_PLANNER_SPEED 0.05 // (mm/sec)
+//
+// Use Junction Deviation instead of traditional Jerk Limiting
+//
+//#define JUNCTION_DEVIATION
+#if ENABLED(JUNCTION_DEVIATION)
+ #define JUNCTION_DEVIATION_FACTOR 0.02
+ //#define JUNCTION_DEVIATION_INCLUDE_E
+#endif
+
// Microstep setting (Only functional when stepper driver microstep pins are connected to MCU.
#define MICROSTEP_MODES {16,16,16,16,16} // [1,2,4,8,16]
diff --git a/Marlin/src/config/examples/JGAurora/A5/Configuration_adv.h b/Marlin/src/config/examples/JGAurora/A5/Configuration_adv.h
index 88b455b8eb0c7d466230988ca11e8e2b15f70334..e6f5efe4fb06791d1756448f53c3b381f9d4b5f3 100644
--- a/Marlin/src/config/examples/JGAurora/A5/Configuration_adv.h
+++ b/Marlin/src/config/examples/JGAurora/A5/Configuration_adv.h
@@ -431,6 +431,15 @@
// if unwanted behavior is observed on a user's machine when running at very slow speeds.
#define MINIMUM_PLANNER_SPEED 0.05 // (mm/sec)
+//
+// Use Junction Deviation instead of traditional Jerk Limiting
+//
+//#define JUNCTION_DEVIATION
+#if ENABLED(JUNCTION_DEVIATION)
+ #define JUNCTION_DEVIATION_FACTOR 0.02
+ //#define JUNCTION_DEVIATION_INCLUDE_E
+#endif
+
// Microstep setting (Only functional when stepper driver microstep pins are connected to MCU.
#define MICROSTEP_MODES {16,16,16,16,16} // [1,2,4,8,16]
diff --git a/Marlin/src/config/examples/MakerParts/Configuration_adv.h b/Marlin/src/config/examples/MakerParts/Configuration_adv.h
index 81af968a4a52f8c0aa049f90d3d30dfbfb5ffee5..699236c4ee0e91f4a80084110ad5a44519cb34ab 100644
--- a/Marlin/src/config/examples/MakerParts/Configuration_adv.h
+++ b/Marlin/src/config/examples/MakerParts/Configuration_adv.h
@@ -431,6 +431,15 @@
// if unwanted behavior is observed on a user's machine when running at very slow speeds.
#define MINIMUM_PLANNER_SPEED 0.05 // (mm/sec)
+//
+// Use Junction Deviation instead of traditional Jerk Limiting
+//
+//#define JUNCTION_DEVIATION
+#if ENABLED(JUNCTION_DEVIATION)
+ #define JUNCTION_DEVIATION_FACTOR 0.02
+ //#define JUNCTION_DEVIATION_INCLUDE_E
+#endif
+
// Microstep setting (Only functional when stepper driver microstep pins are connected to MCU.
#define MICROSTEP_MODES {16,16,16,16,16} // [1,2,4,8,16]
diff --git a/Marlin/src/config/examples/Malyan/M150/Configuration_adv.h b/Marlin/src/config/examples/Malyan/M150/Configuration_adv.h
index e4217a1b1da400d4cca4838fb9cc077377e1d68c..e9e8c34eb7ef7661e4bab6833fafec64521fd323 100644
--- a/Marlin/src/config/examples/Malyan/M150/Configuration_adv.h
+++ b/Marlin/src/config/examples/Malyan/M150/Configuration_adv.h
@@ -431,6 +431,15 @@
// if unwanted behavior is observed on a user's machine when running at very slow speeds.
#define MINIMUM_PLANNER_SPEED 0.05 // (mm/sec)
+//
+// Use Junction Deviation instead of traditional Jerk Limiting
+//
+//#define JUNCTION_DEVIATION
+#if ENABLED(JUNCTION_DEVIATION)
+ #define JUNCTION_DEVIATION_FACTOR 0.02
+ //#define JUNCTION_DEVIATION_INCLUDE_E
+#endif
+
// Microstep setting (Only functional when stepper driver microstep pins are connected to MCU.
#define MICROSTEP_MODES {16,16,16,16,16} // [1,2,4,8,16]
diff --git a/Marlin/src/config/examples/Malyan/M200/Configuration_adv.h b/Marlin/src/config/examples/Malyan/M200/Configuration_adv.h
index dc31b6b0b8a476483d112b52c33aaf5f67cb2b04..9008c1cdffeb6204cb65f9dc0127b527811f6313 100644
--- a/Marlin/src/config/examples/Malyan/M200/Configuration_adv.h
+++ b/Marlin/src/config/examples/Malyan/M200/Configuration_adv.h
@@ -431,6 +431,15 @@
// if unwanted behavior is observed on a user's machine when running at very slow speeds.
#define MINIMUM_PLANNER_SPEED 0.05 // (mm/sec)
+//
+// Use Junction Deviation instead of traditional Jerk Limiting
+//
+//#define JUNCTION_DEVIATION
+#if ENABLED(JUNCTION_DEVIATION)
+ #define JUNCTION_DEVIATION_FACTOR 0.02
+ //#define JUNCTION_DEVIATION_INCLUDE_E
+#endif
+
// Microstep setting (Only functional when stepper driver microstep pins are connected to MCU.
#define MICROSTEP_MODES {16,16,16,16,16} // [1,2,4,8,16]
diff --git a/Marlin/src/config/examples/Micromake/C1/enhanced/Configuration_adv.h b/Marlin/src/config/examples/Micromake/C1/enhanced/Configuration_adv.h
index 1e4f77db524c29372bc78f3f36ddf39d9132b562..6948d246906ad91d0adb1b9e1e7678ab88ff039c 100644
--- a/Marlin/src/config/examples/Micromake/C1/enhanced/Configuration_adv.h
+++ b/Marlin/src/config/examples/Micromake/C1/enhanced/Configuration_adv.h
@@ -431,6 +431,15 @@
// if unwanted behavior is observed on a user's machine when running at very slow speeds.
#define MINIMUM_PLANNER_SPEED 0.05 // (mm/sec)
+//
+// Use Junction Deviation instead of traditional Jerk Limiting
+//
+//#define JUNCTION_DEVIATION
+#if ENABLED(JUNCTION_DEVIATION)
+ #define JUNCTION_DEVIATION_FACTOR 0.02
+ //#define JUNCTION_DEVIATION_INCLUDE_E
+#endif
+
// Microstep setting (Only functional when stepper driver microstep pins are connected to MCU.
#define MICROSTEP_MODES {16,16,16,16,16} // [1,2,4,8,16]
diff --git a/Marlin/src/config/examples/Mks/Sbase/Configuration_adv.h b/Marlin/src/config/examples/Mks/Sbase/Configuration_adv.h
index 72e6c02946dd2134b205fd405c083679c3e77c4b..7ee3c9d59db95aae5b27cd5fcc5c22b66bb3719f 100644
--- a/Marlin/src/config/examples/Mks/Sbase/Configuration_adv.h
+++ b/Marlin/src/config/examples/Mks/Sbase/Configuration_adv.h
@@ -431,6 +431,15 @@
// if unwanted behavior is observed on a user's machine when running at very slow speeds.
#define MINIMUM_PLANNER_SPEED 0.05 // (mm/sec)
+//
+// Use Junction Deviation instead of traditional Jerk Limiting
+//
+//#define JUNCTION_DEVIATION
+#if ENABLED(JUNCTION_DEVIATION)
+ #define JUNCTION_DEVIATION_FACTOR 0.02
+ //#define JUNCTION_DEVIATION_INCLUDE_E
+#endif
+
// Microstep setting (Only functional when stepper driver microstep pins are connected to MCU.
#define MICROSTEP_MODES {16,16,16,16,16} // [1,2,4,8,16]
diff --git a/Marlin/src/config/examples/RigidBot/Configuration_adv.h b/Marlin/src/config/examples/RigidBot/Configuration_adv.h
index d7f2edd81c3ecef7cdb27a2bcfc12c9ceef6595e..abe863f4621d3d2d1d8fde10f20ad15b3f264838 100644
--- a/Marlin/src/config/examples/RigidBot/Configuration_adv.h
+++ b/Marlin/src/config/examples/RigidBot/Configuration_adv.h
@@ -431,6 +431,15 @@
// if unwanted behavior is observed on a user's machine when running at very slow speeds.
#define MINIMUM_PLANNER_SPEED 0.05 // (mm/sec)
+//
+// Use Junction Deviation instead of traditional Jerk Limiting
+//
+//#define JUNCTION_DEVIATION
+#if ENABLED(JUNCTION_DEVIATION)
+ #define JUNCTION_DEVIATION_FACTOR 0.02
+ //#define JUNCTION_DEVIATION_INCLUDE_E
+#endif
+
// Microstep setting (Only functional when stepper driver microstep pins are connected to MCU.
#define MICROSTEP_MODES {16,16,16,16,16} // [1,2,4,8,16]
diff --git a/Marlin/src/config/examples/SCARA/Configuration_adv.h b/Marlin/src/config/examples/SCARA/Configuration_adv.h
index bdab33d3afbd91fe873a6a20ccecc82c990799b6..fe0ac67b48f21beae6665da377a2e463240d1960 100644
--- a/Marlin/src/config/examples/SCARA/Configuration_adv.h
+++ b/Marlin/src/config/examples/SCARA/Configuration_adv.h
@@ -431,6 +431,15 @@
// if unwanted behavior is observed on a user's machine when running at very slow speeds.
#define MINIMUM_PLANNER_SPEED 0.05 // (mm/sec)
+//
+// Use Junction Deviation instead of traditional Jerk Limiting
+//
+//#define JUNCTION_DEVIATION
+#if ENABLED(JUNCTION_DEVIATION)
+ #define JUNCTION_DEVIATION_FACTOR 0.02
+ //#define JUNCTION_DEVIATION_INCLUDE_E
+#endif
+
// Microstep setting (Only functional when stepper driver microstep pins are connected to MCU.
#define MICROSTEP_MODES {16,16,16,16,16} // [1,2,4,8,16]
diff --git a/Marlin/src/config/examples/Sanguinololu/Configuration_adv.h b/Marlin/src/config/examples/Sanguinololu/Configuration_adv.h
index 36cf3838162d2a187e136f2eab8cea1063088e5e..20183a8cf6a4ed733ececb421491e7eb3d16dd94 100644
--- a/Marlin/src/config/examples/Sanguinololu/Configuration_adv.h
+++ b/Marlin/src/config/examples/Sanguinololu/Configuration_adv.h
@@ -431,6 +431,15 @@
// if unwanted behavior is observed on a user's machine when running at very slow speeds.
#define MINIMUM_PLANNER_SPEED 0.05 // (mm/sec)
+//
+// Use Junction Deviation instead of traditional Jerk Limiting
+//
+//#define JUNCTION_DEVIATION
+#if ENABLED(JUNCTION_DEVIATION)
+ #define JUNCTION_DEVIATION_FACTOR 0.02
+ //#define JUNCTION_DEVIATION_INCLUDE_E
+#endif
+
// Microstep setting (Only functional when stepper driver microstep pins are connected to MCU.
#define MICROSTEP_MODES {16,16,16,16,16} // [1,2,4,8,16]
diff --git a/Marlin/src/config/examples/TheBorg/Configuration_adv.h b/Marlin/src/config/examples/TheBorg/Configuration_adv.h
index 95ecd0134666ea20f303c81ce93c43a68f7866bd..b4252b2a0ab26526bb967df82b3ef58a390644c2 100644
--- a/Marlin/src/config/examples/TheBorg/Configuration_adv.h
+++ b/Marlin/src/config/examples/TheBorg/Configuration_adv.h
@@ -431,6 +431,15 @@
// if unwanted behavior is observed on a user's machine when running at very slow speeds.
#define MINIMUM_PLANNER_SPEED 0.05 // (mm/sec)
+//
+// Use Junction Deviation instead of traditional Jerk Limiting
+//
+//#define JUNCTION_DEVIATION
+#if ENABLED(JUNCTION_DEVIATION)
+ #define JUNCTION_DEVIATION_FACTOR 0.02
+ //#define JUNCTION_DEVIATION_INCLUDE_E
+#endif
+
// Microstep setting (Only functional when stepper driver microstep pins are connected to MCU.
#define MICROSTEP_MODES {16,16,16,16,16} // [1,2,4,8,16]
diff --git a/Marlin/src/config/examples/TinyBoy2/Configuration_adv.h b/Marlin/src/config/examples/TinyBoy2/Configuration_adv.h
index b643652d2e37eeee5fb0bdd69291dba629e7e3a5..10b0a492546601d36f034a6291c72b1b090daff1 100644
--- a/Marlin/src/config/examples/TinyBoy2/Configuration_adv.h
+++ b/Marlin/src/config/examples/TinyBoy2/Configuration_adv.h
@@ -431,6 +431,15 @@
// if unwanted behavior is observed on a user's machine when running at very slow speeds.
#define MINIMUM_PLANNER_SPEED 0.05 // (mm/sec)
+//
+// Use Junction Deviation instead of traditional Jerk Limiting
+//
+//#define JUNCTION_DEVIATION
+#if ENABLED(JUNCTION_DEVIATION)
+ #define JUNCTION_DEVIATION_FACTOR 0.02
+ //#define JUNCTION_DEVIATION_INCLUDE_E
+#endif
+
// Microstep setting (Only functional when stepper driver microstep pins are connected to MCU.
#define MICROSTEP_MODES {16,16,16,16,16} // [1,2,4,8,16]
diff --git a/Marlin/src/config/examples/UltiMachine/Archim2/Configuration_adv.h b/Marlin/src/config/examples/UltiMachine/Archim2/Configuration_adv.h
index d7f1800ee5ce2543c79f3fb0330aaea79922395b..427acace503d2be6fe3881ff12acf1ce4d5ff742 100644
--- a/Marlin/src/config/examples/UltiMachine/Archim2/Configuration_adv.h
+++ b/Marlin/src/config/examples/UltiMachine/Archim2/Configuration_adv.h
@@ -431,6 +431,15 @@
// if unwanted behavior is observed on a user's machine when running at very slow speeds.
#define MINIMUM_PLANNER_SPEED 0.05 // (mm/sec)
+//
+// Use Junction Deviation instead of traditional Jerk Limiting
+//
+//#define JUNCTION_DEVIATION
+#if ENABLED(JUNCTION_DEVIATION)
+ #define JUNCTION_DEVIATION_FACTOR 0.02
+ //#define JUNCTION_DEVIATION_INCLUDE_E
+#endif
+
// Microstep setting (Only functional when stepper driver microstep pins are connected to MCU.
#define MICROSTEP_MODES {16,16,16,16,16} // [1,2,4,8,16]
diff --git a/Marlin/src/config/examples/Velleman/K8200/Configuration_adv.h b/Marlin/src/config/examples/Velleman/K8200/Configuration_adv.h
index dc8eef4f682762fb141c29b7707887b5dfe845dd..4cb83d16fe7fa86728f9a326cf2d110bcb61ab3a 100644
--- a/Marlin/src/config/examples/Velleman/K8200/Configuration_adv.h
+++ b/Marlin/src/config/examples/Velleman/K8200/Configuration_adv.h
@@ -444,6 +444,15 @@
// if unwanted behavior is observed on a user's machine when running at very slow speeds.
#define MINIMUM_PLANNER_SPEED 0.05 // (mm/sec)
+//
+// Use Junction Deviation instead of traditional Jerk Limiting
+//
+//#define JUNCTION_DEVIATION
+#if ENABLED(JUNCTION_DEVIATION)
+ #define JUNCTION_DEVIATION_FACTOR 0.02
+ //#define JUNCTION_DEVIATION_INCLUDE_E
+#endif
+
// Microstep setting (Only functional when stepper driver microstep pins are connected to MCU.
#define MICROSTEP_MODES {16,16,16,16,16} // [1,2,4,8,16]
diff --git a/Marlin/src/config/examples/Velleman/K8400/Configuration_adv.h b/Marlin/src/config/examples/Velleman/K8400/Configuration_adv.h
index 84b29f46c28e1c17b7657a0f7f221fd84a7e2f8e..11db883d82f46f0adfff7d93a6bb04bb1b619588 100644
--- a/Marlin/src/config/examples/Velleman/K8400/Configuration_adv.h
+++ b/Marlin/src/config/examples/Velleman/K8400/Configuration_adv.h
@@ -431,6 +431,15 @@
// if unwanted behavior is observed on a user's machine when running at very slow speeds.
#define MINIMUM_PLANNER_SPEED 0.05 // (mm/sec)
+//
+// Use Junction Deviation instead of traditional Jerk Limiting
+//
+//#define JUNCTION_DEVIATION
+#if ENABLED(JUNCTION_DEVIATION)
+ #define JUNCTION_DEVIATION_FACTOR 0.02
+ //#define JUNCTION_DEVIATION_INCLUDE_E
+#endif
+
// Microstep setting (Only functional when stepper driver microstep pins are connected to MCU.
#define MICROSTEP_MODES {16,16,16,16,16} // [1,2,4,8,16]
diff --git a/Marlin/src/config/examples/Wanhao/Duplicator 6/Configuration_adv.h b/Marlin/src/config/examples/Wanhao/Duplicator 6/Configuration_adv.h
index e553c96bec8bc03b300ac078099cc3609e6e89e5..b4ba8fbf4f0c26053221b837cd7228b1d461cdb3 100644
--- a/Marlin/src/config/examples/Wanhao/Duplicator 6/Configuration_adv.h
+++ b/Marlin/src/config/examples/Wanhao/Duplicator 6/Configuration_adv.h
@@ -431,6 +431,15 @@
// if unwanted behavior is observed on a user's machine when running at very slow speeds.
#define MINIMUM_PLANNER_SPEED 0.05 // (mm/sec)
+//
+// Use Junction Deviation instead of traditional Jerk Limiting
+//
+//#define JUNCTION_DEVIATION
+#if ENABLED(JUNCTION_DEVIATION)
+ #define JUNCTION_DEVIATION_FACTOR 0.02
+ //#define JUNCTION_DEVIATION_INCLUDE_E
+#endif
+
// Microstep setting (Only functional when stepper driver microstep pins are connected to MCU.
#define MICROSTEP_MODES {16,16,16,16,16} // [1,2,4,8,16]
diff --git a/Marlin/src/config/examples/delta/FLSUN/auto_calibrate/Configuration_adv.h b/Marlin/src/config/examples/delta/FLSUN/auto_calibrate/Configuration_adv.h
index 1ac881501c36928ce4c1b165c9da3c36dd5a4494..87af2a742bacea795e3274ffd8df6b9330b853c4 100644
--- a/Marlin/src/config/examples/delta/FLSUN/auto_calibrate/Configuration_adv.h
+++ b/Marlin/src/config/examples/delta/FLSUN/auto_calibrate/Configuration_adv.h
@@ -433,6 +433,15 @@
// if unwanted behavior is observed on a user's machine when running at very slow speeds.
#define MINIMUM_PLANNER_SPEED 0.05 // (mm/sec)
+//
+// Use Junction Deviation instead of traditional Jerk Limiting
+//
+//#define JUNCTION_DEVIATION
+#if ENABLED(JUNCTION_DEVIATION)
+ #define JUNCTION_DEVIATION_FACTOR 0.02
+ //#define JUNCTION_DEVIATION_INCLUDE_E
+#endif
+
// Microstep setting (Only functional when stepper driver microstep pins are connected to MCU.
#define MICROSTEP_MODES {16,16,16,16,16} // [1,2,4,8,16]
diff --git a/Marlin/src/config/examples/delta/FLSUN/kossel/Configuration_adv.h b/Marlin/src/config/examples/delta/FLSUN/kossel/Configuration_adv.h
index 8cfdf1f155c4c570d3b7362da59bd1304c94f1ce..1ba74a3c084d0fbccb95f00f3d51732004d0a6d6 100644
--- a/Marlin/src/config/examples/delta/FLSUN/kossel/Configuration_adv.h
+++ b/Marlin/src/config/examples/delta/FLSUN/kossel/Configuration_adv.h
@@ -433,6 +433,15 @@
// if unwanted behavior is observed on a user's machine when running at very slow speeds.
#define MINIMUM_PLANNER_SPEED 0.05 // (mm/sec)
+//
+// Use Junction Deviation instead of traditional Jerk Limiting
+//
+//#define JUNCTION_DEVIATION
+#if ENABLED(JUNCTION_DEVIATION)
+ #define JUNCTION_DEVIATION_FACTOR 0.02
+ //#define JUNCTION_DEVIATION_INCLUDE_E
+#endif
+
// Microstep setting (Only functional when stepper driver microstep pins are connected to MCU.
#define MICROSTEP_MODES {16,16,16,16,16} // [1,2,4,8,16]
diff --git a/Marlin/src/config/examples/delta/FLSUN/kossel_mini/Configuration_adv.h b/Marlin/src/config/examples/delta/FLSUN/kossel_mini/Configuration_adv.h
index 9350070322abb361824ea26e28c3a962826e3560..7877a3dc0f38568d0372906ff50abf112ed23eec 100644
--- a/Marlin/src/config/examples/delta/FLSUN/kossel_mini/Configuration_adv.h
+++ b/Marlin/src/config/examples/delta/FLSUN/kossel_mini/Configuration_adv.h
@@ -433,6 +433,15 @@
// if unwanted behavior is observed on a user's machine when running at very slow speeds.
#define MINIMUM_PLANNER_SPEED 0.05 // (mm/sec)
+//
+// Use Junction Deviation instead of traditional Jerk Limiting
+//
+//#define JUNCTION_DEVIATION
+#if ENABLED(JUNCTION_DEVIATION)
+ #define JUNCTION_DEVIATION_FACTOR 0.02
+ //#define JUNCTION_DEVIATION_INCLUDE_E
+#endif
+
// Microstep setting (Only functional when stepper driver microstep pins are connected to MCU.
#define MICROSTEP_MODES {16,16,16,16,16} // [1,2,4,8,16]
diff --git a/Marlin/src/config/examples/delta/generic/Configuration_adv.h b/Marlin/src/config/examples/delta/generic/Configuration_adv.h
index 9350070322abb361824ea26e28c3a962826e3560..7877a3dc0f38568d0372906ff50abf112ed23eec 100644
--- a/Marlin/src/config/examples/delta/generic/Configuration_adv.h
+++ b/Marlin/src/config/examples/delta/generic/Configuration_adv.h
@@ -433,6 +433,15 @@
// if unwanted behavior is observed on a user's machine when running at very slow speeds.
#define MINIMUM_PLANNER_SPEED 0.05 // (mm/sec)
+//
+// Use Junction Deviation instead of traditional Jerk Limiting
+//
+//#define JUNCTION_DEVIATION
+#if ENABLED(JUNCTION_DEVIATION)
+ #define JUNCTION_DEVIATION_FACTOR 0.02
+ //#define JUNCTION_DEVIATION_INCLUDE_E
+#endif
+
// Microstep setting (Only functional when stepper driver microstep pins are connected to MCU.
#define MICROSTEP_MODES {16,16,16,16,16} // [1,2,4,8,16]
diff --git a/Marlin/src/config/examples/delta/kossel_mini/Configuration_adv.h b/Marlin/src/config/examples/delta/kossel_mini/Configuration_adv.h
index 9350070322abb361824ea26e28c3a962826e3560..7877a3dc0f38568d0372906ff50abf112ed23eec 100644
--- a/Marlin/src/config/examples/delta/kossel_mini/Configuration_adv.h
+++ b/Marlin/src/config/examples/delta/kossel_mini/Configuration_adv.h
@@ -433,6 +433,15 @@
// if unwanted behavior is observed on a user's machine when running at very slow speeds.
#define MINIMUM_PLANNER_SPEED 0.05 // (mm/sec)
+//
+// Use Junction Deviation instead of traditional Jerk Limiting
+//
+//#define JUNCTION_DEVIATION
+#if ENABLED(JUNCTION_DEVIATION)
+ #define JUNCTION_DEVIATION_FACTOR 0.02
+ //#define JUNCTION_DEVIATION_INCLUDE_E
+#endif
+
// Microstep setting (Only functional when stepper driver microstep pins are connected to MCU.
#define MICROSTEP_MODES {16,16,16,16,16} // [1,2,4,8,16]
diff --git a/Marlin/src/config/examples/delta/kossel_pro/Configuration_adv.h b/Marlin/src/config/examples/delta/kossel_pro/Configuration_adv.h
index 030c5d856d2c345cf14db0fd8ddd234ea6db6267..5954e88c2bd991969dcf361372b848a1f2dbd621 100644
--- a/Marlin/src/config/examples/delta/kossel_pro/Configuration_adv.h
+++ b/Marlin/src/config/examples/delta/kossel_pro/Configuration_adv.h
@@ -438,6 +438,15 @@
// if unwanted behavior is observed on a user's machine when running at very slow speeds.
#define MINIMUM_PLANNER_SPEED 0.05 // (mm/sec)
+//
+// Use Junction Deviation instead of traditional Jerk Limiting
+//
+//#define JUNCTION_DEVIATION
+#if ENABLED(JUNCTION_DEVIATION)
+ #define JUNCTION_DEVIATION_FACTOR 0.02
+ //#define JUNCTION_DEVIATION_INCLUDE_E
+#endif
+
// Microstep setting (Only functional when stepper driver microstep pins are connected to MCU.
#define MICROSTEP_MODES {16,16,16,16,16} // [1,2,4,8,16]
diff --git a/Marlin/src/config/examples/delta/kossel_xl/Configuration_adv.h b/Marlin/src/config/examples/delta/kossel_xl/Configuration_adv.h
index 7468386d04365f1159398fbf5aa4d505e664b1b0..7c5b56ad5c4537466e8e62ffba695777c9c32d10 100644
--- a/Marlin/src/config/examples/delta/kossel_xl/Configuration_adv.h
+++ b/Marlin/src/config/examples/delta/kossel_xl/Configuration_adv.h
@@ -433,6 +433,15 @@
// if unwanted behavior is observed on a user's machine when running at very slow speeds.
#define MINIMUM_PLANNER_SPEED 0.05 // (mm/sec)
+//
+// Use Junction Deviation instead of traditional Jerk Limiting
+//
+//#define JUNCTION_DEVIATION
+#if ENABLED(JUNCTION_DEVIATION)
+ #define JUNCTION_DEVIATION_FACTOR 0.02
+ //#define JUNCTION_DEVIATION_INCLUDE_E
+#endif
+
// Microstep setting (Only functional when stepper driver microstep pins are connected to MCU.
#define MICROSTEP_MODES {16,16,16,16,16} // [1,2,4,8,16]
diff --git a/Marlin/src/config/examples/gCreate/gMax1.5+/Configuration_adv.h b/Marlin/src/config/examples/gCreate/gMax1.5+/Configuration_adv.h
index dd6ead860ba6a2fe827db1aca8c9561c6d370495..a8aa8bd8c6ccdc1e69a2e336e46c8e8d4cca941e 100644
--- a/Marlin/src/config/examples/gCreate/gMax1.5+/Configuration_adv.h
+++ b/Marlin/src/config/examples/gCreate/gMax1.5+/Configuration_adv.h
@@ -431,6 +431,15 @@
// if unwanted behavior is observed on a user's machine when running at very slow speeds.
#define MINIMUM_PLANNER_SPEED 0.05 // (mm/sec)
+//
+// Use Junction Deviation instead of traditional Jerk Limiting
+//
+//#define JUNCTION_DEVIATION
+#if ENABLED(JUNCTION_DEVIATION)
+ #define JUNCTION_DEVIATION_FACTOR 0.02
+ //#define JUNCTION_DEVIATION_INCLUDE_E
+#endif
+
// Microstep setting (Only functional when stepper driver microstep pins are connected to MCU.
#define MICROSTEP_MODES {16,16,16,16,16} // [1,2,4,8,16]
diff --git a/Marlin/src/config/examples/makibox/Configuration_adv.h b/Marlin/src/config/examples/makibox/Configuration_adv.h
index 528d330640aae1697818d6dd664bef521bf7c470..1d5be947eff71fa4363bac3d97f8200506fce1b6 100644
--- a/Marlin/src/config/examples/makibox/Configuration_adv.h
+++ b/Marlin/src/config/examples/makibox/Configuration_adv.h
@@ -431,6 +431,15 @@
// if unwanted behavior is observed on a user's machine when running at very slow speeds.
#define MINIMUM_PLANNER_SPEED 0.05 // (mm/sec)
+//
+// Use Junction Deviation instead of traditional Jerk Limiting
+//
+//#define JUNCTION_DEVIATION
+#if ENABLED(JUNCTION_DEVIATION)
+ #define JUNCTION_DEVIATION_FACTOR 0.02
+ //#define JUNCTION_DEVIATION_INCLUDE_E
+#endif
+
// Microstep setting (Only functional when stepper driver microstep pins are connected to MCU.
#define MICROSTEP_MODES {16,16,16,16,16} // [1,2,4,8,16]
diff --git a/Marlin/src/config/examples/tvrrug/Round2/Configuration_adv.h b/Marlin/src/config/examples/tvrrug/Round2/Configuration_adv.h
index b458fb702778240f7ab82a86b65d186dfdf8a0d1..9468a7f70085735de4331a5bee7a333878c9f25c 100644
--- a/Marlin/src/config/examples/tvrrug/Round2/Configuration_adv.h
+++ b/Marlin/src/config/examples/tvrrug/Round2/Configuration_adv.h
@@ -431,6 +431,15 @@
// if unwanted behavior is observed on a user's machine when running at very slow speeds.
#define MINIMUM_PLANNER_SPEED 0.05 // (mm/sec)
+//
+// Use Junction Deviation instead of traditional Jerk Limiting
+//
+//#define JUNCTION_DEVIATION
+#if ENABLED(JUNCTION_DEVIATION)
+ #define JUNCTION_DEVIATION_FACTOR 0.02
+ //#define JUNCTION_DEVIATION_INCLUDE_E
+#endif
+
// Microstep setting (Only functional when stepper driver microstep pins are connected to MCU.
#define MICROSTEP_MODES {16,16,16,16,16} // [1,2,4,8,16]
diff --git a/Marlin/src/config/examples/wt150/Configuration_adv.h b/Marlin/src/config/examples/wt150/Configuration_adv.h
index cdfd37d4650effe328b4098908f243a5610f674a..d738ed9d59a035a3a454d16b1ab3b3c488c235c0 100644
--- a/Marlin/src/config/examples/wt150/Configuration_adv.h
+++ b/Marlin/src/config/examples/wt150/Configuration_adv.h
@@ -431,6 +431,15 @@
// if unwanted behavior is observed on a user's machine when running at very slow speeds.
#define MINIMUM_PLANNER_SPEED 0.05 // (mm/sec)
+//
+// Use Junction Deviation instead of traditional Jerk Limiting
+//
+//#define JUNCTION_DEVIATION
+#if ENABLED(JUNCTION_DEVIATION)
+ #define JUNCTION_DEVIATION_FACTOR 0.02
+ //#define JUNCTION_DEVIATION_INCLUDE_E
+#endif
+
// Microstep setting (Only functional when stepper driver microstep pins are connected to MCU.
#define MICROSTEP_MODES {16,16,16,16,16} // [1,2,4,8,16]
diff --git a/Marlin/src/core/macros.h b/Marlin/src/core/macros.h
index 9bdd33e7e5009429dd513c27ab64eeea73e36fa3..34896c4f56544845dc4ad88aadc885a5995da9c1 100644
--- a/Marlin/src/core/macros.h
+++ b/Marlin/src/core/macros.h
@@ -110,6 +110,9 @@
#define STRINGIFY_(M) #M
#define STRINGIFY(M) STRINGIFY_(M)
+#define A(CODE) " " CODE "\n\t"
+#define L(CODE) CODE ":\n\t"
+
// Macros for bit masks
#undef _BV
#define _BV(b) (1 << (b))
diff --git a/Marlin/src/libs/softspi.h b/Marlin/src/libs/softspi.h
index b3afcc11d418bf02343b6c445dd5e369f7008f30..e3a28fdc736c700b7a9926a95df3588e419d466b 100644
--- a/Marlin/src/libs/softspi.h
+++ b/Marlin/src/libs/softspi.h
@@ -639,7 +639,7 @@ class DigitalPin {
//------------------------------------------------------------------------------
/** Nop for timing. */
-#define nop asm volatile ("nop\n\t")
+#define nop __asm__ volatile ("nop")
//------------------------------------------------------------------------------
/** Pin Mode for MISO is input.*/
const bool MISO_MODE = false;
diff --git a/Marlin/src/module/planner.cpp b/Marlin/src/module/planner.cpp
index 7a68cc628345e6be50ea2108fbed61c670e07901..109e7455269295e40494eedc2c2858ab2daa178d 100644
--- a/Marlin/src/module/planner.cpp
+++ b/Marlin/src/module/planner.cpp
@@ -409,7 +409,7 @@ void Planner::init() {
// %8:%7:%6 = interval
// r31:r30: MUST be those registers, and they must point to the inv_tab
- " clr %13" "\n\t" // %13 = 0
+ A("clr %13") // %13 = 0
// Now we must compute
// result = 0xFFFFFF / d
@@ -421,122 +421,122 @@ void Planner::init() {
// use Newton-Raphson for the calculation, and will strive to get way less cycles
// for the same result - Using C division, it takes 500cycles to complete .
- " clr %3" "\n\t" // idx = 0
- " mov %14,%6" "\n\t"
- " mov %15,%7" "\n\t"
- " mov %16,%8" "\n\t" // nr = interval
- " tst %16" "\n\t" // nr & 0xFF0000 == 0 ?
- " brne 2f" "\n\t" // No, skip this
- " mov %16,%15" "\n\t"
- " mov %15,%14" "\n\t" // nr <<= 8, %14 not needed
- " subi %3,-8" "\n\t" // idx += 8
- " tst %16" "\n\t" // nr & 0xFF0000 == 0 ?
- " brne 2f" "\n\t" // No, skip this
- " mov %16,%15" "\n\t" // nr <<= 8, %14 not needed
- " clr %15" "\n\t" // We clear %14
- " subi %3,-8" "\n\t" // idx += 8
+ A("clr %3") // idx = 0
+ A("mov %14,%6")
+ A("mov %15,%7")
+ A("mov %16,%8") // nr = interval
+ A("tst %16") // nr & 0xFF0000 == 0 ?
+ A("brne 2f") // No, skip this
+ A("mov %16,%15")
+ A("mov %15,%14") // nr <<= 8, %14 not needed
+ A("subi %3,-8") // idx += 8
+ A("tst %16") // nr & 0xFF0000 == 0 ?
+ A("brne 2f") // No, skip this
+ A("mov %16,%15") // nr <<= 8, %14 not needed
+ A("clr %15") // We clear %14
+ A("subi %3,-8") // idx += 8
// here %16 != 0 and %16:%15 contains at least 9 MSBits, or both %16:%15 are 0
- "2:" "\n\t"
- " cpi %16,0x10" "\n\t" // (nr & 0xf00000) == 0 ?
- " brcc 3f" "\n\t" // No, skip this
- " swap %15" "\n\t" // Swap nibbles
- " swap %16" "\n\t" // Swap nibbles. Low nibble is 0
- " mov %14, %15" "\n\t"
- " andi %14,0x0f" "\n\t" // Isolate low nibble
- " andi %15,0xf0" "\n\t" // Keep proper nibble in %15
- " or %16, %14" "\n\t" // %16:%15 <<= 4
- " subi %3,-4" "\n\t" // idx += 4
-
- "3:" "\n\t"
- " cpi %16,0x40" "\n\t" // (nr & 0xc00000) == 0 ?
- " brcc 4f" "\n\t" // No, skip this
- " add %15,%15" "\n\t"
- " adc %16,%16" "\n\t"
- " add %15,%15" "\n\t"
- " adc %16,%16" "\n\t" // %16:%15 <<= 2
- " subi %3,-2" "\n\t" // idx += 2
-
- "4:" "\n\t"
- " cpi %16,0x80" "\n\t" // (nr & 0x800000) == 0 ?
- " brcc 5f" "\n\t" // No, skip this
- " add %15,%15" "\n\t"
- " adc %16,%16" "\n\t" // %16:%15 <<= 1
- " inc %3" "\n\t" // idx += 1
+ L("2")
+ A("cpi %16,0x10") // (nr & 0xF00000) == 0 ?
+ A("brcc 3f") // No, skip this
+ A("swap %15") // Swap nibbles
+ A("swap %16") // Swap nibbles. Low nibble is 0
+ A("mov %14, %15")
+ A("andi %14,0x0F") // Isolate low nibble
+ A("andi %15,0xF0") // Keep proper nibble in %15
+ A("or %16, %14") // %16:%15 <<= 4
+ A("subi %3,-4") // idx += 4
+
+ L("3")
+ A("cpi %16,0x40") // (nr & 0xC00000) == 0 ?
+ A("brcc 4f") // No, skip this
+ A("add %15,%15")
+ A("adc %16,%16")
+ A("add %15,%15")
+ A("adc %16,%16") // %16:%15 <<= 2
+ A("subi %3,-2") // idx += 2
+
+ L("4")
+ A("cpi %16,0x80") // (nr & 0x800000) == 0 ?
+ A("brcc 5f") // No, skip this
+ A("add %15,%15")
+ A("adc %16,%16") // %16:%15 <<= 1
+ A("inc %3") // idx += 1
// Now %16:%15 contains its MSBit set to 1, or %16:%15 is == 0. We are now absolutely sure
// we have at least 9 MSBits available to enter the initial estimation table
- "5:" "\n\t"
- " add %15,%15" "\n\t"
- " adc %16,%16" "\n\t" // %16:%15 = tidx = (nr <<= 1), we lose the top MSBit (always set to 1, %16 is the index into the inverse table)
- " add r30,%16" "\n\t" // Only use top 8 bits
- " adc r31,%13" "\n\t" // r31:r30 = inv_tab + (tidx)
- " lpm %14, Z" "\n\t" // %14 = inv_tab[tidx]
- " ldi %15, 1" "\n\t" // %15 = 1 %15:%14 = inv_tab[tidx] + 256
+ L("5")
+ A("add %15,%15")
+ A("adc %16,%16") // %16:%15 = tidx = (nr <<= 1), we lose the top MSBit (always set to 1, %16 is the index into the inverse table)
+ A("add r30,%16") // Only use top 8 bits
+ A("adc r31,%13") // r31:r30 = inv_tab + (tidx)
+ A("lpm %14, Z") // %14 = inv_tab[tidx]
+ A("ldi %15, 1") // %15 = 1 %15:%14 = inv_tab[tidx] + 256
// We must scale the approximation to the proper place
- " clr %16" "\n\t" // %16 will always be 0 here
- " subi %3,8" "\n\t" // idx == 8 ?
- " breq 6f" "\n\t" // yes, no need to scale
- " brcs 7f" "\n\t" // If C=1, means idx < 8, result was negative!
+ A("clr %16") // %16 will always be 0 here
+ A("subi %3,8") // idx == 8 ?
+ A("breq 6f") // yes, no need to scale
+ A("brcs 7f") // If C=1, means idx < 8, result was negative!
// idx > 8, now %3 = idx - 8. We must perform a left shift. idx range:[1-8]
- " sbrs %3,0" "\n\t" // shift by 1bit position?
- " rjmp 8f" "\n\t" // No
- " add %14,%14" "\n\t"
- " adc %15,%15" "\n\t" // %15:16 <<= 1
- "8:" "\n\t"
- " sbrs %3,1" "\n\t" // shift by 2bit position?
- " rjmp 9f" "\n\t" // No
- " add %14,%14" "\n\t"
- " adc %15,%15" "\n\t"
- " add %14,%14" "\n\t"
- " adc %15,%15" "\n\t" // %15:16 <<= 1
- "9:" "\n\t"
- " sbrs %3,2" "\n\t" // shift by 4bits position?
- " rjmp 16f" "\n\t" // No
- " swap %15" "\n\t" // Swap nibbles. lo nibble of %15 will always be 0
- " swap %14" "\n\t" // Swap nibbles
- " mov %12,%14" "\n\t"
- " andi %12,0x0f" "\n\t" // isolate low nibble
- " andi %14,0xf0" "\n\t" // and clear it
- " or %15,%12" "\n\t" // %15:%16 <<= 4
- "16:" "\n\t"
- " sbrs %3,3" "\n\t" // shift by 8bits position?
- " rjmp 6f" "\n\t" // No, we are done
- " mov %16,%15" "\n\t"
- " mov %15,%14" "\n\t"
- " clr %14" "\n\t"
- " jmp 6f" "\n\t"
+ A("sbrs %3,0") // shift by 1bit position?
+ A("rjmp 8f") // No
+ A("add %14,%14")
+ A("adc %15,%15") // %15:16 <<= 1
+ L("8")
+ A("sbrs %3,1") // shift by 2bit position?
+ A("rjmp 9f") // No
+ A("add %14,%14")
+ A("adc %15,%15")
+ A("add %14,%14")
+ A("adc %15,%15") // %15:16 <<= 1
+ L("9")
+ A("sbrs %3,2") // shift by 4bits position?
+ A("rjmp 16f") // No
+ A("swap %15") // Swap nibbles. lo nibble of %15 will always be 0
+ A("swap %14") // Swap nibbles
+ A("mov %12,%14")
+ A("andi %12,0x0F") // isolate low nibble
+ A("andi %14,0xF0") // and clear it
+ A("or %15,%12") // %15:%16 <<= 4
+ L("16")
+ A("sbrs %3,3") // shift by 8bits position?
+ A("rjmp 6f") // No, we are done
+ A("mov %16,%15")
+ A("mov %15,%14")
+ A("clr %14")
+ A("jmp 6f")
// idx < 8, now %3 = idx - 8. Get the count of bits
- "7:" "\n\t"
- " neg %3" "\n\t" // %3 = -idx = count of bits to move right. idx range:[1...8]
- " sbrs %3,0" "\n\t" // shift by 1 bit position ?
- " rjmp 10f" "\n\t" // No, skip it
- " asr %15" "\n\t" // (bit7 is always 0 here)
- " ror %14" "\n\t"
- "10:" "\n\t"
- " sbrs %3,1" "\n\t" // shift by 2 bit position ?
- " rjmp 11f" "\n\t" // No, skip it
- " asr %15" "\n\t" // (bit7 is always 0 here)
- " ror %14" "\n\t"
- " asr %15" "\n\t" // (bit7 is always 0 here)
- " ror %14" "\n\t"
- "11:" "\n\t"
- " sbrs %3,2" "\n\t" // shift by 4 bit position ?
- " rjmp 12f" "\n\t" // No, skip it
- " swap %15" "\n\t" // Swap nibbles
- " andi %14, 0xf0" "\n\t" // Lose the lowest nibble
- " swap %14" "\n\t" // Swap nibbles. Upper nibble is 0
- " or %14,%15" "\n\t" // Pass nibble from upper byte
- " andi %15, 0x0f" "\n\t" // And get rid of that nibble
- "12:" "\n\t"
- " sbrs %3,3" "\n\t" // shift by 8 bit position ?
- " rjmp 6f" "\n\t" // No, skip it
- " mov %14,%15" "\n\t"
- " clr %15" "\n\t"
- "6:" "\n\t" // %16:%15:%14 = initial estimation of 0x1000000 / d
+ L("7")
+ A("neg %3") // %3 = -idx = count of bits to move right. idx range:[1...8]
+ A("sbrs %3,0") // shift by 1 bit position ?
+ A("rjmp 10f") // No, skip it
+ A("asr %15") // (bit7 is always 0 here)
+ A("ror %14")
+ L("10")
+ A("sbrs %3,1") // shift by 2 bit position ?
+ A("rjmp 11f") // No, skip it
+ A("asr %15") // (bit7 is always 0 here)
+ A("ror %14")
+ A("asr %15") // (bit7 is always 0 here)
+ A("ror %14")
+ L("11")
+ A("sbrs %3,2") // shift by 4 bit position ?
+ A("rjmp 12f") // No, skip it
+ A("swap %15") // Swap nibbles
+ A("andi %14, 0xF0") // Lose the lowest nibble
+ A("swap %14") // Swap nibbles. Upper nibble is 0
+ A("or %14,%15") // Pass nibble from upper byte
+ A("andi %15, 0x0F") // And get rid of that nibble
+ L("12")
+ A("sbrs %3,3") // shift by 8 bit position ?
+ A("rjmp 6f") // No, skip it
+ A("mov %14,%15")
+ A("clr %15")
+ L("6") // %16:%15:%14 = initial estimation of 0x1000000 / d
// Now, we must refine the estimation present on %16:%15:%14 using 1 iteration
// of Newton-Raphson. As it has a quadratic convergence, 1 iteration is enough
@@ -549,36 +549,36 @@ void Planner::init() {
// %3:%2:%1:%0 = working accumulator
// Compute 1<<25 - x*d. Result should never exceed 25 bits and should always be positive
- " clr %0" "\n\t"
- " clr %1" "\n\t"
- " clr %2" "\n\t"
- " ldi %3,2" "\n\t" // %3:%2:%1:%0 = 0x2000000
- " mul %6,%14" "\n\t" // r1:r0 = LO(d) * LO(x)
- " sub %0,r0" "\n\t"
- " sbc %1,r1" "\n\t"
- " sbc %2,%13" "\n\t"
- " sbc %3,%13" "\n\t" // %3:%2:%1:%0 -= LO(d) * LO(x)
- " mul %7,%14" "\n\t" // r1:r0 = MI(d) * LO(x)
- " sub %1,r0" "\n\t"
- " sbc %2,r1" "\n\t"
- " sbc %3,%13" "\n\t" // %3:%2:%1:%0 -= MI(d) * LO(x) << 8
- " mul %8,%14" "\n\t" // r1:r0 = HI(d) * LO(x)
- " sub %2,r0" "\n\t"
- " sbc %3,r1" "\n\t" // %3:%2:%1:%0 -= MIL(d) * LO(x) << 16
- " mul %6,%15" "\n\t" // r1:r0 = LO(d) * MI(x)
- " sub %1,r0" "\n\t"
- " sbc %2,r1" "\n\t"
- " sbc %3,%13" "\n\t" // %3:%2:%1:%0 -= LO(d) * MI(x) << 8
- " mul %7,%15" "\n\t" // r1:r0 = MI(d) * MI(x)
- " sub %2,r0" "\n\t"
- " sbc %3,r1" "\n\t" // %3:%2:%1:%0 -= MI(d) * MI(x) << 16
- " mul %8,%15" "\n\t" // r1:r0 = HI(d) * MI(x)
- " sub %3,r0" "\n\t" // %3:%2:%1:%0 -= MIL(d) * MI(x) << 24
- " mul %6,%16" "\n\t" // r1:r0 = LO(d) * HI(x)
- " sub %2,r0" "\n\t"
- " sbc %3,r1" "\n\t" // %3:%2:%1:%0 -= LO(d) * HI(x) << 16
- " mul %7,%16" "\n\t" // r1:r0 = MI(d) * HI(x)
- " sub %3,r0" "\n\t" // %3:%2:%1:%0 -= MI(d) * HI(x) << 24
+ A("clr %0")
+ A("clr %1")
+ A("clr %2")
+ A("ldi %3,2") // %3:%2:%1:%0 = 0x2000000
+ A("mul %6,%14") // r1:r0 = LO(d) * LO(x)
+ A("sub %0,r0")
+ A("sbc %1,r1")
+ A("sbc %2,%13")
+ A("sbc %3,%13") // %3:%2:%1:%0 -= LO(d) * LO(x)
+ A("mul %7,%14") // r1:r0 = MI(d) * LO(x)
+ A("sub %1,r0")
+ A("sbc %2,r1" )
+ A("sbc %3,%13") // %3:%2:%1:%0 -= MI(d) * LO(x) << 8
+ A("mul %8,%14") // r1:r0 = HI(d) * LO(x)
+ A("sub %2,r0")
+ A("sbc %3,r1") // %3:%2:%1:%0 -= MIL(d) * LO(x) << 16
+ A("mul %6,%15") // r1:r0 = LO(d) * MI(x)
+ A("sub %1,r0")
+ A("sbc %2,r1")
+ A("sbc %3,%13") // %3:%2:%1:%0 -= LO(d) * MI(x) << 8
+ A("mul %7,%15") // r1:r0 = MI(d) * MI(x)
+ A("sub %2,r0")
+ A("sbc %3,r1") // %3:%2:%1:%0 -= MI(d) * MI(x) << 16
+ A("mul %8,%15") // r1:r0 = HI(d) * MI(x)
+ A("sub %3,r0") // %3:%2:%1:%0 -= MIL(d) * MI(x) << 24
+ A("mul %6,%16") // r1:r0 = LO(d) * HI(x)
+ A("sub %2,r0")
+ A("sbc %3,r1") // %3:%2:%1:%0 -= LO(d) * HI(x) << 16
+ A("mul %7,%16") // r1:r0 = MI(d) * HI(x)
+ A("sub %3,r0") // %3:%2:%1:%0 -= MI(d) * HI(x) << 24
// %3:%2:%1:%0 = (1<<25) - x*d [169]
// We need to multiply that result by x, and we are only interested in the top 24bits of that multiply
@@ -588,62 +588,62 @@ void Planner::init() {
// %13 = 0
// result = %11:%10:%9:%5:%4
- " mul %14,%0" "\n\t" // r1:r0 = LO(x) * LO(acc)
- " mov %4,r1" "\n\t"
- " clr %5" "\n\t"
- " clr %9" "\n\t"
- " clr %10" "\n\t"
- " clr %11" "\n\t" // %11:%10:%9:%5:%4 = LO(x) * LO(acc) >> 8
- " mul %15,%0" "\n\t" // r1:r0 = MI(x) * LO(acc)
- " add %4,r0" "\n\t"
- " adc %5,r1" "\n\t"
- " adc %9,%13" "\n\t"
- " adc %10,%13" "\n\t"
- " adc %11,%13" "\n\t" // %11:%10:%9:%5:%4 += MI(x) * LO(acc)
- " mul %16,%0" "\n\t" // r1:r0 = HI(x) * LO(acc)
- " add %5,r0" "\n\t"
- " adc %9,r1" "\n\t"
- " adc %10,%13" "\n\t"
- " adc %11,%13" "\n\t" // %11:%10:%9:%5:%4 += MI(x) * LO(acc) << 8
-
- " mul %14,%1" "\n\t" // r1:r0 = LO(x) * MIL(acc)
- " add %4,r0" "\n\t"
- " adc %5,r1" "\n\t"
- " adc %9,%13" "\n\t"
- " adc %10,%13" "\n\t"
- " adc %11,%13" "\n\t" // %11:%10:%9:%5:%4 = LO(x) * MIL(acc)
- " mul %15,%1" "\n\t" // r1:r0 = MI(x) * MIL(acc)
- " add %5,r0" "\n\t"
- " adc %9,r1" "\n\t"
- " adc %10,%13" "\n\t"
- " adc %11,%13" "\n\t" // %11:%10:%9:%5:%4 += MI(x) * MIL(acc) << 8
- " mul %16,%1" "\n\t" // r1:r0 = HI(x) * MIL(acc)
- " add %9,r0" "\n\t"
- " adc %10,r1" "\n\t"
- " adc %11,%13" "\n\t" // %11:%10:%9:%5:%4 += MI(x) * MIL(acc) << 16
-
- " mul %14,%2" "\n\t" // r1:r0 = LO(x) * MIH(acc)
- " add %5,r0" "\n\t"
- " adc %9,r1" "\n\t"
- " adc %10,%13" "\n\t"
- " adc %11,%13" "\n\t" // %11:%10:%9:%5:%4 = LO(x) * MIH(acc) << 8
- " mul %15,%2" "\n\t" // r1:r0 = MI(x) * MIH(acc)
- " add %9,r0" "\n\t"
- " adc %10,r1" "\n\t"
- " adc %11,%13" "\n\t" // %11:%10:%9:%5:%4 += MI(x) * MIH(acc) << 16
- " mul %16,%2" "\n\t" // r1:r0 = HI(x) * MIH(acc)
- " add %10,r0" "\n\t"
- " adc %11,r1" "\n\t" // %11:%10:%9:%5:%4 += MI(x) * MIH(acc) << 24
-
- " mul %14,%3" "\n\t" // r1:r0 = LO(x) * HI(acc)
- " add %9,r0" "\n\t"
- " adc %10,r1" "\n\t"
- " adc %11,%13" "\n\t" // %11:%10:%9:%5:%4 = LO(x) * HI(acc) << 16
- " mul %15,%3" "\n\t" // r1:r0 = MI(x) * HI(acc)
- " add %10,r0" "\n\t"
- " adc %11,r1" "\n\t" // %11:%10:%9:%5:%4 += MI(x) * HI(acc) << 24
- " mul %16,%3" "\n\t" // r1:r0 = HI(x) * HI(acc)
- " add %11,r0" "\n\t" // %11:%10:%9:%5:%4 += MI(x) * HI(acc) << 32
+ A("mul %14,%0") // r1:r0 = LO(x) * LO(acc)
+ A("mov %4,r1")
+ A("clr %5")
+ A("clr %9")
+ A("clr %10")
+ A("clr %11") // %11:%10:%9:%5:%4 = LO(x) * LO(acc) >> 8
+ A("mul %15,%0") // r1:r0 = MI(x) * LO(acc)
+ A("add %4,r0")
+ A("adc %5,r1")
+ A("adc %9,%13")
+ A("adc %10,%13")
+ A("adc %11,%13") // %11:%10:%9:%5:%4 += MI(x) * LO(acc)
+ A("mul %16,%0") // r1:r0 = HI(x) * LO(acc)
+ A("add %5,r0")
+ A("adc %9,r1")
+ A("adc %10,%13")
+ A("adc %11,%13") // %11:%10:%9:%5:%4 += MI(x) * LO(acc) << 8
+
+ A("mul %14,%1") // r1:r0 = LO(x) * MIL(acc)
+ A("add %4,r0")
+ A("adc %5,r1")
+ A("adc %9,%13")
+ A("adc %10,%13")
+ A("adc %11,%13") // %11:%10:%9:%5:%4 = LO(x) * MIL(acc)
+ A("mul %15,%1") // r1:r0 = MI(x) * MIL(acc)
+ A("add %5,r0")
+ A("adc %9,r1")
+ A("adc %10,%13")
+ A("adc %11,%13") // %11:%10:%9:%5:%4 += MI(x) * MIL(acc) << 8
+ A("mul %16,%1") // r1:r0 = HI(x) * MIL(acc)
+ A("add %9,r0")
+ A("adc %10,r1")
+ A("adc %11,%13") // %11:%10:%9:%5:%4 += MI(x) * MIL(acc) << 16
+
+ A("mul %14,%2") // r1:r0 = LO(x) * MIH(acc)
+ A("add %5,r0")
+ A("adc %9,r1")
+ A("adc %10,%13")
+ A("adc %11,%13") // %11:%10:%9:%5:%4 = LO(x) * MIH(acc) << 8
+ A("mul %15,%2") // r1:r0 = MI(x) * MIH(acc)
+ A("add %9,r0")
+ A("adc %10,r1")
+ A("adc %11,%13") // %11:%10:%9:%5:%4 += MI(x) * MIH(acc) << 16
+ A("mul %16,%2") // r1:r0 = HI(x) * MIH(acc)
+ A("add %10,r0")
+ A("adc %11,r1") // %11:%10:%9:%5:%4 += MI(x) * MIH(acc) << 24
+
+ A("mul %14,%3") // r1:r0 = LO(x) * HI(acc)
+ A("add %9,r0")
+ A("adc %10,r1")
+ A("adc %11,%13") // %11:%10:%9:%5:%4 = LO(x) * HI(acc) << 16
+ A("mul %15,%3") // r1:r0 = MI(x) * HI(acc)
+ A("add %10,r0")
+ A("adc %11,r1") // %11:%10:%9:%5:%4 += MI(x) * HI(acc) << 24
+ A("mul %16,%3") // r1:r0 = HI(x) * HI(acc)
+ A("add %11,r0") // %11:%10:%9:%5:%4 += MI(x) * HI(acc) << 32
// At this point, %11:%10:%9 contains the new estimation of x.
@@ -651,54 +651,54 @@ void Planner::init() {
// (1<<24) - x*d
// %11:%10:%9 = x
// %8:%7:%6 = d = interval" "\n\t"
- " ldi %3,1" "\n\t"
- " clr %2" "\n\t"
- " clr %1" "\n\t"
- " clr %0" "\n\t" // %3:%2:%1:%0 = 0x1000000
- " mul %6,%9" "\n\t" // r1:r0 = LO(d) * LO(x)
- " sub %0,r0" "\n\t"
- " sbc %1,r1" "\n\t"
- " sbc %2,%13" "\n\t"
- " sbc %3,%13" "\n\t" // %3:%2:%1:%0 -= LO(d) * LO(x)
- " mul %7,%9" "\n\t" // r1:r0 = MI(d) * LO(x)
- " sub %1,r0" "\n\t"
- " sbc %2,r1" "\n\t"
- " sbc %3,%13" "\n\t" // %3:%2:%1:%0 -= MI(d) * LO(x) << 8
- " mul %8,%9" "\n\t" // r1:r0 = HI(d) * LO(x)
- " sub %2,r0" "\n\t"
- " sbc %3,r1" "\n\t" // %3:%2:%1:%0 -= MIL(d) * LO(x) << 16
- " mul %6,%10" "\n\t" // r1:r0 = LO(d) * MI(x)
- " sub %1,r0" "\n\t"
- " sbc %2,r1" "\n\t"
- " sbc %3,%13" "\n\t" // %3:%2:%1:%0 -= LO(d) * MI(x) << 8
- " mul %7,%10" "\n\t" // r1:r0 = MI(d) * MI(x)
- " sub %2,r0" "\n\t"
- " sbc %3,r1" "\n\t" // %3:%2:%1:%0 -= MI(d) * MI(x) << 16
- " mul %8,%10" "\n\t" // r1:r0 = HI(d) * MI(x)
- " sub %3,r0" "\n\t" // %3:%2:%1:%0 -= MIL(d) * MI(x) << 24
- " mul %6,%11" "\n\t" // r1:r0 = LO(d) * HI(x)
- " sub %2,r0" "\n\t"
- " sbc %3,r1" "\n\t" // %3:%2:%1:%0 -= LO(d) * HI(x) << 16
- " mul %7,%11" "\n\t" // r1:r0 = MI(d) * HI(x)
- " sub %3,r0" "\n\t" // %3:%2:%1:%0 -= MI(d) * HI(x) << 24
+ A("ldi %3,1")
+ A("clr %2")
+ A("clr %1")
+ A("clr %0") // %3:%2:%1:%0 = 0x1000000
+ A("mul %6,%9") // r1:r0 = LO(d) * LO(x)
+ A("sub %0,r0")
+ A("sbc %1,r1")
+ A("sbc %2,%13")
+ A("sbc %3,%13") // %3:%2:%1:%0 -= LO(d) * LO(x)
+ A("mul %7,%9") // r1:r0 = MI(d) * LO(x)
+ A("sub %1,r0")
+ A("sbc %2,r1")
+ A("sbc %3,%13") // %3:%2:%1:%0 -= MI(d) * LO(x) << 8
+ A("mul %8,%9") // r1:r0 = HI(d) * LO(x)
+ A("sub %2,r0")
+ A("sbc %3,r1") // %3:%2:%1:%0 -= MIL(d) * LO(x) << 16
+ A("mul %6,%10") // r1:r0 = LO(d) * MI(x)
+ A("sub %1,r0")
+ A("sbc %2,r1")
+ A("sbc %3,%13") // %3:%2:%1:%0 -= LO(d) * MI(x) << 8
+ A("mul %7,%10") // r1:r0 = MI(d) * MI(x)
+ A("sub %2,r0")
+ A("sbc %3,r1") // %3:%2:%1:%0 -= MI(d) * MI(x) << 16
+ A("mul %8,%10") // r1:r0 = HI(d) * MI(x)
+ A("sub %3,r0") // %3:%2:%1:%0 -= MIL(d) * MI(x) << 24
+ A("mul %6,%11") // r1:r0 = LO(d) * HI(x)
+ A("sub %2,r0")
+ A("sbc %3,r1") // %3:%2:%1:%0 -= LO(d) * HI(x) << 16
+ A("mul %7,%11") // r1:r0 = MI(d) * HI(x)
+ A("sub %3,r0") // %3:%2:%1:%0 -= MI(d) * HI(x) << 24
// %3:%2:%1:%0 = r = (1<<24) - x*d
// %8:%7:%6 = d = interval
// Perform the final correction
- " sub %0,%6" "\n\t"
- " sbc %1,%7" "\n\t"
- " sbc %2,%8" "\n\t" // r -= d
- " brcs 14f" "\n\t" // if ( r >= d)
+ A("sub %0,%6")
+ A("sbc %1,%7")
+ A("sbc %2,%8") // r -= d
+ A("brcs 14f") // if ( r >= d)
// %11:%10:%9 = x
- " ldi %3,1" "\n\t"
- " add %9,%3" "\n\t"
- " adc %10,%13" "\n\t"
- " adc %11,%13" "\n\t" // x++
- "14:" "\n\t"
+ A("ldi %3,1")
+ A("add %9,%3")
+ A("adc %10,%13")
+ A("adc %11,%13") // x++
+ L("14")
// Estimation is done. %11:%10:%9 = x
- " clr __zero_reg__" "\n\t" // Make C runtime happy
+ A("clr __zero_reg__") // Make C runtime happy
// [211 cycles total]
: "=r" (r2),
"=r" (r3),
@@ -787,8 +787,8 @@ void Planner::calculate_trapezoid_for_block(block_t* const block, const float &e
#if ENABLED(BEZIER_JERK_CONTROL)
// Jerk controlled speed requires to express speed versus time, NOT steps
- uint32_t acceleration_time = ((float)(cruise_rate - initial_rate) / accel) * HAL_STEPPER_TIMER_RATE,
- deceleration_time = ((float)(cruise_rate - final_rate) / accel) * HAL_STEPPER_TIMER_RATE;
+ uint32_t acceleration_time = ((float)(cruise_rate - initial_rate) / accel) * (HAL_STEPPER_TIMER_RATE),
+ deceleration_time = ((float)(cruise_rate - final_rate) / accel) * (HAL_STEPPER_TIMER_RATE);
// And to offload calculations from the ISR, we also calculate the inverse of those times here
uint32_t acceleration_time_inverse = get_period_inverse(acceleration_time);
@@ -1864,129 +1864,161 @@ void Planner::_buffer_steps(const int32_t (&target)[XYZE]
}
#endif
- // Initial limit on the segment entry velocity
- float vmax_junction;
-
- #if 0 // Use old jerk for now
+ float vmax_junction; // Initial limit on the segment entry velocity
+
+ #if ENABLED(JUNCTION_DEVIATION)
+
+ /**
+ * Compute maximum allowable entry speed at junction by centripetal acceleration approximation.
+ * Let a circle be tangent to both previous and current path line segments, where the junction
+ * deviation is defined as the distance from the junction to the closest edge of the circle,
+ * colinear with the circle center. The circular segment joining the two paths represents the
+ * path of centripetal acceleration. Solve for max velocity based on max acceleration about the
+ * radius of the circle, defined indirectly by junction deviation. This may be also viewed as
+ * path width or max_jerk in the previous Grbl version. This approach does not actually deviate
+ * from path, but used as a robust way to compute cornering speeds, as it takes into account the
+ * nonlinearities of both the junction angle and junction velocity.
+ *
+ * NOTE: If the junction deviation value is finite, Grbl executes the motions in an exact path
+ * mode (G61). If the junction deviation value is zero, Grbl will execute the motion in an exact
+ * stop mode (G61.1) manner. In the future, if continuous mode (G64) is desired, the math here
+ * is exactly the same. Instead of motioning all the way to junction point, the machine will
+ * just follow the arc circle defined here. The Arduino doesn't have the CPU cycles to perform
+ * a continuous mode path, but ARM-based microcontrollers most certainly do.
+ *
+ * NOTE: The max junction speed is a fixed value, since machine acceleration limits cannot be
+ * changed dynamically during operation nor can the line move geometry. This must be kept in
+ * memory in the event of a feedrate override changing the nominal speeds of blocks, which can
+ * change the overall maximum entry speed conditions of all blocks.
+ */
- float junction_deviation = 0.1;
+ // Unit vector of previous path line segment
+ static float previous_unit_vec[
+ #if ENABLED(JUNCTION_DEVIATION_INCLUDE_E)
+ XYZE
+ #else
+ XYZ
+ #endif
+ ];
- // Compute path unit vector
- double unit_vec[XYZ] = {
+ float unit_vec[] = {
delta_mm[A_AXIS] * inverse_millimeters,
delta_mm[B_AXIS] * inverse_millimeters,
delta_mm[C_AXIS] * inverse_millimeters
+ #if ENABLED(JUNCTION_DEVIATION_INCLUDE_E)
+ , delta_mm[E_AXIS] * inverse_millimeters
+ #endif
};
- /*
- Compute maximum allowable entry speed at junction by centripetal acceleration approximation.
-
- Let a circle be tangent to both previous and current path line segments, where the junction
- deviation is defined as the distance from the junction to the closest edge of the circle,
- collinear with the circle center.
-
- The circular segment joining the two paths represents the path of centripetal acceleration.
- Solve for max velocity based on max acceleration about the radius of the circle, defined
- indirectly by junction deviation.
-
- This may be also viewed as path width or max_jerk in the previous grbl version. This approach
- does not actually deviate from path, but used as a robust way to compute cornering speeds, as
- it takes into account the nonlinearities of both the junction angle and junction velocity.
- */
-
- vmax_junction = MINIMUM_PLANNER_SPEED; // Set default max junction speed
-
// Skip first block or when previous_nominal_speed is used as a flag for homing and offset cycles.
if (moves_queued && !UNEAR_ZERO(previous_nominal_speed)) {
// Compute cosine of angle between previous and current path. (prev_unit_vec is negative)
// NOTE: Max junction velocity is computed without sin() or acos() by trig half angle identity.
- const float cos_theta = - previous_unit_vec[X_AXIS] * unit_vec[X_AXIS]
- - previous_unit_vec[Y_AXIS] * unit_vec[Y_AXIS]
- - previous_unit_vec[Z_AXIS] * unit_vec[Z_AXIS];
- // Skip and use default max junction speed for 0 degree acute junction.
- if (cos_theta < 0.95) {
- vmax_junction = min(previous_nominal_speed, block->nominal_speed);
- // Skip and avoid divide by zero for straight junctions at 180 degrees. Limit to min() of nominal speeds.
- if (cos_theta > -0.95) {
- // Compute maximum junction velocity based on maximum acceleration and junction deviation
- float sin_theta_d2 = SQRT(0.5 * (1.0 - cos_theta)); // Trig half angle identity. Always positive.
- NOMORE(vmax_junction, SQRT(block->acceleration * junction_deviation * sin_theta_d2 / (1.0 - sin_theta_d2)));
- }
+ float junction_cos_theta = -previous_unit_vec[X_AXIS] * unit_vec[X_AXIS]
+ -previous_unit_vec[Y_AXIS] * unit_vec[Y_AXIS]
+ -previous_unit_vec[Z_AXIS] * unit_vec[Z_AXIS]
+ #if ENABLED(JUNCTION_DEVIATION_INCLUDE_E)
+ -previous_unit_vec[E_AXIS] * unit_vec[E_AXIS]
+ #endif
+ ;
+
+ // NOTE: Computed without any expensive trig, sin() or acos(), by trig half angle identity of cos(theta).
+ if (junction_cos_theta > 0.999999) {
+ // For a 0 degree acute junction, just set minimum junction speed.
+ vmax_junction = MINIMUM_PLANNER_SPEED;
+ }
+ else {
+ junction_cos_theta = max(junction_cos_theta, -0.999999); // Check for numerical round-off to avoid divide by zero.
+ const float sin_theta_d2 = SQRT(0.5 * (1.0 - junction_cos_theta)); // Trig half angle identity. Always positive.
+
+ // TODO: Technically, the acceleration used in calculation needs to be limited by the minimum of the
+ // two junctions. However, this shouldn't be a significant problem except in extreme circumstances.
+ vmax_junction = SQRT((block->acceleration * JUNCTION_DEVIATION_FACTOR * sin_theta_d2) / (1.0 - sin_theta_d2));
}
+
+ vmax_junction = MIN3(vmax_junction, block->nominal_speed, previous_nominal_speed);
}
- #endif
+ else // Init entry speed to zero. Assume it starts from rest. Planner will correct this later.
+ vmax_junction = 0.0;
- /**
- * Adapted from Průša MKS firmware
- * https://github.com/prusa3d/Prusa-Firmware
- *
- * Start with a safe speed (from which the machine may halt to stop immediately).
- */
+ COPY(previous_unit_vec, unit_vec);
- // Exit speed limited by a jerk to full halt of a previous last segment
- static float previous_safe_speed;
+ #else // Classic Jerk Limiting
- float safe_speed = block->nominal_speed;
- uint8_t limited = 0;
- LOOP_XYZE(i) {
- const float jerk = FABS(current_speed[i]), maxj = max_jerk[i];
- if (jerk > maxj) {
- if (limited) {
- const float mjerk = maxj * block->nominal_speed;
- if (jerk * safe_speed > mjerk) safe_speed = mjerk / jerk;
- }
- else {
- ++limited;
- safe_speed = maxj;
+ /**
+ * Adapted from Průša MKS firmware
+ * https://github.com/prusa3d/Prusa-Firmware
+ *
+ * Start with a safe speed (from which the machine may halt to stop immediately).
+ */
+
+ // Exit speed limited by a jerk to full halt of a previous last segment
+ static float previous_safe_speed;
+
+ float safe_speed = block->nominal_speed;
+ uint8_t limited = 0;
+ LOOP_XYZE(i) {
+ const float jerk = FABS(current_speed[i]), maxj = max_jerk[i];
+ if (jerk > maxj) {
+ if (limited) {
+ const float mjerk = maxj * block->nominal_speed;
+ if (jerk * safe_speed > mjerk) safe_speed = mjerk / jerk;
+ }
+ else {
+ ++limited;
+ safe_speed = maxj;
+ }
}
}
- }
- if (moves_queued && !UNEAR_ZERO(previous_nominal_speed)) {
- // Estimate a maximum velocity allowed at a joint of two successive segments.
- // If this maximum velocity allowed is lower than the minimum of the entry / exit safe velocities,
- // then the machine is not coasting anymore and the safe entry / exit velocities shall be used.
-
- // The junction velocity will be shared between successive segments. Limit the junction velocity to their minimum.
- // Pick the smaller of the nominal speeds. Higher speed shall not be achieved at the junction during coasting.
- vmax_junction = min(block->nominal_speed, previous_nominal_speed);
-
- // Factor to multiply the previous / current nominal velocities to get componentwise limited velocities.
- float v_factor = 1;
- limited = 0;
-
- // Now limit the jerk in all axes.
- const float smaller_speed_factor = vmax_junction / previous_nominal_speed;
- LOOP_XYZE(axis) {
- // Limit an axis. We have to differentiate: coasting, reversal of an axis, full stop.
- float v_exit = previous_speed[axis] * smaller_speed_factor,
- v_entry = current_speed[axis];
- if (limited) {
- v_exit *= v_factor;
- v_entry *= v_factor;
- }
+ if (moves_queued && !UNEAR_ZERO(previous_nominal_speed)) {
+ // Estimate a maximum velocity allowed at a joint of two successive segments.
+ // If this maximum velocity allowed is lower than the minimum of the entry / exit safe velocities,
+ // then the machine is not coasting anymore and the safe entry / exit velocities shall be used.
+
+ // The junction velocity will be shared between successive segments. Limit the junction velocity to their minimum.
+ // Pick the smaller of the nominal speeds. Higher speed shall not be achieved at the junction during coasting.
+ vmax_junction = min(block->nominal_speed, previous_nominal_speed);
+
+ // Factor to multiply the previous / current nominal velocities to get componentwise limited velocities.
+ float v_factor = 1;
+ limited = 0;
+
+ // Now limit the jerk in all axes.
+ const float smaller_speed_factor = vmax_junction / previous_nominal_speed;
+ LOOP_XYZE(axis) {
+ // Limit an axis. We have to differentiate: coasting, reversal of an axis, full stop.
+ float v_exit = previous_speed[axis] * smaller_speed_factor,
+ v_entry = current_speed[axis];
+ if (limited) {
+ v_exit *= v_factor;
+ v_entry *= v_factor;
+ }
- // Calculate jerk depending on whether the axis is coasting in the same direction or reversing.
- const float jerk = (v_exit > v_entry)
- ? // coasting axis reversal
- ( (v_entry > 0 || v_exit < 0) ? (v_exit - v_entry) : max(v_exit, -v_entry) )
- : // v_exit <= v_entry coasting axis reversal
- ( (v_entry < 0 || v_exit > 0) ? (v_entry - v_exit) : max(-v_exit, v_entry) );
+ // Calculate jerk depending on whether the axis is coasting in the same direction or reversing.
+ const float jerk = (v_exit > v_entry)
+ ? // coasting axis reversal
+ ( (v_entry > 0 || v_exit < 0) ? (v_exit - v_entry) : max(v_exit, -v_entry) )
+ : // v_exit <= v_entry coasting axis reversal
+ ( (v_entry < 0 || v_exit > 0) ? (v_entry - v_exit) : max(-v_exit, v_entry) );
- if (jerk > max_jerk[axis]) {
- v_factor *= max_jerk[axis] / jerk;
- ++limited;
+ if (jerk > max_jerk[axis]) {
+ v_factor *= max_jerk[axis] / jerk;
+ ++limited;
+ }
}
+ if (limited) vmax_junction *= v_factor;
+ // Now the transition velocity is known, which maximizes the shared exit / entry velocity while
+ // respecting the jerk factors, it may be possible, that applying separate safe exit / entry velocities will achieve faster prints.
+ const float vmax_junction_threshold = vmax_junction * 0.99f;
+ if (previous_safe_speed > vmax_junction_threshold && safe_speed > vmax_junction_threshold)
+ vmax_junction = safe_speed;
}
- if (limited) vmax_junction *= v_factor;
- // Now the transition velocity is known, which maximizes the shared exit / entry velocity while
- // respecting the jerk factors, it may be possible, that applying separate safe exit / entry velocities will achieve faster prints.
- const float vmax_junction_threshold = vmax_junction * 0.99f;
- if (previous_safe_speed > vmax_junction_threshold && safe_speed > vmax_junction_threshold)
+ else
vmax_junction = safe_speed;
- }
- else
- vmax_junction = safe_speed;
+
+ previous_safe_speed = safe_speed;
+ #endif // Classic Jerk Limiting
// Max entry speed of this block equals the max exit speed of the previous block.
block->max_entry_speed = vmax_junction;
@@ -2010,7 +2042,6 @@ void Planner::_buffer_steps(const int32_t (&target)[XYZE]
// Update previous path unit_vector and nominal speed
COPY(previous_speed, current_speed);
previous_nominal_speed = block->nominal_speed;
- previous_safe_speed = safe_speed;
// Move buffer head
block_buffer_head = next_buffer_head;
diff --git a/Marlin/src/module/stepper.cpp b/Marlin/src/module/stepper.cpp
index 4e6747a1242df1824716202e27ad38dc722500b8..5214bade44e6ad85dba8779864d4bb6f8d2b200c 100644
--- a/Marlin/src/module/stepper.cpp
+++ b/Marlin/src/module/stepper.cpp
@@ -581,68 +581,68 @@ void Stepper::set_directions() {
/* %10 (must be high register!)*/
/* Store initial velocity*/
- " sts bezier_F, %0" "\n\t"
- " sts bezier_F+1, %1" "\n\t"
- " sts bezier_F+2, %10" "\n\t" /* bezier_F = %10:%1:%0 = v0 */
+ A("sts bezier_F, %0")
+ A("sts bezier_F+1, %1")
+ A("sts bezier_F+2, %10") /* bezier_F = %10:%1:%0 = v0 */
/* Get delta speed */
- " ldi %2,-1" "\n\t" /* %2 = 0xff, means A_negative = true */
- " clr %8" "\n\t" /* %8 = 0 */
- " sub %0,%3" "\n\t"
- " sbc %1,%4" "\n\t"
- " sbc %10,%5" "\n\t" /* v0 -= v1, C=1 if result is negative */
- " brcc 1f" "\n\t" /* branch if result is positive (C=0), that means v0 >= v1 */
+ A("ldi %2,-1") /* %2 = 0xFF, means A_negative = true */
+ A("clr %8") /* %8 = 0 */
+ A("sub %0,%3")
+ A("sbc %1,%4")
+ A("sbc %10,%5") /* v0 -= v1, C=1 if result is negative */
+ A("brcc 1f") /* branch if result is positive (C=0), that means v0 >= v1 */
/* Result was negative, get the absolute value*/
- " com %10" "\n\t"
- " com %1" "\n\t"
- " neg %0" "\n\t"
- " sbc %1,%2" "\n\t"
- " sbc %10,%2" "\n\t" /* %10:%1:%0 +1 -> %10:%1:%0 = -(v0 - v1) = (v1 - v0) */
- " clr %2" "\n\t" /* %2 = 0, means A_negative = false */
+ A("com %10")
+ A("com %1")
+ A("neg %0")
+ A("sbc %1,%2")
+ A("sbc %10,%2") /* %10:%1:%0 +1 -> %10:%1:%0 = -(v0 - v1) = (v1 - v0) */
+ A("clr %2") /* %2 = 0, means A_negative = false */
/* Store negative flag*/
- "1:" "\n\t"
- " sts A_negative, %2" "\n\t" /* Store negative flag */
+ L("1")
+ A("sts A_negative, %2") /* Store negative flag */
/* Compute coefficients A,B and C [20 cycles worst case]*/
- " ldi %9,6" "\n\t" /* %9 = 6 */
- " mul %0,%9" "\n\t" /* r1:r0 = 6*LO(v0-v1) */
- " sts bezier_A, r0" "\n\t"
- " mov %6,r1" "\n\t"
- " clr %7" "\n\t" /* %7:%6:r0 = 6*LO(v0-v1) */
- " mul %1,%9" "\n\t" /* r1:r0 = 6*MI(v0-v1) */
- " add %6,r0" "\n\t"
- " adc %7,r1" "\n\t" /* %7:%6:?? += 6*MI(v0-v1) << 8 */
- " mul %10,%9" "\n\t" /* r1:r0 = 6*HI(v0-v1) */
- " add %7,r0" "\n\t" /* %7:%6:?? += 6*HI(v0-v1) << 16 */
- " sts bezier_A+1, %6" "\n\t"
- " sts bezier_A+2, %7" "\n\t" /* bezier_A = %7:%6:?? = 6*(v0-v1) [35 cycles worst] */
-
- " ldi %9,15" "\n\t" /* %9 = 15 */
- " mul %0,%9" "\n\t" /* r1:r0 = 5*LO(v0-v1) */
- " sts bezier_B, r0" "\n\t"
- " mov %6,r1" "\n\t"
- " clr %7" "\n\t" /* %7:%6:?? = 5*LO(v0-v1) */
- " mul %1,%9" "\n\t" /* r1:r0 = 5*MI(v0-v1) */
- " add %6,r0" "\n\t"
- " adc %7,r1" "\n\t" /* %7:%6:?? += 5*MI(v0-v1) << 8 */
- " mul %10,%9" "\n\t" /* r1:r0 = 5*HI(v0-v1) */
- " add %7,r0" "\n\t" /* %7:%6:?? += 5*HI(v0-v1) << 16 */
- " sts bezier_B+1, %6" "\n\t"
- " sts bezier_B+2, %7" "\n\t" /* bezier_B = %7:%6:?? = 5*(v0-v1) [50 cycles worst] */
-
- " ldi %9,10" "\n\t" /* %9 = 10 */
- " mul %0,%9" "\n\t" /* r1:r0 = 10*LO(v0-v1) */
- " sts bezier_C, r0" "\n\t"
- " mov %6,r1" "\n\t"
- " clr %7" "\n\t" /* %7:%6:?? = 10*LO(v0-v1) */
- " mul %1,%9" "\n\t" /* r1:r0 = 10*MI(v0-v1) */
- " add %6,r0" "\n\t"
- " adc %7,r1" "\n\t" /* %7:%6:?? += 10*MI(v0-v1) << 8 */
- " mul %10,%9" "\n\t" /* r1:r0 = 10*HI(v0-v1) */
- " add %7,r0" "\n\t" /* %7:%6:?? += 10*HI(v0-v1) << 16 */
- " sts bezier_C+1, %6" "\n\t"
+ A("ldi %9,6") /* %9 = 6 */
+ A("mul %0,%9") /* r1:r0 = 6*LO(v0-v1) */
+ A("sts bezier_A, r0")
+ A("mov %6,r1")
+ A("clr %7") /* %7:%6:r0 = 6*LO(v0-v1) */
+ A("mul %1,%9") /* r1:r0 = 6*MI(v0-v1) */
+ A("add %6,r0")
+ A("adc %7,r1") /* %7:%6:?? += 6*MI(v0-v1) << 8 */
+ A("mul %10,%9") /* r1:r0 = 6*HI(v0-v1) */
+ A("add %7,r0") /* %7:%6:?? += 6*HI(v0-v1) << 16 */
+ A("sts bezier_A+1, %6")
+ A("sts bezier_A+2, %7") /* bezier_A = %7:%6:?? = 6*(v0-v1) [35 cycles worst] */
+
+ A("ldi %9,15") /* %9 = 15 */
+ A("mul %0,%9") /* r1:r0 = 5*LO(v0-v1) */
+ A("sts bezier_B, r0")
+ A("mov %6,r1")
+ A("clr %7") /* %7:%6:?? = 5*LO(v0-v1) */
+ A("mul %1,%9") /* r1:r0 = 5*MI(v0-v1) */
+ A("add %6,r0")
+ A("adc %7,r1") /* %7:%6:?? += 5*MI(v0-v1) << 8 */
+ A("mul %10,%9") /* r1:r0 = 5*HI(v0-v1) */
+ A("add %7,r0") /* %7:%6:?? += 5*HI(v0-v1) << 16 */
+ A("sts bezier_B+1, %6")
+ A("sts bezier_B+2, %7") /* bezier_B = %7:%6:?? = 5*(v0-v1) [50 cycles worst] */
+
+ A("ldi %9,10") /* %9 = 10 */
+ A("mul %0,%9") /* r1:r0 = 10*LO(v0-v1) */
+ A("sts bezier_C, r0")
+ A("mov %6,r1")
+ A("clr %7") /* %7:%6:?? = 10*LO(v0-v1) */
+ A("mul %1,%9") /* r1:r0 = 10*MI(v0-v1) */
+ A("add %6,r0")
+ A("adc %7,r1") /* %7:%6:?? += 10*MI(v0-v1) << 8 */
+ A("mul %10,%9") /* r1:r0 = 10*HI(v0-v1) */
+ A("add %7,r0") /* %7:%6:?? += 10*HI(v0-v1) << 16 */
+ A("sts bezier_C+1, %6")
" sts bezier_C+2, %7" /* bezier_C = %7:%6:?? = 10*(v0-v1) [65 cycles worst] */
: "+r" (r2),
"+d" (r3),
@@ -674,358 +674,358 @@ void Stepper::set_directions() {
__asm__ __volatile(
/* umul24x24to16hi(t, bezier_AV, curr_step); t: Range 0 - 1^16 = 16 bits*/
- " lds %9,bezier_AV" "\n\t" /* %9 = LO(AV)*/
- " mul %9,%2" "\n\t" /* r1:r0 = LO(bezier_AV)*LO(curr_step)*/
- " mov %7,r1" "\n\t" /* %7 = LO(bezier_AV)*LO(curr_step) >> 8*/
- " clr %8" "\n\t" /* %8:%7 = LO(bezier_AV)*LO(curr_step) >> 8*/
- " lds %10,bezier_AV+1" "\n\t" /* %10 = MI(AV)*/
- " mul %10,%2" "\n\t" /* r1:r0 = MI(bezier_AV)*LO(curr_step)*/
- " add %7,r0" "\n\t"
- " adc %8,r1" "\n\t" /* %8:%7 += MI(bezier_AV)*LO(curr_step)*/
- " lds r1,bezier_AV+2" "\n\t" /* r11 = HI(AV)*/
- " mul r1,%2" "\n\t" /* r1:r0 = HI(bezier_AV)*LO(curr_step)*/
- " add %8,r0" "\n\t" /* %8:%7 += HI(bezier_AV)*LO(curr_step) << 8*/
- " mul %9,%3" "\n\t" /* r1:r0 = LO(bezier_AV)*MI(curr_step)*/
- " add %7,r0" "\n\t"
- " adc %8,r1" "\n\t" /* %8:%7 += LO(bezier_AV)*MI(curr_step)*/
- " mul %10,%3" "\n\t" /* r1:r0 = MI(bezier_AV)*MI(curr_step)*/
- " add %8,r0" "\n\t" /* %8:%7 += LO(bezier_AV)*MI(curr_step) << 8*/
- " mul %9,%4" "\n\t" /* r1:r0 = LO(bezier_AV)*HI(curr_step)*/
- " add %8,r0" "\n\t" /* %8:%7 += LO(bezier_AV)*HI(curr_step) << 8*/
+ A("lds %9,bezier_AV") /* %9 = LO(AV)*/
+ A("mul %9,%2") /* r1:r0 = LO(bezier_AV)*LO(curr_step)*/
+ A("mov %7,r1") /* %7 = LO(bezier_AV)*LO(curr_step) >> 8*/
+ A("clr %8") /* %8:%7 = LO(bezier_AV)*LO(curr_step) >> 8*/
+ A("lds %10,bezier_AV+1") /* %10 = MI(AV)*/
+ A("mul %10,%2") /* r1:r0 = MI(bezier_AV)*LO(curr_step)*/
+ A("add %7,r0")
+ A("adc %8,r1") /* %8:%7 += MI(bezier_AV)*LO(curr_step)*/
+ A("lds r1,bezier_AV+2") /* r11 = HI(AV)*/
+ A("mul r1,%2") /* r1:r0 = HI(bezier_AV)*LO(curr_step)*/
+ A("add %8,r0") /* %8:%7 += HI(bezier_AV)*LO(curr_step) << 8*/
+ A("mul %9,%3") /* r1:r0 = LO(bezier_AV)*MI(curr_step)*/
+ A("add %7,r0")
+ A("adc %8,r1") /* %8:%7 += LO(bezier_AV)*MI(curr_step)*/
+ A("mul %10,%3") /* r1:r0 = MI(bezier_AV)*MI(curr_step)*/
+ A("add %8,r0") /* %8:%7 += LO(bezier_AV)*MI(curr_step) << 8*/
+ A("mul %9,%4") /* r1:r0 = LO(bezier_AV)*HI(curr_step)*/
+ A("add %8,r0") /* %8:%7 += LO(bezier_AV)*HI(curr_step) << 8*/
/* %8:%7 = t*/
/* uint16_t f = t;*/
- " mov %5,%7" "\n\t" /* %6:%5 = f*/
- " mov %6,%8" "\n\t"
+ A("mov %5,%7") /* %6:%5 = f*/
+ A("mov %6,%8")
/* %6:%5 = f*/
/* umul16x16to16hi(f, f, t); / Range 16 bits (unsigned) [17] */
- " mul %5,%7" "\n\t" /* r1:r0 = LO(f) * LO(t)*/
- " mov %9,r1" "\n\t" /* store MIL(LO(f) * LO(t)) in %9, we need it for rounding*/
- " clr %10" "\n\t" /* %10 = 0*/
- " clr %11" "\n\t" /* %11 = 0*/
- " mul %5,%8" "\n\t" /* r1:r0 = LO(f) * HI(t)*/
- " add %9,r0" "\n\t" /* %9 += LO(LO(f) * HI(t))*/
- " adc %10,r1" "\n\t" /* %10 = HI(LO(f) * HI(t))*/
- " adc %11,%0" "\n\t" /* %11 += carry*/
- " mul %6,%7" "\n\t" /* r1:r0 = HI(f) * LO(t)*/
- " add %9,r0" "\n\t" /* %9 += LO(HI(f) * LO(t))*/
- " adc %10,r1" "\n\t" /* %10 += HI(HI(f) * LO(t)) */
- " adc %11,%0" "\n\t" /* %11 += carry*/
- " mul %6,%8" "\n\t" /* r1:r0 = HI(f) * HI(t)*/
- " add %10,r0" "\n\t" /* %10 += LO(HI(f) * HI(t))*/
- " adc %11,r1" "\n\t" /* %11 += HI(HI(f) * HI(t))*/
- " mov %5,%10" "\n\t" /* %6:%5 = */
- " mov %6,%11" "\n\t" /* f = %10:%11*/
+ A("mul %5,%7") /* r1:r0 = LO(f) * LO(t)*/
+ A("mov %9,r1") /* store MIL(LO(f) * LO(t)) in %9, we need it for rounding*/
+ A("clr %10") /* %10 = 0*/
+ A("clr %11") /* %11 = 0*/
+ A("mul %5,%8") /* r1:r0 = LO(f) * HI(t)*/
+ A("add %9,r0") /* %9 += LO(LO(f) * HI(t))*/
+ A("adc %10,r1") /* %10 = HI(LO(f) * HI(t))*/
+ A("adc %11,%0") /* %11 += carry*/
+ A("mul %6,%7") /* r1:r0 = HI(f) * LO(t)*/
+ A("add %9,r0") /* %9 += LO(HI(f) * LO(t))*/
+ A("adc %10,r1") /* %10 += HI(HI(f) * LO(t)) */
+ A("adc %11,%0") /* %11 += carry*/
+ A("mul %6,%8") /* r1:r0 = HI(f) * HI(t)*/
+ A("add %10,r0") /* %10 += LO(HI(f) * HI(t))*/
+ A("adc %11,r1") /* %11 += HI(HI(f) * HI(t))*/
+ A("mov %5,%10") /* %6:%5 = */
+ A("mov %6,%11") /* f = %10:%11*/
/* umul16x16to16hi(f, f, t); / Range 16 bits : f = t^3 (unsigned) [17]*/
- " mul %5,%7" "\n\t" /* r1:r0 = LO(f) * LO(t)*/
- " mov %1,r1" "\n\t" /* store MIL(LO(f) * LO(t)) in %1, we need it for rounding*/
- " clr %10" "\n\t" /* %10 = 0*/
- " clr %11" "\n\t" /* %11 = 0*/
- " mul %5,%8" "\n\t" /* r1:r0 = LO(f) * HI(t)*/
- " add %1,r0" "\n\t" /* %1 += LO(LO(f) * HI(t))*/
- " adc %10,r1" "\n\t" /* %10 = HI(LO(f) * HI(t))*/
- " adc %11,%0" "\n\t" /* %11 += carry*/
- " mul %6,%7" "\n\t" /* r1:r0 = HI(f) * LO(t)*/
- " add %1,r0" "\n\t" /* %1 += LO(HI(f) * LO(t))*/
- " adc %10,r1" "\n\t" /* %10 += HI(HI(f) * LO(t))*/
- " adc %11,%0" "\n\t" /* %11 += carry*/
- " mul %6,%8" "\n\t" /* r1:r0 = HI(f) * HI(t)*/
- " add %10,r0" "\n\t" /* %10 += LO(HI(f) * HI(t))*/
- " adc %11,r1" "\n\t" /* %11 += HI(HI(f) * HI(t))*/
- " mov %5,%10" "\n\t" /* %6:%5 =*/
- " mov %6,%11" "\n\t" /* f = %10:%11*/
+ A("mul %5,%7") /* r1:r0 = LO(f) * LO(t)*/
+ A("mov %1,r1") /* store MIL(LO(f) * LO(t)) in %1, we need it for rounding*/
+ A("clr %10") /* %10 = 0*/
+ A("clr %11") /* %11 = 0*/
+ A("mul %5,%8") /* r1:r0 = LO(f) * HI(t)*/
+ A("add %1,r0") /* %1 += LO(LO(f) * HI(t))*/
+ A("adc %10,r1") /* %10 = HI(LO(f) * HI(t))*/
+ A("adc %11,%0") /* %11 += carry*/
+ A("mul %6,%7") /* r1:r0 = HI(f) * LO(t)*/
+ A("add %1,r0") /* %1 += LO(HI(f) * LO(t))*/
+ A("adc %10,r1") /* %10 += HI(HI(f) * LO(t))*/
+ A("adc %11,%0") /* %11 += carry*/
+ A("mul %6,%8") /* r1:r0 = HI(f) * HI(t)*/
+ A("add %10,r0") /* %10 += LO(HI(f) * HI(t))*/
+ A("adc %11,r1") /* %11 += HI(HI(f) * HI(t))*/
+ A("mov %5,%10") /* %6:%5 =*/
+ A("mov %6,%11") /* f = %10:%11*/
/* [15 +17*2] = [49]*/
/* %4:%3:%2 will be acc from now on*/
/* uint24_t acc = bezier_F; / Range 20 bits (unsigned)*/
- " clr %9" "\n\t" /* "decimal place we get for free"*/
- " lds %2,bezier_F" "\n\t"
- " lds %3,bezier_F+1" "\n\t"
- " lds %4,bezier_F+2" "\n\t" /* %4:%3:%2 = acc*/
+ A("clr %9") /* "decimal place we get for free"*/
+ A("lds %2,bezier_F")
+ A("lds %3,bezier_F+1")
+ A("lds %4,bezier_F+2") /* %4:%3:%2 = acc*/
/* if (A_negative) {*/
- " lds r0,A_negative" "\n\t"
- " or r0,%0" "\n\t" /* Is flag signalling negative? */
- " brne 3f" "\n\t" /* If yes, Skip next instruction if A was negative*/
- " rjmp 1f" "\n\t" /* Otherwise, jump */
+ A("lds r0,A_negative")
+ A("or r0,%0") /* Is flag signalling negative? */
+ A("brne 3f") /* If yes, Skip next instruction if A was negative*/
+ A("rjmp 1f") /* Otherwise, jump */
/* uint24_t v; */
/* umul16x24to24hi(v, f, bezier_C); / Range 21bits [29] */
/* acc -= v; */
- "3:" "\n\t"
- " lds %10, bezier_C" "\n\t" /* %10 = LO(bezier_C)*/
- " mul %10,%5" "\n\t" /* r1:r0 = LO(bezier_C) * LO(f)*/
- " sub %9,r1" "\n\t"
- " sbc %2,%0" "\n\t"
- " sbc %3,%0" "\n\t"
- " sbc %4,%0" "\n\t" /* %4:%3:%2:%9 -= HI(LO(bezier_C) * LO(f))*/
- " lds %11, bezier_C+1" "\n\t" /* %11 = MI(bezier_C)*/
- " mul %11,%5" "\n\t" /* r1:r0 = MI(bezier_C) * LO(f)*/
- " sub %9,r0" "\n\t"
- " sbc %2,r1" "\n\t"
- " sbc %3,%0" "\n\t"
- " sbc %4,%0" "\n\t" /* %4:%3:%2:%9 -= MI(bezier_C) * LO(f)*/
- " lds %1, bezier_C+2" "\n\t" /* %1 = HI(bezier_C)*/
- " mul %1,%5" "\n\t" /* r1:r0 = MI(bezier_C) * LO(f)*/
- " sub %2,r0" "\n\t"
- " sbc %3,r1" "\n\t"
- " sbc %4,%0" "\n\t" /* %4:%3:%2:%9 -= HI(bezier_C) * LO(f) << 8*/
- " mul %10,%6" "\n\t" /* r1:r0 = LO(bezier_C) * MI(f)*/
- " sub %9,r0" "\n\t"
- " sbc %2,r1" "\n\t"
- " sbc %3,%0" "\n\t"
- " sbc %4,%0" "\n\t" /* %4:%3:%2:%9 -= LO(bezier_C) * MI(f)*/
- " mul %11,%6" "\n\t" /* r1:r0 = MI(bezier_C) * MI(f)*/
- " sub %2,r0" "\n\t"
- " sbc %3,r1" "\n\t"
- " sbc %4,%0" "\n\t" /* %4:%3:%2:%9 -= MI(bezier_C) * MI(f) << 8*/
- " mul %1,%6" "\n\t" /* r1:r0 = HI(bezier_C) * LO(f)*/
- " sub %3,r0" "\n\t"
- " sbc %4,r1" "\n\t" /* %4:%3:%2:%9 -= HI(bezier_C) * LO(f) << 16*/
+ L("3")
+ A("lds %10, bezier_C") /* %10 = LO(bezier_C)*/
+ A("mul %10,%5") /* r1:r0 = LO(bezier_C) * LO(f)*/
+ A("sub %9,r1")
+ A("sbc %2,%0")
+ A("sbc %3,%0")
+ A("sbc %4,%0") /* %4:%3:%2:%9 -= HI(LO(bezier_C) * LO(f))*/
+ A("lds %11, bezier_C+1") /* %11 = MI(bezier_C)*/
+ A("mul %11,%5") /* r1:r0 = MI(bezier_C) * LO(f)*/
+ A("sub %9,r0")
+ A("sbc %2,r1")
+ A("sbc %3,%0")
+ A("sbc %4,%0") /* %4:%3:%2:%9 -= MI(bezier_C) * LO(f)*/
+ A("lds %1, bezier_C+2") /* %1 = HI(bezier_C)*/
+ A("mul %1,%5") /* r1:r0 = MI(bezier_C) * LO(f)*/
+ A("sub %2,r0")
+ A("sbc %3,r1")
+ A("sbc %4,%0") /* %4:%3:%2:%9 -= HI(bezier_C) * LO(f) << 8*/
+ A("mul %10,%6") /* r1:r0 = LO(bezier_C) * MI(f)*/
+ A("sub %9,r0")
+ A("sbc %2,r1")
+ A("sbc %3,%0")
+ A("sbc %4,%0") /* %4:%3:%2:%9 -= LO(bezier_C) * MI(f)*/
+ A("mul %11,%6") /* r1:r0 = MI(bezier_C) * MI(f)*/
+ A("sub %2,r0")
+ A("sbc %3,r1")
+ A("sbc %4,%0") /* %4:%3:%2:%9 -= MI(bezier_C) * MI(f) << 8*/
+ A("mul %1,%6") /* r1:r0 = HI(bezier_C) * LO(f)*/
+ A("sub %3,r0")
+ A("sbc %4,r1") /* %4:%3:%2:%9 -= HI(bezier_C) * LO(f) << 16*/
/* umul16x16to16hi(f, f, t); / Range 16 bits : f = t^3 (unsigned) [17]*/
- " mul %5,%7" "\n\t" /* r1:r0 = LO(f) * LO(t)*/
- " mov %1,r1" "\n\t" /* store MIL(LO(f) * LO(t)) in %1, we need it for rounding*/
- " clr %10" "\n\t" /* %10 = 0*/
- " clr %11" "\n\t" /* %11 = 0*/
- " mul %5,%8" "\n\t" /* r1:r0 = LO(f) * HI(t)*/
- " add %1,r0" "\n\t" /* %1 += LO(LO(f) * HI(t))*/
- " adc %10,r1" "\n\t" /* %10 = HI(LO(f) * HI(t))*/
- " adc %11,%0" "\n\t" /* %11 += carry*/
- " mul %6,%7" "\n\t" /* r1:r0 = HI(f) * LO(t)*/
- " add %1,r0" "\n\t" /* %1 += LO(HI(f) * LO(t))*/
- " adc %10,r1" "\n\t" /* %10 += HI(HI(f) * LO(t))*/
- " adc %11,%0" "\n\t" /* %11 += carry*/
- " mul %6,%8" "\n\t" /* r1:r0 = HI(f) * HI(t)*/
- " add %10,r0" "\n\t" /* %10 += LO(HI(f) * HI(t))*/
- " adc %11,r1" "\n\t" /* %11 += HI(HI(f) * HI(t))*/
- " mov %5,%10" "\n\t" /* %6:%5 =*/
- " mov %6,%11" "\n\t" /* f = %10:%11*/
+ A("mul %5,%7") /* r1:r0 = LO(f) * LO(t)*/
+ A("mov %1,r1") /* store MIL(LO(f) * LO(t)) in %1, we need it for rounding*/
+ A("clr %10") /* %10 = 0*/
+ A("clr %11") /* %11 = 0*/
+ A("mul %5,%8") /* r1:r0 = LO(f) * HI(t)*/
+ A("add %1,r0") /* %1 += LO(LO(f) * HI(t))*/
+ A("adc %10,r1") /* %10 = HI(LO(f) * HI(t))*/
+ A("adc %11,%0") /* %11 += carry*/
+ A("mul %6,%7") /* r1:r0 = HI(f) * LO(t)*/
+ A("add %1,r0") /* %1 += LO(HI(f) * LO(t))*/
+ A("adc %10,r1") /* %10 += HI(HI(f) * LO(t))*/
+ A("adc %11,%0") /* %11 += carry*/
+ A("mul %6,%8") /* r1:r0 = HI(f) * HI(t)*/
+ A("add %10,r0") /* %10 += LO(HI(f) * HI(t))*/
+ A("adc %11,r1") /* %11 += HI(HI(f) * HI(t))*/
+ A("mov %5,%10") /* %6:%5 =*/
+ A("mov %6,%11") /* f = %10:%11*/
/* umul16x24to24hi(v, f, bezier_B); / Range 22bits [29]*/
/* acc += v; */
- " lds %10, bezier_B" "\n\t" /* %10 = LO(bezier_B)*/
- " mul %10,%5" "\n\t" /* r1:r0 = LO(bezier_B) * LO(f)*/
- " add %9,r1" "\n\t"
- " adc %2,%0" "\n\t"
- " adc %3,%0" "\n\t"
- " adc %4,%0" "\n\t" /* %4:%3:%2:%9 += HI(LO(bezier_B) * LO(f))*/
- " lds %11, bezier_B+1" "\n\t" /* %11 = MI(bezier_B)*/
- " mul %11,%5" "\n\t" /* r1:r0 = MI(bezier_B) * LO(f)*/
- " add %9,r0" "\n\t"
- " adc %2,r1" "\n\t"
- " adc %3,%0" "\n\t"
- " adc %4,%0" "\n\t" /* %4:%3:%2:%9 += MI(bezier_B) * LO(f)*/
- " lds %1, bezier_B+2" "\n\t" /* %1 = HI(bezier_B)*/
- " mul %1,%5" "\n\t" /* r1:r0 = MI(bezier_B) * LO(f)*/
- " add %2,r0" "\n\t"
- " adc %3,r1" "\n\t"
- " adc %4,%0" "\n\t" /* %4:%3:%2:%9 += HI(bezier_B) * LO(f) << 8*/
- " mul %10,%6" "\n\t" /* r1:r0 = LO(bezier_B) * MI(f)*/
- " add %9,r0" "\n\t"
- " adc %2,r1" "\n\t"
- " adc %3,%0" "\n\t"
- " adc %4,%0" "\n\t" /* %4:%3:%2:%9 += LO(bezier_B) * MI(f)*/
- " mul %11,%6" "\n\t" /* r1:r0 = MI(bezier_B) * MI(f)*/
- " add %2,r0" "\n\t"
- " adc %3,r1" "\n\t"
- " adc %4,%0" "\n\t" /* %4:%3:%2:%9 += MI(bezier_B) * MI(f) << 8*/
- " mul %1,%6" "\n\t" /* r1:r0 = HI(bezier_B) * LO(f)*/
- " add %3,r0" "\n\t"
- " adc %4,r1" "\n\t" /* %4:%3:%2:%9 += HI(bezier_B) * LO(f) << 16*/
+ A("lds %10, bezier_B") /* %10 = LO(bezier_B)*/
+ A("mul %10,%5") /* r1:r0 = LO(bezier_B) * LO(f)*/
+ A("add %9,r1")
+ A("adc %2,%0")
+ A("adc %3,%0")
+ A("adc %4,%0") /* %4:%3:%2:%9 += HI(LO(bezier_B) * LO(f))*/
+ A("lds %11, bezier_B+1") /* %11 = MI(bezier_B)*/
+ A("mul %11,%5") /* r1:r0 = MI(bezier_B) * LO(f)*/
+ A("add %9,r0")
+ A("adc %2,r1")
+ A("adc %3,%0")
+ A("adc %4,%0") /* %4:%3:%2:%9 += MI(bezier_B) * LO(f)*/
+ A("lds %1, bezier_B+2") /* %1 = HI(bezier_B)*/
+ A("mul %1,%5") /* r1:r0 = MI(bezier_B) * LO(f)*/
+ A("add %2,r0")
+ A("adc %3,r1")
+ A("adc %4,%0") /* %4:%3:%2:%9 += HI(bezier_B) * LO(f) << 8*/
+ A("mul %10,%6") /* r1:r0 = LO(bezier_B) * MI(f)*/
+ A("add %9,r0")
+ A("adc %2,r1")
+ A("adc %3,%0")
+ A("adc %4,%0") /* %4:%3:%2:%9 += LO(bezier_B) * MI(f)*/
+ A("mul %11,%6") /* r1:r0 = MI(bezier_B) * MI(f)*/
+ A("add %2,r0")
+ A("adc %3,r1")
+ A("adc %4,%0") /* %4:%3:%2:%9 += MI(bezier_B) * MI(f) << 8*/
+ A("mul %1,%6") /* r1:r0 = HI(bezier_B) * LO(f)*/
+ A("add %3,r0")
+ A("adc %4,r1") /* %4:%3:%2:%9 += HI(bezier_B) * LO(f) << 16*/
/* umul16x16to16hi(f, f, t); / Range 16 bits : f = t^5 (unsigned) [17]*/
- " mul %5,%7" "\n\t" /* r1:r0 = LO(f) * LO(t)*/
- " mov %1,r1" "\n\t" /* store MIL(LO(f) * LO(t)) in %1, we need it for rounding*/
- " clr %10" "\n\t" /* %10 = 0*/
- " clr %11" "\n\t" /* %11 = 0*/
- " mul %5,%8" "\n\t" /* r1:r0 = LO(f) * HI(t)*/
- " add %1,r0" "\n\t" /* %1 += LO(LO(f) * HI(t))*/
- " adc %10,r1" "\n\t" /* %10 = HI(LO(f) * HI(t))*/
- " adc %11,%0" "\n\t" /* %11 += carry*/
- " mul %6,%7" "\n\t" /* r1:r0 = HI(f) * LO(t)*/
- " add %1,r0" "\n\t" /* %1 += LO(HI(f) * LO(t))*/
- " adc %10,r1" "\n\t" /* %10 += HI(HI(f) * LO(t))*/
- " adc %11,%0" "\n\t" /* %11 += carry*/
- " mul %6,%8" "\n\t" /* r1:r0 = HI(f) * HI(t)*/
- " add %10,r0" "\n\t" /* %10 += LO(HI(f) * HI(t))*/
- " adc %11,r1" "\n\t" /* %11 += HI(HI(f) * HI(t))*/
- " mov %5,%10" "\n\t" /* %6:%5 =*/
- " mov %6,%11" "\n\t" /* f = %10:%11*/
+ A("mul %5,%7") /* r1:r0 = LO(f) * LO(t)*/
+ A("mov %1,r1") /* store MIL(LO(f) * LO(t)) in %1, we need it for rounding*/
+ A("clr %10") /* %10 = 0*/
+ A("clr %11") /* %11 = 0*/
+ A("mul %5,%8") /* r1:r0 = LO(f) * HI(t)*/
+ A("add %1,r0") /* %1 += LO(LO(f) * HI(t))*/
+ A("adc %10,r1") /* %10 = HI(LO(f) * HI(t))*/
+ A("adc %11,%0") /* %11 += carry*/
+ A("mul %6,%7") /* r1:r0 = HI(f) * LO(t)*/
+ A("add %1,r0") /* %1 += LO(HI(f) * LO(t))*/
+ A("adc %10,r1") /* %10 += HI(HI(f) * LO(t))*/
+ A("adc %11,%0") /* %11 += carry*/
+ A("mul %6,%8") /* r1:r0 = HI(f) * HI(t)*/
+ A("add %10,r0") /* %10 += LO(HI(f) * HI(t))*/
+ A("adc %11,r1") /* %11 += HI(HI(f) * HI(t))*/
+ A("mov %5,%10") /* %6:%5 =*/
+ A("mov %6,%11") /* f = %10:%11*/
/* umul16x24to24hi(v, f, bezier_A); / Range 21bits [29]*/
/* acc -= v; */
- " lds %10, bezier_A" "\n\t" /* %10 = LO(bezier_A)*/
- " mul %10,%5" "\n\t" /* r1:r0 = LO(bezier_A) * LO(f)*/
- " sub %9,r1" "\n\t"
- " sbc %2,%0" "\n\t"
- " sbc %3,%0" "\n\t"
- " sbc %4,%0" "\n\t" /* %4:%3:%2:%9 -= HI(LO(bezier_A) * LO(f))*/
- " lds %11, bezier_A+1" "\n\t" /* %11 = MI(bezier_A)*/
- " mul %11,%5" "\n\t" /* r1:r0 = MI(bezier_A) * LO(f)*/
- " sub %9,r0" "\n\t"
- " sbc %2,r1" "\n\t"
- " sbc %3,%0" "\n\t"
- " sbc %4,%0" "\n\t" /* %4:%3:%2:%9 -= MI(bezier_A) * LO(f)*/
- " lds %1, bezier_A+2" "\n\t" /* %1 = HI(bezier_A)*/
- " mul %1,%5" "\n\t" /* r1:r0 = MI(bezier_A) * LO(f)*/
- " sub %2,r0" "\n\t"
- " sbc %3,r1" "\n\t"
- " sbc %4,%0" "\n\t" /* %4:%3:%2:%9 -= HI(bezier_A) * LO(f) << 8*/
- " mul %10,%6" "\n\t" /* r1:r0 = LO(bezier_A) * MI(f)*/
- " sub %9,r0" "\n\t"
- " sbc %2,r1" "\n\t"
- " sbc %3,%0" "\n\t"
- " sbc %4,%0" "\n\t" /* %4:%3:%2:%9 -= LO(bezier_A) * MI(f)*/
- " mul %11,%6" "\n\t" /* r1:r0 = MI(bezier_A) * MI(f)*/
- " sub %2,r0" "\n\t"
- " sbc %3,r1" "\n\t"
- " sbc %4,%0" "\n\t" /* %4:%3:%2:%9 -= MI(bezier_A) * MI(f) << 8*/
- " mul %1,%6" "\n\t" /* r1:r0 = HI(bezier_A) * LO(f)*/
- " sub %3,r0" "\n\t"
- " sbc %4,r1" "\n\t" /* %4:%3:%2:%9 -= HI(bezier_A) * LO(f) << 16*/
- " jmp 2f" "\n\t" /* Done!*/
-
- "1:" "\n\t"
+ A("lds %10, bezier_A") /* %10 = LO(bezier_A)*/
+ A("mul %10,%5") /* r1:r0 = LO(bezier_A) * LO(f)*/
+ A("sub %9,r1")
+ A("sbc %2,%0")
+ A("sbc %3,%0")
+ A("sbc %4,%0") /* %4:%3:%2:%9 -= HI(LO(bezier_A) * LO(f))*/
+ A("lds %11, bezier_A+1") /* %11 = MI(bezier_A)*/
+ A("mul %11,%5") /* r1:r0 = MI(bezier_A) * LO(f)*/
+ A("sub %9,r0")
+ A("sbc %2,r1")
+ A("sbc %3,%0")
+ A("sbc %4,%0") /* %4:%3:%2:%9 -= MI(bezier_A) * LO(f)*/
+ A("lds %1, bezier_A+2") /* %1 = HI(bezier_A)*/
+ A("mul %1,%5") /* r1:r0 = MI(bezier_A) * LO(f)*/
+ A("sub %2,r0")
+ A("sbc %3,r1")
+ A("sbc %4,%0") /* %4:%3:%2:%9 -= HI(bezier_A) * LO(f) << 8*/
+ A("mul %10,%6") /* r1:r0 = LO(bezier_A) * MI(f)*/
+ A("sub %9,r0")
+ A("sbc %2,r1")
+ A("sbc %3,%0")
+ A("sbc %4,%0") /* %4:%3:%2:%9 -= LO(bezier_A) * MI(f)*/
+ A("mul %11,%6") /* r1:r0 = MI(bezier_A) * MI(f)*/
+ A("sub %2,r0")
+ A("sbc %3,r1")
+ A("sbc %4,%0") /* %4:%3:%2:%9 -= MI(bezier_A) * MI(f) << 8*/
+ A("mul %1,%6") /* r1:r0 = HI(bezier_A) * LO(f)*/
+ A("sub %3,r0")
+ A("sbc %4,r1") /* %4:%3:%2:%9 -= HI(bezier_A) * LO(f) << 16*/
+ A("jmp 2f") /* Done!*/
+
+ L("1")
/* uint24_t v; */
/* umul16x24to24hi(v, f, bezier_C); / Range 21bits [29]*/
/* acc += v; */
- " lds %10, bezier_C" "\n\t" /* %10 = LO(bezier_C)*/
- " mul %10,%5" "\n\t" /* r1:r0 = LO(bezier_C) * LO(f)*/
- " add %9,r1" "\n\t"
- " adc %2,%0" "\n\t"
- " adc %3,%0" "\n\t"
- " adc %4,%0" "\n\t" /* %4:%3:%2:%9 += HI(LO(bezier_C) * LO(f))*/
- " lds %11, bezier_C+1" "\n\t" /* %11 = MI(bezier_C)*/
- " mul %11,%5" "\n\t" /* r1:r0 = MI(bezier_C) * LO(f)*/
- " add %9,r0" "\n\t"
- " adc %2,r1" "\n\t"
- " adc %3,%0" "\n\t"
- " adc %4,%0" "\n\t" /* %4:%3:%2:%9 += MI(bezier_C) * LO(f)*/
- " lds %1, bezier_C+2" "\n\t" /* %1 = HI(bezier_C)*/
- " mul %1,%5" "\n\t" /* r1:r0 = MI(bezier_C) * LO(f)*/
- " add %2,r0" "\n\t"
- " adc %3,r1" "\n\t"
- " adc %4,%0" "\n\t" /* %4:%3:%2:%9 += HI(bezier_C) * LO(f) << 8*/
- " mul %10,%6" "\n\t" /* r1:r0 = LO(bezier_C) * MI(f)*/
- " add %9,r0" "\n\t"
- " adc %2,r1" "\n\t"
- " adc %3,%0" "\n\t"
- " adc %4,%0" "\n\t" /* %4:%3:%2:%9 += LO(bezier_C) * MI(f)*/
- " mul %11,%6" "\n\t" /* r1:r0 = MI(bezier_C) * MI(f)*/
- " add %2,r0" "\n\t"
- " adc %3,r1" "\n\t"
- " adc %4,%0" "\n\t" /* %4:%3:%2:%9 += MI(bezier_C) * MI(f) << 8*/
- " mul %1,%6" "\n\t" /* r1:r0 = HI(bezier_C) * LO(f)*/
- " add %3,r0" "\n\t"
- " adc %4,r1" "\n\t" /* %4:%3:%2:%9 += HI(bezier_C) * LO(f) << 16*/
+ A("lds %10, bezier_C") /* %10 = LO(bezier_C)*/
+ A("mul %10,%5") /* r1:r0 = LO(bezier_C) * LO(f)*/
+ A("add %9,r1")
+ A("adc %2,%0")
+ A("adc %3,%0")
+ A("adc %4,%0") /* %4:%3:%2:%9 += HI(LO(bezier_C) * LO(f))*/
+ A("lds %11, bezier_C+1") /* %11 = MI(bezier_C)*/
+ A("mul %11,%5") /* r1:r0 = MI(bezier_C) * LO(f)*/
+ A("add %9,r0")
+ A("adc %2,r1")
+ A("adc %3,%0")
+ A("adc %4,%0") /* %4:%3:%2:%9 += MI(bezier_C) * LO(f)*/
+ A("lds %1, bezier_C+2") /* %1 = HI(bezier_C)*/
+ A("mul %1,%5") /* r1:r0 = MI(bezier_C) * LO(f)*/
+ A("add %2,r0")
+ A("adc %3,r1")
+ A("adc %4,%0") /* %4:%3:%2:%9 += HI(bezier_C) * LO(f) << 8*/
+ A("mul %10,%6") /* r1:r0 = LO(bezier_C) * MI(f)*/
+ A("add %9,r0")
+ A("adc %2,r1")
+ A("adc %3,%0")
+ A("adc %4,%0") /* %4:%3:%2:%9 += LO(bezier_C) * MI(f)*/
+ A("mul %11,%6") /* r1:r0 = MI(bezier_C) * MI(f)*/
+ A("add %2,r0")
+ A("adc %3,r1")
+ A("adc %4,%0") /* %4:%3:%2:%9 += MI(bezier_C) * MI(f) << 8*/
+ A("mul %1,%6") /* r1:r0 = HI(bezier_C) * LO(f)*/
+ A("add %3,r0")
+ A("adc %4,r1") /* %4:%3:%2:%9 += HI(bezier_C) * LO(f) << 16*/
/* umul16x16to16hi(f, f, t); / Range 16 bits : f = t^3 (unsigned) [17]*/
- " mul %5,%7" "\n\t" /* r1:r0 = LO(f) * LO(t)*/
- " mov %1,r1" "\n\t" /* store MIL(LO(f) * LO(t)) in %1, we need it for rounding*/
- " clr %10" "\n\t" /* %10 = 0*/
- " clr %11" "\n\t" /* %11 = 0*/
- " mul %5,%8" "\n\t" /* r1:r0 = LO(f) * HI(t)*/
- " add %1,r0" "\n\t" /* %1 += LO(LO(f) * HI(t))*/
- " adc %10,r1" "\n\t" /* %10 = HI(LO(f) * HI(t))*/
- " adc %11,%0" "\n\t" /* %11 += carry*/
- " mul %6,%7" "\n\t" /* r1:r0 = HI(f) * LO(t)*/
- " add %1,r0" "\n\t" /* %1 += LO(HI(f) * LO(t))*/
- " adc %10,r1" "\n\t" /* %10 += HI(HI(f) * LO(t))*/
- " adc %11,%0" "\n\t" /* %11 += carry*/
- " mul %6,%8" "\n\t" /* r1:r0 = HI(f) * HI(t)*/
- " add %10,r0" "\n\t" /* %10 += LO(HI(f) * HI(t))*/
- " adc %11,r1" "\n\t" /* %11 += HI(HI(f) * HI(t))*/
- " mov %5,%10" "\n\t" /* %6:%5 =*/
- " mov %6,%11" "\n\t" /* f = %10:%11*/
+ A("mul %5,%7") /* r1:r0 = LO(f) * LO(t)*/
+ A("mov %1,r1") /* store MIL(LO(f) * LO(t)) in %1, we need it for rounding*/
+ A("clr %10") /* %10 = 0*/
+ A("clr %11") /* %11 = 0*/
+ A("mul %5,%8") /* r1:r0 = LO(f) * HI(t)*/
+ A("add %1,r0") /* %1 += LO(LO(f) * HI(t))*/
+ A("adc %10,r1") /* %10 = HI(LO(f) * HI(t))*/
+ A("adc %11,%0") /* %11 += carry*/
+ A("mul %6,%7") /* r1:r0 = HI(f) * LO(t)*/
+ A("add %1,r0") /* %1 += LO(HI(f) * LO(t))*/
+ A("adc %10,r1") /* %10 += HI(HI(f) * LO(t))*/
+ A("adc %11,%0") /* %11 += carry*/
+ A("mul %6,%8") /* r1:r0 = HI(f) * HI(t)*/
+ A("add %10,r0") /* %10 += LO(HI(f) * HI(t))*/
+ A("adc %11,r1") /* %11 += HI(HI(f) * HI(t))*/
+ A("mov %5,%10") /* %6:%5 =*/
+ A("mov %6,%11") /* f = %10:%11*/
/* umul16x24to24hi(v, f, bezier_B); / Range 22bits [29]*/
/* acc -= v;*/
- " lds %10, bezier_B" "\n\t" /* %10 = LO(bezier_B)*/
- " mul %10,%5" "\n\t" /* r1:r0 = LO(bezier_B) * LO(f)*/
- " sub %9,r1" "\n\t"
- " sbc %2,%0" "\n\t"
- " sbc %3,%0" "\n\t"
- " sbc %4,%0" "\n\t" /* %4:%3:%2:%9 -= HI(LO(bezier_B) * LO(f))*/
- " lds %11, bezier_B+1" "\n\t" /* %11 = MI(bezier_B)*/
- " mul %11,%5" "\n\t" /* r1:r0 = MI(bezier_B) * LO(f)*/
- " sub %9,r0" "\n\t"
- " sbc %2,r1" "\n\t"
- " sbc %3,%0" "\n\t"
- " sbc %4,%0" "\n\t" /* %4:%3:%2:%9 -= MI(bezier_B) * LO(f)*/
- " lds %1, bezier_B+2" "\n\t" /* %1 = HI(bezier_B)*/
- " mul %1,%5" "\n\t" /* r1:r0 = MI(bezier_B) * LO(f)*/
- " sub %2,r0" "\n\t"
- " sbc %3,r1" "\n\t"
- " sbc %4,%0" "\n\t" /* %4:%3:%2:%9 -= HI(bezier_B) * LO(f) << 8*/
- " mul %10,%6" "\n\t" /* r1:r0 = LO(bezier_B) * MI(f)*/
- " sub %9,r0" "\n\t"
- " sbc %2,r1" "\n\t"
- " sbc %3,%0" "\n\t"
- " sbc %4,%0" "\n\t" /* %4:%3:%2:%9 -= LO(bezier_B) * MI(f)*/
- " mul %11,%6" "\n\t" /* r1:r0 = MI(bezier_B) * MI(f)*/
- " sub %2,r0" "\n\t"
- " sbc %3,r1" "\n\t"
- " sbc %4,%0" "\n\t" /* %4:%3:%2:%9 -= MI(bezier_B) * MI(f) << 8*/
- " mul %1,%6" "\n\t" /* r1:r0 = HI(bezier_B) * LO(f)*/
- " sub %3,r0" "\n\t"
- " sbc %4,r1" "\n\t" /* %4:%3:%2:%9 -= HI(bezier_B) * LO(f) << 16*/
+ A("lds %10, bezier_B") /* %10 = LO(bezier_B)*/
+ A("mul %10,%5") /* r1:r0 = LO(bezier_B) * LO(f)*/
+ A("sub %9,r1")
+ A("sbc %2,%0")
+ A("sbc %3,%0")
+ A("sbc %4,%0") /* %4:%3:%2:%9 -= HI(LO(bezier_B) * LO(f))*/
+ A("lds %11, bezier_B+1") /* %11 = MI(bezier_B)*/
+ A("mul %11,%5") /* r1:r0 = MI(bezier_B) * LO(f)*/
+ A("sub %9,r0")
+ A("sbc %2,r1")
+ A("sbc %3,%0")
+ A("sbc %4,%0") /* %4:%3:%2:%9 -= MI(bezier_B) * LO(f)*/
+ A("lds %1, bezier_B+2") /* %1 = HI(bezier_B)*/
+ A("mul %1,%5") /* r1:r0 = MI(bezier_B) * LO(f)*/
+ A("sub %2,r0")
+ A("sbc %3,r1")
+ A("sbc %4,%0") /* %4:%3:%2:%9 -= HI(bezier_B) * LO(f) << 8*/
+ A("mul %10,%6") /* r1:r0 = LO(bezier_B) * MI(f)*/
+ A("sub %9,r0")
+ A("sbc %2,r1")
+ A("sbc %3,%0")
+ A("sbc %4,%0") /* %4:%3:%2:%9 -= LO(bezier_B) * MI(f)*/
+ A("mul %11,%6") /* r1:r0 = MI(bezier_B) * MI(f)*/
+ A("sub %2,r0")
+ A("sbc %3,r1")
+ A("sbc %4,%0") /* %4:%3:%2:%9 -= MI(bezier_B) * MI(f) << 8*/
+ A("mul %1,%6") /* r1:r0 = HI(bezier_B) * LO(f)*/
+ A("sub %3,r0")
+ A("sbc %4,r1") /* %4:%3:%2:%9 -= HI(bezier_B) * LO(f) << 16*/
/* umul16x16to16hi(f, f, t); / Range 16 bits : f = t^5 (unsigned) [17]*/
- " mul %5,%7" "\n\t" /* r1:r0 = LO(f) * LO(t)*/
- " mov %1,r1" "\n\t" /* store MIL(LO(f) * LO(t)) in %1, we need it for rounding*/
- " clr %10" "\n\t" /* %10 = 0*/
- " clr %11" "\n\t" /* %11 = 0*/
- " mul %5,%8" "\n\t" /* r1:r0 = LO(f) * HI(t)*/
- " add %1,r0" "\n\t" /* %1 += LO(LO(f) * HI(t))*/
- " adc %10,r1" "\n\t" /* %10 = HI(LO(f) * HI(t))*/
- " adc %11,%0" "\n\t" /* %11 += carry*/
- " mul %6,%7" "\n\t" /* r1:r0 = HI(f) * LO(t)*/
- " add %1,r0" "\n\t" /* %1 += LO(HI(f) * LO(t))*/
- " adc %10,r1" "\n\t" /* %10 += HI(HI(f) * LO(t))*/
- " adc %11,%0" "\n\t" /* %11 += carry*/
- " mul %6,%8" "\n\t" /* r1:r0 = HI(f) * HI(t)*/
- " add %10,r0" "\n\t" /* %10 += LO(HI(f) * HI(t))*/
- " adc %11,r1" "\n\t" /* %11 += HI(HI(f) * HI(t))*/
- " mov %5,%10" "\n\t" /* %6:%5 =*/
- " mov %6,%11" "\n\t" /* f = %10:%11*/
+ A("mul %5,%7") /* r1:r0 = LO(f) * LO(t)*/
+ A("mov %1,r1") /* store MIL(LO(f) * LO(t)) in %1, we need it for rounding*/
+ A("clr %10") /* %10 = 0*/
+ A("clr %11") /* %11 = 0*/
+ A("mul %5,%8") /* r1:r0 = LO(f) * HI(t)*/
+ A("add %1,r0") /* %1 += LO(LO(f) * HI(t))*/
+ A("adc %10,r1") /* %10 = HI(LO(f) * HI(t))*/
+ A("adc %11,%0") /* %11 += carry*/
+ A("mul %6,%7") /* r1:r0 = HI(f) * LO(t)*/
+ A("add %1,r0") /* %1 += LO(HI(f) * LO(t))*/
+ A("adc %10,r1") /* %10 += HI(HI(f) * LO(t))*/
+ A("adc %11,%0") /* %11 += carry*/
+ A("mul %6,%8") /* r1:r0 = HI(f) * HI(t)*/
+ A("add %10,r0") /* %10 += LO(HI(f) * HI(t))*/
+ A("adc %11,r1") /* %11 += HI(HI(f) * HI(t))*/
+ A("mov %5,%10") /* %6:%5 =*/
+ A("mov %6,%11") /* f = %10:%11*/
/* umul16x24to24hi(v, f, bezier_A); / Range 21bits [29]*/
/* acc += v; */
- " lds %10, bezier_A" "\n\t" /* %10 = LO(bezier_A)*/
- " mul %10,%5" "\n\t" /* r1:r0 = LO(bezier_A) * LO(f)*/
- " add %9,r1" "\n\t"
- " adc %2,%0" "\n\t"
- " adc %3,%0" "\n\t"
- " adc %4,%0" "\n\t" /* %4:%3:%2:%9 += HI(LO(bezier_A) * LO(f))*/
- " lds %11, bezier_A+1" "\n\t" /* %11 = MI(bezier_A)*/
- " mul %11,%5" "\n\t" /* r1:r0 = MI(bezier_A) * LO(f)*/
- " add %9,r0" "\n\t"
- " adc %2,r1" "\n\t"
- " adc %3,%0" "\n\t"
- " adc %4,%0" "\n\t" /* %4:%3:%2:%9 += MI(bezier_A) * LO(f)*/
- " lds %1, bezier_A+2" "\n\t" /* %1 = HI(bezier_A)*/
- " mul %1,%5" "\n\t" /* r1:r0 = MI(bezier_A) * LO(f)*/
- " add %2,r0" "\n\t"
- " adc %3,r1" "\n\t"
- " adc %4,%0" "\n\t" /* %4:%3:%2:%9 += HI(bezier_A) * LO(f) << 8*/
- " mul %10,%6" "\n\t" /* r1:r0 = LO(bezier_A) * MI(f)*/
- " add %9,r0" "\n\t"
- " adc %2,r1" "\n\t"
- " adc %3,%0" "\n\t"
- " adc %4,%0" "\n\t" /* %4:%3:%2:%9 += LO(bezier_A) * MI(f)*/
- " mul %11,%6" "\n\t" /* r1:r0 = MI(bezier_A) * MI(f)*/
- " add %2,r0" "\n\t"
- " adc %3,r1" "\n\t"
- " adc %4,%0" "\n\t" /* %4:%3:%2:%9 += MI(bezier_A) * MI(f) << 8*/
- " mul %1,%6" "\n\t" /* r1:r0 = HI(bezier_A) * LO(f)*/
- " add %3,r0" "\n\t"
- " adc %4,r1" "\n\t" /* %4:%3:%2:%9 += HI(bezier_A) * LO(f) << 16*/
- "2:" "\n\t"
+ A("lds %10, bezier_A") /* %10 = LO(bezier_A)*/
+ A("mul %10,%5") /* r1:r0 = LO(bezier_A) * LO(f)*/
+ A("add %9,r1")
+ A("adc %2,%0")
+ A("adc %3,%0")
+ A("adc %4,%0") /* %4:%3:%2:%9 += HI(LO(bezier_A) * LO(f))*/
+ A("lds %11, bezier_A+1") /* %11 = MI(bezier_A)*/
+ A("mul %11,%5") /* r1:r0 = MI(bezier_A) * LO(f)*/
+ A("add %9,r0")
+ A("adc %2,r1")
+ A("adc %3,%0")
+ A("adc %4,%0") /* %4:%3:%2:%9 += MI(bezier_A) * LO(f)*/
+ A("lds %1, bezier_A+2") /* %1 = HI(bezier_A)*/
+ A("mul %1,%5") /* r1:r0 = MI(bezier_A) * LO(f)*/
+ A("add %2,r0")
+ A("adc %3,r1")
+ A("adc %4,%0") /* %4:%3:%2:%9 += HI(bezier_A) * LO(f) << 8*/
+ A("mul %10,%6") /* r1:r0 = LO(bezier_A) * MI(f)*/
+ A("add %9,r0")
+ A("adc %2,r1")
+ A("adc %3,%0")
+ A("adc %4,%0") /* %4:%3:%2:%9 += LO(bezier_A) * MI(f)*/
+ A("mul %11,%6") /* r1:r0 = MI(bezier_A) * MI(f)*/
+ A("add %2,r0")
+ A("adc %3,r1")
+ A("adc %4,%0") /* %4:%3:%2:%9 += MI(bezier_A) * MI(f) << 8*/
+ A("mul %1,%6") /* r1:r0 = HI(bezier_A) * LO(f)*/
+ A("add %3,r0")
+ A("adc %4,r1") /* %4:%3:%2:%9 += HI(bezier_A) * LO(f) << 16*/
+ L("2")
" clr __zero_reg__" /* C runtime expects r1 = __zero_reg__ = 0 */
: "+r"(r0),
"+r"(r1),
@@ -1071,20 +1071,20 @@ void Stepper::set_directions() {
register int32_t C = bezier_C;
__asm__ __volatile__(
- ".syntax unified" "\n\t" // is to prevent CM0,CM1 non-unified syntax
- " lsrs %[ahi],%[alo],#1" "\n\t" // a = F << 31 1 cycles
- " lsls %[alo],%[alo],#31" "\n\t" // 1 cycles
- " umull %[flo],%[fhi],%[fhi],%[t]" "\n\t" // f *= t 5 cycles [fhi:flo=64bits]
- " umull %[flo],%[fhi],%[fhi],%[t]" "\n\t" // f>>=32; f*=t 5 cycles [fhi:flo=64bits]
- " lsrs %[flo],%[fhi],#1" "\n\t" // 1 cycles [31bits]
- " smlal %[alo],%[ahi],%[flo],%[C]" "\n\t" // a+=(f>>33)*C; 5 cycles
- " umull %[flo],%[fhi],%[fhi],%[t]" "\n\t" // f>>=32; f*=t 5 cycles [fhi:flo=64bits]
- " lsrs %[flo],%[fhi],#1" "\n\t" // 1 cycles [31bits]
- " smlal %[alo],%[ahi],%[flo],%[B]" "\n\t" // a+=(f>>33)*B; 5 cycles
- " umull %[flo],%[fhi],%[fhi],%[t]" "\n\t" // f>>=32; f*=t 5 cycles [fhi:flo=64bits]
- " lsrs %[flo],%[fhi],#1" "\n\t" // f>>=33; 1 cycles [31bits]
- " smlal %[alo],%[ahi],%[flo],%[A]" "\n\t" // a+=(f>>33)*A; 5 cycles
- " lsrs %[alo],%[ahi],#6" "\n\t" // a>>=38 1 cycles
+ ".syntax unified" "\n\t" // is to prevent CM0,CM1 non-unified syntax
+ A("lsrs %[ahi],%[alo],#1") // a = F << 31 1 cycles
+ A("lsls %[alo],%[alo],#31") // 1 cycles
+ A("umull %[flo],%[fhi],%[fhi],%[t]") // f *= t 5 cycles [fhi:flo=64bits]
+ A("umull %[flo],%[fhi],%[fhi],%[t]") // f>>=32; f*=t 5 cycles [fhi:flo=64bits]
+ A("lsrs %[flo],%[fhi],#1") // 1 cycles [31bits]
+ A("smlal %[alo],%[ahi],%[flo],%[C]") // a+=(f>>33)*C; 5 cycles
+ A("umull %[flo],%[fhi],%[fhi],%[t]") // f>>=32; f*=t 5 cycles [fhi:flo=64bits]
+ A("lsrs %[flo],%[fhi],#1") // 1 cycles [31bits]
+ A("smlal %[alo],%[ahi],%[flo],%[B]") // a+=(f>>33)*B; 5 cycles
+ A("umull %[flo],%[fhi],%[fhi],%[t]") // f>>=32; f*=t 5 cycles [fhi:flo=64bits]
+ A("lsrs %[flo],%[fhi],#1") // f>>=33; 1 cycles [31bits]
+ A("smlal %[alo],%[ahi],%[flo],%[A]") // a+=(f>>33)*A; 5 cycles
+ A("lsrs %[alo],%[ahi],#6") // a>>=38 1 cycles
: [alo]"+r"( alo ) ,
[flo]"+r"( flo ) ,
[fhi]"+r"( fhi ) ,