microlab
/
scube
1
1
Fork 0
Code Issues Pull Requests Releases Activity

Merge pull request #10651 from thinkyhead/bf2_junction_deviation

Browse Source 
[2.0.x] Junction Deviation
2.0.x
Scott Lahteine 7 years ago committed by GitHub
parent d1b619be52 4c663b0216
commit 2cdaf76c40
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
60 changed files with 1457 additions and 973 deletions
Show Stats Download Patch File Download Diff File

2
.travis.yml
Unescape Escape View File

@ -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

9
Marlin/Configuration_adv.h
Unescape Escape View File

@ -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]

92
Marlin/src/HAL/HAL_AVR/math_AVR.h
Unescape Escape View File

@ -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) \
: \

130
Marlin/src/HAL/HAL_DUE/DebugMonitor_Due.cpp
Unescape Escape View File

@ -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")
);
}

286
Marlin/src/HAL/HAL_DUE/HAL_spi_Due.cpp
Unescape Escape View File

@ -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),

10
Marlin/src/HAL/HAL_DUE/u8g_com_HAL_DUE_st7920_sw_spi.cpp
Unescape Escape View File

@ -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:

2
Marlin/src/backtrace/unwarmbytab.cpp
Unescape Escape View File

@ -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) : :
);

9
Marlin/src/config/default/Configuration_adv.h
Unescape Escape View File

@ -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]

9
Marlin/src/config/examples/AlephObjects/TAZ4/Configuration_adv.h
Unescape Escape View File

@ -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]

9
Marlin/src/config/examples/Anet/A6/Configuration_adv.h
Unescape Escape View File

@ -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]

9
Marlin/src/config/examples/Anet/A8/Configuration_adv.h
Unescape Escape View File

@ -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]

9
Marlin/src/config/examples/Azteeg/X5GT/Configuration_adv.h
Unescape Escape View File

@ -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]

9
Marlin/src/config/examples/BIBO/TouchX/cyclops/Configuration_adv.h
Unescape Escape View File

@ -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]

9
Marlin/src/config/examples/BIBO/TouchX/default/Configuration_adv.h
Unescape Escape View File

@ -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]

9
Marlin/src/config/examples/BQ/Hephestos/Configuration_adv.h
Unescape Escape View File

@ -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]

9
Marlin/src/config/examples/BQ/Hephestos_2/Configuration_adv.h
Unescape Escape View File

@ -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]

9
Marlin/src/config/examples/BQ/WITBOX/Configuration_adv.h
Unescape Escape View File

@ -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]

9
Marlin/src/config/examples/Cartesio/Configuration_adv.h
Unescape Escape View File

@ -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]

9
Marlin/src/config/examples/Creality/CR-10/Configuration_adv.h
Unescape Escape View File

@ -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]

9
Marlin/src/config/examples/Creality/CR-10S/Configuration_adv.h
Unescape Escape View File

@ -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]

9
Marlin/src/config/examples/Creality/CR-10mini/Configuration_adv.h
Unescape Escape View File

@ -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]

9
Marlin/src/config/examples/Creality/CR-8/Configuration_adv.h
Unescape Escape View File

@ -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]

9
Marlin/src/config/examples/Creality/Ender-2/Configuration_adv.h
Unescape Escape View File

@ -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]

9
Marlin/src/config/examples/Creality/Ender-3/Configuration_adv.h
Unescape Escape View File

@ -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]

9
Marlin/src/config/examples/Creality/Ender-4/Configuration_adv.h
Unescape Escape View File

@ -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]

9
Marlin/src/config/examples/Felix/Configuration_adv.h
Unescape Escape View File

@ -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]

9
Marlin/src/config/examples/FolgerTech/i3-2020/Configuration_adv.h
Unescape Escape View File

@ -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]

9
Marlin/src/config/examples/Geeetech/Prusa i3 Pro C/Configuration_adv.h
Unescape Escape View File

@ -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]

9
Marlin/src/config/examples/Geeetech/Prusa i3 Pro W/Configuration_adv.h
Unescape Escape View File

@ -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]

9
Marlin/src/config/examples/Infitary/i3-M508/Configuration_adv.h
Unescape Escape View File

@ -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]

9
Marlin/src/config/examples/JGAurora/A5/Configuration_adv.h
Unescape Escape View File

