EasyThreeD X3 diff vs EasyThreeD X1

X3.diff

diff --git Marlin/Configuration.h Marlin/Configuration.h
index 949f021d6a..965a523e41 100644
--- Marlin/Configuration.h
+++ Marlin/Configuration.h
@@ -149,7 +149,7 @@ Here are some standard links for getting your machine calibrated:
 #define TEMP_SENSOR_1 0
 #define TEMP_SENSOR_2 0
 #define TEMP_SENSOR_3 0
-#define TEMP_SENSOR_BED 0
+#define TEMP_SENSOR_BED 1
 
 // This makes temp sensor 1 a redundant sensor for sensor 0. If the temperatures difference between these sensors is to high the print will be aborted.
 //#define TEMP_SENSOR_1_AS_REDUNDANT
@@ -176,7 +176,7 @@ Here are some standard links for getting your machine calibrated:
 #define HEATER_1_MAXTEMP 275
 #define HEATER_2_MAXTEMP 275
 #define HEATER_3_MAXTEMP 275
-#define BED_MAXTEMP 150
+#define BED_MAXTEMP 70
 
 // If your bed has low resistance e.g. .6 ohm and throws the fuse you can duty cycle it to reduce the
 // average current. The value should be an integer and the heat bed will be turned on for 1 interval of
@@ -399,9 +399,9 @@ const bool Z_MIN_PROBE_ENDSTOP_INVERTING = false; // set to true to invert the l
 #define X_MIN_POS 0
 #define Y_MIN_POS 0
 #define Z_MIN_POS 0
-#define X_MAX_POS 100
-#define Y_MAX_POS 100
-#define Z_MAX_POS 100
+#define X_MAX_POS 150
+#define Y_MAX_POS 150
+#define Z_MAX_POS 150
 
 //===========================================================================
 //========================= Filament Runout Sensor ==========================
@@ -598,9 +598,9 @@ const bool Z_MIN_PROBE_ENDSTOP_INVERTING = false; // set to true to invert the l
 #define DEFAULT_TRAVEL_ACCELERATION   300//3000    // X, Y, Z acceleration in mm/s^2 for travel (non printing) moves
 
 // The speed change that does not require acceleration (i.e. the software might assume it can be done instantaneously)
-#define DEFAULT_XYJERK               2       // (mm/sec)
+#define DEFAULT_XYJERK               2 //20.0    // (mm/sec)
 #define DEFAULT_ZJERK                0.4     // (mm/sec)
-#define DEFAULT_EJERK                1       // (mm/sec)
+#define DEFAULT_EJERK                1// 5.0    // (mm/sec)
 
 
 //=============================================================================
diff --git Marlin/Sd2Card.cpp Marlin/Sd2Card.cpp
index 22670671c8..64daaed788 100644
--- Marlin/Sd2Card.cpp
+++ Marlin/Sd2Card.cpp
@@ -25,7 +25,7 @@
 #include "Sd2Card.h"
 
 //------------------------------------------------------------------------------
-#if DISABLED(SOFTWARE_SPI)  //”≤º˛SPI
+#if DISABLED(SOFTWARE_SPI)  //”≤ÔøΩÔøΩSPI
   // functions for hardware SPI
   //------------------------------------------------------------------------------
   // make sure SPCR rate is in expected bits
@@ -36,14 +36,14 @@
    * Initialize hardware SPI
    * Set SCK rate to F_CPU/pow(2, 1 + spiRate) for spiRate [0,6]
    */