@ -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]

9
Marlin/src/config/examples/MakerParts/Configuration_adv.h
Unescape Escape View File

@ -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]

9
Marlin/src/config/examples/Malyan/M150/Configuration_adv.h
Unescape Escape View File

@ -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]

9
Marlin/src/config/examples/Malyan/M200/Configuration_adv.h
Unescape Escape View File

@ -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]

9
Marlin/src/config/examples/Micromake/C1/enhanced/Configuration_adv.h
Unescape Escape View File

@ -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]

9
Marlin/src/config/examples/Mks/Sbase/Configuration_adv.h
Unescape Escape View File

@ -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]

9
Marlin/src/config/examples/RigidBot/Configuration_adv.h
Unescape Escape View File

@ -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]

9
Marlin/src/config/examples/SCARA/Configuration_adv.h
Unescape Escape View File

@ -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]

9
Marlin/src/config/examples/Sanguinololu/Configuration_adv.h
Unescape Escape View File

@ -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]

9
Marlin/src/config/examples/TheBorg/Configuration_adv.h
Unescape Escape View File

@ -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]

9
Marlin/src/config/examples/TinyBoy2/Configuration_adv.h
Unescape Escape View File

@ -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]

9
Marlin/src/config/examples/UltiMachine/Archim2/Configuration_adv.h
Unescape Escape View File

@ -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]

9
Marlin/src/config/examples/Velleman/K8200/Configuration_adv.h
Unescape Escape View File

@ -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]

9
Marlin/src/config/examples/Velleman/K8400/Configuration_adv.h
Unescape Escape View File

@ -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]

9
Marlin/src/config/examples/Wanhao/Duplicator 6/Configuration_adv.h
Unescape Escape View File

@ -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]

9
Marlin/src/config/examples/delta/FLSUN/auto_calibrate/Configuration_adv.h
Unescape Escape View File

@ -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]

9
Marlin/src/config/examples/delta/FLSUN/kossel/Configuration_adv.h
Unescape Escape View File

@ -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]

9
Marlin/src/config/examples/delta/FLSUN/kossel_mini/Configuration_adv.h
Unescape Escape View File

@ -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]

9
Marlin/src/config/examples/delta/generic/Configuration_adv.h
Unescape Escape View File

@ -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]

9
Marlin/src/config/examples/delta/kossel_mini/Configuration_adv.h
Unescape Escape View File

@ -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]

9
Marlin/src/config/examples/delta/kossel_pro/Configuration_adv.h
Unescape Escape View File

@ -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]

9
Marlin/src/config/examples/delta/kossel_xl/Configuration_adv.h
Unescape Escape View File

@ -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]

9
Marlin/src/config/examples/gCreate/gMax1.5+/Configuration_adv.h
Unescape Escape View File

@ -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]

9
Marlin/src/config/examples/makibox/Configuration_adv.h
Unescape Escape View File

@ -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]

9
Marlin/src/config/examples/tvrrug/Round2/Configuration_adv.h
Unescape Escape View File

@ -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]

9
Marlin/src/config/examples/wt150/Configuration_adv.h
Unescape Escape View File

@ -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]

3
Marlin/src/core/macros.h
Unescape Escape View File

@ -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))

2
Marlin/src/libs/softspi.h
Unescape Escape View File

@ -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;

571
Marlin/src/module/planner.cpp
Unescape Escape View File

@ -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,57 +1864,86 @@ void Planner::_buffer_steps(const int32_t (&target)[XYZE]
}
#endif
// Initial limit on the segment entry velocity
float vmax_junction;
float vmax_junction; // Initial limit on the segment entry velocity
#if 0 // Use old jerk for now
#if ENABLED(JUNCTION_DEVIATION)
float junction_deviation = 0.1;
/**
* 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.
*/
// 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]
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];
// 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)));
-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;
COPY(previous_unit_vec, unit_vec);
#else // Classic Jerk Limiting
/**
* Adapted from Průša MKS firmware
@ -1988,6 +2017,9 @@ void Planner::_buffer_steps(const int32_t (&target)[XYZE]
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;

752
Marlin/src/module/stepper.cpp
Unescape Escape View File

@ -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),
@ -1072,19 +1072,19 @@ void Stepper::set_directions() {
__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
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 ) ,

Write Preview
Loading…
Cancel
Save