-  static void spiInit(uint8_t spiRate) { //SPI≈‰÷√≥ı ºªØ
+  static void spiInit(uint8_t spiRate) { //SPI���ó�ʼ��
     // See avr processor documentation
     SPCR = BIT(SPE) | BIT(MSTR) | (spiRate >> 1);
     SPSR = spiRate & 1 || spiRate == 6 ? 0 : BIT(SPI2X);
   }
   //------------------------------------------------------------------------------
   /** SPI receive a byte */
-  static uint8_t spiRec() { //SPI∂¡1∏ˆbyteµƒ ˝æ›
+  static uint8_t spiRec() { //SPIÔøΩÔøΩ1ÔøΩÔøΩbyteÔøΩÔøΩÔøΩÔøΩÔøΩÔøΩ
     SPDR = 0XFF;
     while (!TEST(SPSR, SPIF)) { /* Intentionally left empty */ }
     return SPDR;
@@ -51,7 +51,7 @@
   //------------------------------------------------------------------------------
   /** SPI read data - only one call so force inline */
   static inline __attribute__((always_inline))
-  void spiRead(uint8_t* buf, uint16_t nbyte) { //SPI∂¡nbyte∏ˆbyteµƒ ˝æ›
+  void spiRead(uint8_t* buf, uint16_t nbyte) { //SPIÔøΩÔøΩnbyteÔøΩÔøΩbyteÔøΩÔøΩÔøΩÔøΩÔøΩÔøΩ
     if (nbyte-- == 0) return;
     SPDR = 0XFF;
     for (uint16_t i = 0; i < nbyte; i++) {
@@ -64,7 +64,7 @@
   }
   //------------------------------------------------------------------------------
   /** SPI send a byte */
-  static void spiSend(uint8_t b) { //SPI–¥“ª∏ˆBYTEµƒ ˝æ›
+  static void spiSend(uint8_t b) { //SPIдһ��BYTE������
     SPDR = b;
     while (!TEST(SPSR, SPIF)) { /* Intentionally left empty */ }
   }
@@ -73,7 +73,7 @@
   //------------------------------------------------------------------------------
   /** SPI send block - only one call so force inline */
   static inline __attribute__((always_inline))
-  void spiSendBlock(uint8_t token, const uint8_t* buf) { //SPI¡¨–¯–¥513∏ˆ◊÷Ω⁄µƒ ˝æ›£¨µ⁄“ª∏ˆ ˝æ› «token,bud «∫Û512∏ˆ ˝æ›
+  void spiSendBlock(uint8_t token, const uint8_t* buf) { //SPI����д513���ֽڵ����ݣ���һ��������token,bud�Ǻ�512������
     SPDR = token;
     for (uint16_t i = 0; i < 512; i += 2) {
       while (!TEST(SPSR, SPIF)) { /* Intentionally left empty */ }
@@ -90,7 +90,7 @@
   #define nop asm volatile ("nop\n\t")
   //------------------------------------------------------------------------------
   /** Soft SPI receive byte */
-  static uint8_t spiRec() { //ƒ£ƒ‚SPIœ¬∂¡“ª∏ˆ◊÷Ω⁄µƒ ˝æ›
+  static uint8_t spiRec() { //ģ��SPI�¶�һ���ֽڵ�����
     uint8_t data = 0;
     // no interrupts during byte receive - about 8 us
     cli();
@@ -116,13 +116,13 @@
   }
   //------------------------------------------------------------------------------
   /** Soft SPI read data */
-  static void spiRead(uint8_t* buf, uint16_t nbyte) { //ƒ£ƒ‚SPIœ¬∂¡nbyte∏ˆ◊÷Ω⁄µƒ ˝æ›
+  static void spiRead(uint8_t* buf, uint16_t nbyte) { //ģ��SPI�¶�nbyte���ֽڵ�����
     for (uint16_t i = 0; i < nbyte; i++)
       buf[i] = spiRec();
   }
   //------------------------------------------------------------------------------
   /** Soft SPI send byte */
-  static void spiSend(uint8_t data) {  //ƒ£ƒ‚SPIœ¬–¥“ª∏ˆ◊÷Ω⁄µƒ ˝æ›
+  static void spiSend(uint8_t data) {  //ģ��SPI��дһ���ֽڵ�����
     // no interrupts during byte send - about 8 us
     cli();
     for (uint8_t i = 0; i < 8; i++) {
@@ -146,7 +146,7 @@
   }
   //------------------------------------------------------------------------------
   /** Soft SPI send block */
-  void spiSendBlock(uint8_t token, const uint8_t* buf) { //ƒ£ƒ‚SPIœ¬–¥513∏ˆ◊÷Ω⁄µƒ ˝æ›,µ⁄“ª∏ˆ ˝æ› «token£¨buf «∫Û512∏ˆ◊÷Ω⁄µƒ ˝æ›
+  void spiSendBlock(uint8_t token, const uint8_t* buf) { //ģ��SPI��д513���ֽڵ�����,��һ��������token��buf�Ǻ�512���ֽڵ�����
     spiSend(token);
     for (uint16_t i = 0; i < 512; i++)
       spiSend(buf[i]);
@@ -157,7 +157,7 @@
 
 //------------------------------------------------------------------------------
 // send command and return error code.  Return zero for OK
-uint8_t Sd2Card::cardCommand(uint8_t cmd, uint32_t arg) { //SDø®–¥√¸¡Ó∫Ø ˝
+uint8_t Sd2Card::cardCommand(uint8_t cmd, uint32_t arg) { //SD��д�����
   // select card
   chipSelectLow(); 
 
@@ -165,23 +165,23 @@ uint8_t Sd2Card::cardCommand(uint8_t cmd, uint32_t arg) { //SD
   waitNotBusy(300);
 
   // send command
-  spiSend(cmd | 0x40);  //√¸¡Ó÷µ
+  spiSend(cmd | 0x40);  //ÔøΩÔøΩÔøΩÔøΩ÷µ
 
   // send argument
-  for (int8_t s = 24; s >= 0; s -= 8) spiSend(arg >> s);  //√¸¡Ó≤Œ ˝
+  for (int8_t s = 24; s >= 0; s -= 8) spiSend(arg >> s);  //ÔøΩÔøΩÔøΩÔøΩÔøΩÔøΩÔøΩ
 
   // send CRC
   uint8_t crc = 0XFF;
   if (cmd == CMD0) crc = 0X95;  // correct crc for CMD0 with arg 0
   if (cmd == CMD8) crc = 0X87;  // correct crc for CMD8 with arg 0X1AA
-  spiSend(crc);  //CRC–£—È
+  spiSend(crc);  //CRC–£ÔøΩÔøΩ
 
   // skip stuff byte for stop read
-  if (cmd == CMD12) spiRec(); //»Áπ˚ «Õ£÷π∂‡Ã¨∂¡√¸¡Ó,‘ˆ∑¢ÀÕ8∏ˆ÷‹∆⁄ ±÷”
+  if (cmd == CMD12) spiRec(); //�����ֹͣ��̬������,������8������ʱ��
 
   // wait for response
   for (uint8_t i = 0; ((status_ = spiRec()) & 0X80) && i != 0XFF; i++) { /* Intentionally left empty */ }
-  return status_; //status_µƒ÷µ «0b:1xxxx xxxx
+  return status_; //status_ÔøΩÔøΩ÷µÔøΩÔøΩ0b:1xxxx xxxx
 }
 
 
@@ -192,7 +192,7 @@ uint8_t Sd2Card::cardCommand(uint8_t cmd, uint32_t arg) { //SD
  * \return The number of 512 byte data blocks in the card
  *         or zero if an error occurs.
  */
-uint32_t Sd2Card::cardSize() {  //∂¡blcokµƒ ˝¡ø£¨“ª∏ˆblock «512byte
+uint32_t Sd2Card::cardSize() {  //��blcok��������һ��block��512byte
   csd_t csd;
   if (!readCSD(&csd)) return 0; //
   if (csd.v1.csd_ver == 0) {
@@ -238,7 +238,7 @@ void Sd2Card::chipSelectLow() {
  * \return The value one, true, is returned for success and
  * the value zero, false, is returned for failure.
  */
-bool Sd2Card::erase(uint32_t firstBlock, uint32_t lastBlock) { //øÈ≤¡≥˝
+bool Sd2Card::erase(uint32_t firstBlock, uint32_t lastBlock) { //ÔøΩÔøΩÔøΩÔøΩÔøΩ
   csd_t csd;
   if (!readCSD(&csd)) goto fail;
   // check for single block erase
@@ -277,7 +277,7 @@ fail:
  * \return The value one, true, is returned if single block erase is supported.
  * The value zero, false, is returned if single block erase is not supported.
  */
-bool Sd2Card::eraseSingleBlockEnable() { //≤È—Ø «∑Ò‘ –ÌøÈ≤¡≥˝
+bool Sd2Card::eraseSingleBlockEnable() { //ÔøΩÔøΩ—ØÔøΩ«∑ÔøΩÔøΩÔøΩÔøΩÔøΩÔøΩÔøΩÔøΩÔøΩ
   csd_t csd;
   return readCSD(&csd) ? csd.v1.erase_blk_en : false;
 }
@@ -292,7 +292,7 @@ bool Sd2Card::eraseSingleBlockEnable() { //
  * the value zero, false, is returned for failure.  The reason for failure
  * can be determined by calling errorCode() and errorData().
  */
-bool Sd2Card::init(uint8_t sckRateID, uint8_t chipSelectPin) { //SDø®≥ı ºªØ≥ÖÚ
+bool Sd2Card::init(uint8_t sckRateID, uint8_t chipSelectPin) { //SDÔøΩÔøΩÔøΩÔøΩ ºÔøΩÔøΩÔøΩÔøΩÔøΩÔøΩ
   errorCode_ = type_ = 0;
   chipSelectPin_ = chipSelectPin;
   // 16-bit init start time allows over a minute
@@ -319,10 +319,10 @@ bool Sd2Card::init(uint8_t sckRateID, uint8_t chipSelectPin) { //SD
   #endif  // SOFTWARE_SPI
 
   // must supply min of 74 clock cycles with CS high.
-  for (uint8_t i = 0; i < 10; i++) spiSend(0XFF);  //∑¢ÀÕ¥Û”⁄74∏ˆSCLK ±÷”
+  for (uint8_t i = 0; i < 10; i++) spiSend(0XFF);  //ÔøΩÔøΩÔøΩÕ¥ÔøΩÔøΩÔøΩ74ÔøΩÔøΩSCLK ±ÔøΩÔøΩ
 
   // command to go idle in SPI mode
-  while ((status_ = cardCommand(CMD0, 0)) != R1_IDLE_STATE) {	//∑¢ÀÕ∏¥Œª√¸¡Ó
+  while ((status_ = cardCommand(CMD0, 0)) != R1_IDLE_STATE) {	//���͸�λ����
     if (((uint16_t)millis() - t0) > SD_INIT_TIMEOUT) {
       error(SD_CARD_ERROR_CMD0);
       goto fail;
@@ -382,7 +382,7 @@ fail:
  * \return The value one, true, is returned for success and
  * the value zero, false, is returned for failure.
  */
-bool Sd2Card::readBlock(uint32_t blockNumber, uint8_t* dst) {  //∂¡“ª∏ˆblockµƒ ˝æ›
+bool Sd2Card::readBlock(uint32_t blockNumber, uint8_t* dst) {  //��һ��block������
 #if ENABLED(SD_CHECK_AND_RETRY)
   uint8_t retryCnt = 3;
   // use address if not SDHC card
@@ -432,7 +432,7 @@ bool Sd2Card::readData(uint8_t* dst) {
 }
 
 #if ENABLED(SD_CHECK_AND_RETRY)
-static const uint16_t crctab[] PROGMEM = {   //CRC–£—ȱÌ
+static const uint16_t crctab[] PROGMEM = {   //CRC–£ÔøΩÔøΩÔøΩ
   0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50A5, 0x60C6, 0x70E7,
   0x8108, 0x9129, 0xA14A, 0xB16B, 0xC18C, 0xD1AD, 0xE1CE, 0xF1EF,
   0x1231, 0x0210, 0x3273, 0x2252, 0x52B5, 0x4294, 0x72F7, 0x62D6,
@@ -476,7 +476,7 @@ static uint16_t CRC_CCITT(const uint8_t* data, size_t n) {
 #endif
 
 //------------------------------------------------------------------------------
-bool Sd2Card::readData(uint8_t* dst, uint16_t count) { //∂¡count∏ˆ◊÷Ω⁄µƒ ˝æ›£¨±£¥Ê‘⁄dst÷–
+bool Sd2Card::readData(uint8_t* dst, uint16_t count) { //��count���ֽڵ����ݣ�������dst��
   // wait for start block token
   uint16_t t0 = millis();
   while ((status_ = spiRec()) == 0XFF) {
@@ -515,13 +515,13 @@ fail:
 }
 //------------------------------------------------------------------------------
 /** read CID or CSR register */
-bool Sd2Card::readRegister(uint8_t cmd, void* buf) {  //∂¡ºƒ¥Ê∆˜,cmd «√¸¡Ó÷µ,buf «∑µªÿ≤Œ ˝
+bool Sd2Card::readRegister(uint8_t cmd, void* buf) {  //���Ĵ���,cmd������ֵ,buf�Ƿ��ز���
   uint8_t* dst = reinterpret_cast<uint8_t*>(buf);
-  if (cardCommand(cmd, 0)) {  //–¥√¸¡Ó
+  if (cardCommand(cmd, 0)) {  //–¥ÔøΩÔøΩÔøΩÔøΩ
     error(SD_CARD_ERROR_READ_REG);
     goto fail;
   }
-  return readData(dst, 16); //∂¡16∏ˆ◊÷Ω⁄µƒ ˝æ›
+  return readData(dst, 16); //ÔøΩÔøΩ16ÔøΩÔøΩÔøΩ÷Ω⁄µÔøΩÔøΩÔøΩÔøΩÔøΩ
 fail:
   chipSelectHigh();
   return false;
@@ -540,7 +540,7 @@ fail:
 
 
 
-bool Sd2Card::readStart(uint32_t blockNumber) {  //¡¨–¯∂¡£¨÷™µ¿∑¢ÀÕcmd12≤≈Õ£÷π
+bool Sd2Card::readStart(uint32_t blockNumber) {  //ÔøΩÔøΩÔøΩÔøΩÔøΩÔøΩÔøΩÔøΩ÷™ÔøΩÔøΩÔøΩÔøΩÔøΩÔøΩcmd12ÔøΩÔøΩÕ£÷π
   if (type() != SD_CARD_TYPE_SDHC) blockNumber <<= 9;
   if (cardCommand(CMD18, blockNumber)) {
     error(SD_CARD_ERROR_CMD18);
@@ -558,7 +558,7 @@ fail:
 * \return The value one, true, is returned for success and
  * the value zero, false, is returned for failure.
  */
-bool Sd2Card::readStop() { //∂¡Õ£÷π,∑¢ÀÕµƒ «CMD12√¸¡Ó
+bool Sd2Card::readStop() { //ÔøΩÔøΩÕ£÷π,ÔøΩÔøΩÔøΩÕµÔøΩÔøΩÔøΩCMD12ÔøΩÔøΩÔøΩÔøΩ
   chipSelectLow();
   if (cardCommand(CMD12, 0)) {
     error(SD_CARD_ERROR_CMD12);
@@ -607,7 +607,7 @@ uint16_t count			/* Sector count (1..128) */
  * \return The value one, true, is returned for success and the value zero,
  * false, is returned for an invalid value of \a sckRateID.
  */
-bool Sd2Card::setSckRate(uint8_t sckRateID) { //…Ë÷√”≤º˛SPIµƒÀŸ∂»
+bool Sd2Card::setSckRate(uint8_t sckRateID) { //����Ӳ��SPI���ٶ�
   if (sckRateID > 6) {
     error(SD_CARD_ERROR_SCK_RATE);
     return false;
@@ -617,7 +617,7 @@ bool Sd2Card::setSckRate(uint8_t sckRateID) { //
 }
 //------------------------------------------------------------------------------
 // wait for card to go not busy
-bool Sd2Card::waitNotBusy(uint16_t timeoutMillis) {  //≤ªÕ£µƒ∂¡£¨»Áπ˚ªÿ∏¥ ˝æ›≤ª «0xff,±Ì æø’œ–
+bool Sd2Card::waitNotBusy(uint16_t timeoutMillis) {  //��ͣ�Ķ�������ظ����ݲ���0xff,��ʾ����
   uint16_t t0 = millis();
   while (spiRec() != 0XFF) {
     if (((uint16_t)millis() - t0) >= timeoutMillis) goto fail;
@@ -635,7 +635,7 @@ fail:
  * \return The value one, true, is returned for success and
  * the value zero, false, is returned for failure.
  */
-bool Sd2Card::writeBlock(uint32_t blockNumber, const uint8_t* src) {  //–¥“ª∏ˆbolcokµƒ ˝æ›
+bool Sd2Card::writeBlock(uint32_t blockNumber, const uint8_t* src) {  //дһ��bolcok������
   // use address if not SDHC card
   if (type() != SD_CARD_TYPE_SDHC) blockNumber <<= 9;
   if (cardCommand(CMD24, blockNumber)) {
@@ -708,7 +708,7 @@ fail:
  * \return The value one, true, is returned for success and
  * the value zero, false, is returned for failure.
  */
-bool Sd2Card::writeStart(uint32_t blockNumber, uint32_t eraseCount) { //∂‡øÈ¡¨–¯–¥ø™ º
+bool Sd2Card::writeStart(uint32_t blockNumber, uint32_t eraseCount) { //ÔøΩÔøΩÔøΩÔøΩÔøΩÔøΩÔøΩ–¥ÔøΩÔøΩ º
   // send pre-erase count
   if (cardAcmd(ACMD23, eraseCount)) {
     error(SD_CARD_ERROR_ACMD23);
@@ -732,7 +732,7 @@ fail:
 * \return The value one, true, is returned for success and
  * the value zero, false, is returned for failure.
  */
-bool Sd2Card::writeStop() {  //∂‡øÈ¡¨–¯–¥Ω· ¯
+bool Sd2Card::writeStop() {  //ÔøΩÔøΩÔøΩÔøΩÔøΩÔøΩÔøΩ–¥ÔøΩÔøΩÔøΩÔøΩ
   chipSelectLow();
   if (!waitNotBusy(SD_WRITE_TIMEOUT)) goto fail;
   spiSend(STOP_TRAN_TOKEN);
diff --git Marlin/blinkm.cpp Marlin/blinkm.cpp
index 5ad1edc200..bc0b8ab548 100644
--- Marlin/blinkm.cpp
+++ Marlin/blinkm.cpp
@@ -290,12 +290,12 @@ void retract_filament(void)
   if(IsRunning())
   {
       //  MYSERIAL.print("tui_liao");
-            destination[E_AXIS] += 14;
+            destination[E_AXIS] += 2;
           feedrate = 2*60;
           prepare_move();
 
-    destination[E_AXIS] -= 80;
-    feedrate =5*60;
+    destination[E_AXIS] -= 300;
+    feedrate =5.0*60;
     prepare_move();
   }
 }
@@ -355,7 +355,7 @@ void LoadFilament(void)
   }
   else if(filament_status == 3) //(4)按键的执行状态,等待加热
   {
-    if(current_temperature[0] >= 190) //等待温度加热到210度
+    if(current_temperature[0] >= 210) //等待温度加热到210度
     {
       filament_status++;
     }
@@ -428,7 +428,12 @@ void LoadFilament(void)
       filament_status = 0;
       key_flag = 0;
       key = 0;
+                key=0;
+          key_flag =0;
+          filament_status = 6;
+          setTargetHotend0(0);
     }
+
     if(!READ(RETRACT_PIN))
     {
       if(key==0x01) //已经在进料，再次进料则是停止进料
diff --git Marlin/pins_SANGUINOLOLU_11.h Marlin/pins_SANGUINOLOLU_11.h
index b8b210a081..054412554d 100644
--- Marlin/pins_SANGUINOLOLU_11.h
+++ Marlin/pins_SANGUINOLOLU_11.h
@@ -23,7 +23,7 @@
 
 
 /*
-#define PRINT_START_PIN    30        //ø™ º¥Ú”°º¸
+#define PRINT_START_PIN    30        //ÔøΩÔøΩ ºÔøΩÔøΩ”°ÔøΩÔøΩ
 #define PRINT_LED          17
 
 #define Z_HOME_PIN           29
@@ -35,7 +35,7 @@
 #define RETRACT_PIN        27
 #define RETRACT_LED        10 */
 
-#define PRINT_START_PIN    27        //ø™ º¥Ú”°º¸
+#define PRINT_START_PIN    27        //ÔøΩÔøΩ ºÔøΩÔøΩ”°ÔøΩÔøΩ
 #define PRINT_LED          10
 
 #define Z_HOME_PIN         30
diff --git Marlin/planner.cpp Marlin/planner.cpp
index e2dc2a9e50..3260ee97a4 100644
--- Marlin/planner.cpp
+++ Marlin/planner.cpp
@@ -547,9 +547,7 @@ float junction_deviation = 0.1;
   
   uint8_t dx_t = 0, dy_t = 0, dz_t = 0; 
   static uint8_t dx_p = 0, dy_p = 0, dz_p = 0; 
-  float x_dc = 0, y_dc = 0, z_dc = 0;
-
-  float x_offset = 0.001,y_offset = 0.001,z_offset = 0;
+  uint8_t x_offset = 0.02,y_offset = 0.02,z_offset = 0;
   
   #if ENABLED(COREXY)
   if (dx < 0) db |= BIT(X_HEAD); // Save the real Extruder (head) direction in X Axis
@@ -569,9 +567,9 @@ float junction_deviation = 0.1;
   if (dy < 0) {db |= BIT(Y_AXIS); dy_t = 1;}
   if (dz < 0) {db |= BIT(Z_AXIS); dz_t = 1;}
 
-  if(dx_t != dx_p){dx_p = dx_t; x_dc = 1;}
-  if(dy_t != dy_p){dy_p = dy_t; y_dc = 1;} 
-  if (dz_t != dz_p){dz_p = dz_t; z_dc = 1;} 
+  if(dx_t != dx_p){dx_p = dx_t; x_offset = 0;}
+  if(dy_t != dy_p){dy_p = dy_t; y_offset = 0;} 
+ // if(dz_t != dz_p){dz_p = dz_t; z_offset = 0;} 
   
   #endif
   if (de < 0) db |= BIT(E_AXIS);
@@ -594,9 +592,9 @@ float junction_deviation = 0.1;
     block->steps[C_AXIS] = labs(dx - dz);
   #else
     // default non-h-bot planning
-    block->steps[X_AXIS] = labs(dx) + lround(x_offset * x_dc * axis_steps_per_unit[X_AXIS]);
-    block->steps[Y_AXIS] = labs(dy) + lround(y_offset * y_dc * axis_steps_per_unit[Y_AXIS]);
-    block->steps[Z_AXIS] = labs(dz) + lround(z_offset * z_dc * axis_steps_per_unit[Z_AXIS]);
+    block->steps[X_AXIS] = labs(dx) + lround(x_offset * axis_steps_per_unit[X_AXIS]);
+    block->steps[Y_AXIS] = labs(dy) + lround(y_offset * axis_steps_per_unit[Y_AXIS]);
+    block->steps[Z_AXIS] = labs(dz) + lround(z_offset * axis_steps_per_unit[Z_AXIS]);
   #endif
 
   block->steps[E_AXIS] = labs(de);
diff --git Marlin/stepper.cpp Marlin/stepper.cpp
index eb0e21ce18..95815b471e 100644
--- Marlin/stepper.cpp
+++ Marlin/stepper.cpp
@@ -623,7 +623,7 @@ ISR(TIMER1_COMPA_vect) {
     return;
   }
 
-  if ((print_pause==1) && (current_block->steps[Z_AXIS]==0)) { //»Áπ˚¥Ú”°‘›Õ££¨≤ª∑¢¬ˆ≥Â
+  if((print_pause==1)&&(current_block->steps[Z_AXIS]==0)) { //ÔøΩÔøΩÔøΩÔøΩÔøΩ”°ÔøΩÔøΩÕ£ÔøΩÔøΩÔøΩÔøΩÔøΩÔøΩÔøΩÔøΩÔøΩÔøΩ
     //current_block->nominal_rate *= 0.3;
     acceleration_time  = 0;
     acc_step_rate = current_block->initial_rate;