The-Legend-of-Delta/Repetier Firmware/Repetier/Printer.h
2019-08-07 14:27:54 +02:00

875 lines
27 KiB
C++

/*
This file is part of Repetier-Firmware.
Repetier-Firmware is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
Repetier-Firmware is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with Repetier-Firmware. If not, see <http://www.gnu.org/licenses/>.
This firmware is a nearly complete rewrite of the sprinter firmware
by kliment (https://github.com/kliment/Sprinter)
which based on Tonokip RepRap firmware rewrite based off of Hydra-mmm firmware.
*/
/**
Coordinate system transformations:
Level 1: G-code => Coordinates like send via g-codes.
Level 2: Real coordinates => Coordinates corrected by coordinate shift via G92
currentPosition and lastCmdPos are from this level.
Level 3: Transformed and shifter => Include extruder offset and bed rotation.
These variables are only stored temporary.
Level 4: Step position => Level 3 converted into steps for motor position
currentPositionSteps and destinationPositionSteps are from this level.
Level 5: Nonlinear motor step position, only for nonlinear drive systems
destinationDeltaSteps
*/
#ifndef PRINTER_H_INCLUDED
#define PRINTER_H_INCLUDED
union floatLong
{
float f;
uint32_t l;
#ifdef SUPPORT_64_BIT_MATH
uint64_t L;
#endif
};
union wizardVar {
float f;
int32_t l;
uint32_t ul;
int16_t i;
uint16_t ui;
int8_t c;
uint8_t uc;
wizardVar():i(0) {}
wizardVar(float _f):f(_f) {}
wizardVar(int32_t _f):l(_f) {}
wizardVar(uint32_t _f):ul(_f) {}
wizardVar(int16_t _f):i(_f) {}
wizardVar(uint16_t _f):ui(_f) {}
wizardVar(int8_t _f):c(_f) {}
wizardVar(uint8_t _f):uc(_f) {}
};
#define PRINTER_FLAG0_STEPPER_DISABLED 1
#define PRINTER_FLAG0_SEPERATE_EXTRUDER_INT 2
#define PRINTER_FLAG0_TEMPSENSOR_DEFECT 4
#define PRINTER_FLAG0_FORCE_CHECKSUM 8
#define PRINTER_FLAG0_MANUAL_MOVE_MODE 16
#define PRINTER_FLAG0_AUTOLEVEL_ACTIVE 32
#define PRINTER_FLAG0_ZPROBEING 64
#define PRINTER_FLAG0_LARGE_MACHINE 128
#define PRINTER_FLAG1_HOMED 1
#define PRINTER_FLAG1_AUTOMOUNT 2
#define PRINTER_FLAG1_ANIMATION 4
#define PRINTER_FLAG1_ALLKILLED 8
#define PRINTER_FLAG1_UI_ERROR_MESSAGE 16
#define PRINTER_FLAG1_NO_DESTINATION_CHECK 32
#define PRINTER_FLAG1_POWER_ON 64
#define PRINTER_FLAG1_ALLOW_COLD_EXTRUSION 128
#define PRINTER_FLAG2_BLOCK_RECEIVING 1
#define PRINTER_FLAG2_AUTORETRACT 2
// define an integer number of steps more than large enough to get to endstop from anywhere
#define HOME_DISTANCE_STEPS (Printer::zMaxSteps-Printer::zMinSteps+1000)
#define HOME_DISTANCE_MM (HOME_DISTANCE_STEPS * invAxisStepsPerMM[Z_AXIS])
// Some dfines to make clearer reading, as we overload these cartesion memory locations for delta
#define towerAMaxSteps Printer::xMaxSteps
#define towerBMaxSteps Printer::yMaxSteps
#define towerCMaxSteps Printer::zMaxSteps
#define towerAMinSteps Printer::xMinSteps
#define towerBMinSteps Printer::yMinSteps
#define towerCMinSteps Printer::zMinSteps
#if DISTORTION_CORRECTION
class Distortion
{
public:
Distortion();
void init();
void enable(bool permanent = true);
void disable(bool permanent = true);
void measure(void);
int32_t correct(int32_t x, int32_t y, int32_t z) const;
void updateDerived();
void reportStatus();
private:
inline int matrixIndex(fast8_t x, fast8_t y) const;
inline int32_t getMatrix(int index) const;
inline void setMatrix(int32_t val, int index);
bool isCorner(fast8_t i, fast8_t j) const;
inline int32_t extrapolatePoint(fast8_t x1, fast8_t y1, fast8_t x2, fast8_t y2) const;
void extrapolateCorner(fast8_t x, fast8_t y, fast8_t dx, fast8_t dy);
void extrapolateCorners();
void resetCorrection();
// attributes
int32_t step;
int32_t radiusCorrectionSteps;
int32_t zStart,zEnd;
#if !DISTORTION_PERMANENT
int32_t matrix[DISTORTION_CORRECTION_POINTS * DISTORTION_CORRECTION_POINTS];
#endif
bool enabled;
};
#endif //DISTORTION_CORRECTION
class Printer
{
public:
#if USE_ADVANCE
static volatile int extruderStepsNeeded; ///< This many extruder steps are still needed, <0 = reverse steps needed.
static uint8_t minExtruderSpeed; ///< Timer delay for start extruder speed
static uint8_t maxExtruderSpeed; ///< Timer delay for end extruder speed
//static uint8_t extruderAccelerateDelay; ///< delay between 2 speec increases
static int advanceStepsSet;
#if ENABLE_QUADRATIC_ADVANCE
static long advanceExecuted; ///< Executed advance steps
#endif
#endif
static uint8_t menuMode;
static float axisStepsPerMM[];
static float invAxisStepsPerMM[];
static float maxFeedrate[];
static float homingFeedrate[];
static float maxAccelerationMMPerSquareSecond[];
static float maxTravelAccelerationMMPerSquareSecond[];
static unsigned long maxPrintAccelerationStepsPerSquareSecond[];
static unsigned long maxTravelAccelerationStepsPerSquareSecond[];
static uint8_t relativeCoordinateMode; ///< Determines absolute (false) or relative Coordinates (true).
static uint8_t relativeExtruderCoordinateMode; ///< Determines Absolute or Relative E Codes while in Absolute Coordinates mode. E is always relative in Relative Coordinates mode.
static uint8_t unitIsInches;
static uint8_t debugLevel;
static uint8_t flag0,flag1; // 1 = stepper disabled, 2 = use external extruder interrupt, 4 = temp Sensor defect, 8 = homed
static uint8_t flag2;
static uint8_t stepsPerTimerCall;
static uint32_t interval; ///< Last step duration in ticks.
static uint32_t timer; ///< used for acceleration/deceleration timing
static uint32_t stepNumber; ///< Step number in current move.
static float coordinateOffset[Z_AXIS_ARRAY];
static int32_t currentPositionSteps[E_AXIS_ARRAY]; ///< Position in steps from origin.
static float currentPosition[Z_AXIS_ARRAY];
static float lastCmdPos[Z_AXIS_ARRAY]; ///< Last coordinates send by gcodes
static int32_t destinationSteps[E_AXIS_ARRAY]; ///< Target position in steps.
static float extrudeMultiplyError; ///< Accumulated error during extrusion
static float extrusionFactor; ///< Extrusion multiply factor
#if NONLINEAR_SYSTEM
static int32_t maxDeltaPositionSteps;
static int32_t currentDeltaPositionSteps[E_TOWER_ARRAY];
static floatLong deltaDiagonalStepsSquaredA;
static floatLong deltaDiagonalStepsSquaredB;
static floatLong deltaDiagonalStepsSquaredC;
static float deltaMaxRadiusSquared;
static int32_t deltaFloorSafetyMarginSteps;
static int32_t deltaAPosXSteps;
static int32_t deltaAPosYSteps;
static int32_t deltaBPosXSteps;
static int32_t deltaBPosYSteps;
static int32_t deltaCPosXSteps;
static int32_t deltaCPosYSteps;
static int32_t realDeltaPositionSteps[TOWER_ARRAY];
static int16_t travelMovesPerSecond;
static int16_t printMovesPerSecond;
static float radius0;
#endif
#if FEATURE_Z_PROBE || MAX_HARDWARE_ENDSTOP_Z || NONLINEAR_SYSTEM
static int32_t stepsRemainingAtZHit;
#endif
#if DRIVE_SYSTEM==DELTA
static int32_t stepsRemainingAtXHit;
static int32_t stepsRemainingAtYHit;
#endif
#if SOFTWARE_LEVELING
static int32_t levelingP1[3];
static int32_t levelingP2[3];
static int32_t levelingP3[3];
#endif
#if FEATURE_AUTOLEVEL
static float autolevelTransformation[9]; ///< Transformation matrix
#endif
static signed char zBabystepsMissing;
static float minimumSpeed; ///< lowest allowed speed to keep integration error small
static float minimumZSpeed; ///< lowest allowed speed to keep integration error small
static int32_t xMaxSteps; ///< For software endstops, limit of move in positive direction.
static int32_t yMaxSteps; ///< For software endstops, limit of move in positive direction.
static int32_t zMaxSteps; ///< For software endstops, limit of move in positive direction.
static int32_t xMinSteps; ///< For software endstops, limit of move in negative direction.
static int32_t yMinSteps; ///< For software endstops, limit of move in negative direction.
static int32_t zMinSteps; ///< For software endstops, limit of move in negative direction.
static float xLength;
static float xMin;
static float yLength;
static float yMin;
static float zLength;
static float zMin;
static float feedrate; ///< Last requested feedrate.
static int feedrateMultiply; ///< Multiplier for feedrate in percent (factor 1 = 100)
static unsigned int extrudeMultiply; ///< Flow multiplier in percdent (factor 1 = 100)
static float maxJerk; ///< Maximum allowed jerk in mm/s
#if DRIVE_SYSTEM!=DELTA
static float maxZJerk; ///< Maximum allowed jerk in z direction in mm/s
#endif
static float offsetX; ///< X-offset for different extruder positions.
static float offsetY; ///< Y-offset for different extruder positions.
static speed_t vMaxReached; ///< Maximumu reached speed
static uint32_t msecondsPrinting; ///< Milliseconds of printing time (means time with heated extruder)
static float filamentPrinted; ///< mm of filament printed since counting started
static uint8_t wasLastHalfstepping; ///< Indicates if last move had halfstepping enabled
#if ENABLE_BACKLASH_COMPENSATION
static float backlashX;
static float backlashY;
static float backlashZ;
static uint8_t backlashDir;
#endif
#ifdef DEBUG_STEPCOUNT
static long totalStepsRemaining;
#endif
static float memoryX;
static float memoryY;
static float memoryZ;
static float memoryE;
static float memoryF;
#if GANTRY
static int8_t motorX;
static int8_t motorYorZ;
#endif
#ifdef DEBUG_SEGMENT_LENGTH
static float maxRealSegmentLength;
#endif
#ifdef DEBUG_REAL_JERK
static float maxRealJerk;
#endif
static fast8_t wizardStackPos;
static wizardVar wizardStack[WIZARD_STACK_SIZE];
static inline void setMenuMode(uint8_t mode,bool on)
{
if(on)
menuMode |= mode;
else
menuMode &= ~mode;
}
static inline bool isMenuMode(uint8_t mode)
{
return (menuMode & mode)==mode;
}
static inline bool debugEcho()
{
return ((debugLevel & 1)!=0);
}
static inline bool debugInfo()
{
return ((debugLevel & 2)!=0);
}
static inline bool debugErrors()
{
return ((debugLevel & 4)!=0);
}
static inline bool debugDryrun()
{
return ((debugLevel & 8)!=0);
}
static inline bool debugCommunication()
{
return ((debugLevel & 16)!=0);
}
static inline bool debugNoMoves()
{
return ((debugLevel & 32)!=0);
}
static inline bool debugFlag(unsigned long flags)
{
return (debugLevel & flags);
}
static inline void debugSet(unsigned long flags)
{
debugLevel |= flags;
}
static inline void debugReset(unsigned long flags)
{
debugLevel &= ~flags;
}
/** \brief Disable stepper motor for x direction. */
static inline void disableXStepper()
{
#if (X_ENABLE_PIN > -1)
WRITE(X_ENABLE_PIN,!X_ENABLE_ON);
#endif
#if FEATURE_TWO_XSTEPPER && (X2_ENABLE_PIN > -1)
WRITE(X2_ENABLE_PIN,!X_ENABLE_ON);
#endif
}
/** \brief Disable stepper motor for y direction. */
static inline void disableYStepper()
{
#if (Y_ENABLE_PIN > -1)
WRITE(Y_ENABLE_PIN,!Y_ENABLE_ON);
#endif
#if FEATURE_TWO_YSTEPPER && (Y2_ENABLE_PIN > -1)
WRITE(Y2_ENABLE_PIN,!Y_ENABLE_ON);
#endif
}
/** \brief Disable stepper motor for z direction. */
static inline void disableZStepper()
{
#if (Z_ENABLE_PIN > -1)
WRITE(Z_ENABLE_PIN,!Z_ENABLE_ON);
#endif
#if FEATURE_TWO_ZSTEPPER && (Z2_ENABLE_PIN > -1)
WRITE(Z2_ENABLE_PIN,!Z_ENABLE_ON);
#endif
}
/** \brief Enable stepper motor for x direction. */
static inline void enableXStepper()
{
#if (X_ENABLE_PIN > -1)
WRITE(X_ENABLE_PIN, X_ENABLE_ON);
#endif
#if FEATURE_TWO_XSTEPPER && (X2_ENABLE_PIN > -1)
WRITE(X2_ENABLE_PIN,X_ENABLE_ON);
#endif
}
/** \brief Enable stepper motor for y direction. */
static inline void enableYStepper()
{
#if (Y_ENABLE_PIN > -1)
WRITE(Y_ENABLE_PIN, Y_ENABLE_ON);
#endif
#if FEATURE_TWO_YSTEPPER && (Y2_ENABLE_PIN > -1)
WRITE(Y2_ENABLE_PIN,Y_ENABLE_ON);
#endif
}
/** \brief Enable stepper motor for z direction. */
static inline void enableZStepper()
{
#if (Z_ENABLE_PIN > -1)
WRITE(Z_ENABLE_PIN, Z_ENABLE_ON);
#endif
#if FEATURE_TWO_ZSTEPPER && (Z2_ENABLE_PIN > -1)
WRITE(Z2_ENABLE_PIN,Z_ENABLE_ON);
#endif
}
static inline void setXDirection(bool positive)
{
if(positive)
{
WRITE(X_DIR_PIN,!INVERT_X_DIR);
#if FEATURE_TWO_XSTEPPER
WRITE(X2_DIR_PIN,!INVERT_X_DIR);
#endif
}
else
{
WRITE(X_DIR_PIN,INVERT_X_DIR);
#if FEATURE_TWO_XSTEPPER
WRITE(X2_DIR_PIN,INVERT_X_DIR);
#endif
}
}
static inline void setYDirection(bool positive)
{
if(positive)
{
WRITE(Y_DIR_PIN,!INVERT_Y_DIR);
#if FEATURE_TWO_YSTEPPER
WRITE(Y2_DIR_PIN,!INVERT_Y_DIR);
#endif
}
else
{
WRITE(Y_DIR_PIN,INVERT_Y_DIR);
#if FEATURE_TWO_YSTEPPER
WRITE(Y2_DIR_PIN,INVERT_Y_DIR);
#endif
}
}
static inline void setZDirection(bool positive)
{
if(positive)
{
WRITE(Z_DIR_PIN,!INVERT_Z_DIR);
#if FEATURE_TWO_ZSTEPPER
WRITE(Z2_DIR_PIN,!INVERT_Z_DIR);
#endif
}
else
{
WRITE(Z_DIR_PIN,INVERT_Z_DIR);
#if FEATURE_TWO_ZSTEPPER
WRITE(Z2_DIR_PIN,INVERT_Z_DIR);
#endif
}
}
static inline bool getZDirection()
{
return ((READ(Z_DIR_PIN)!=0) ^ INVERT_Z_DIR);
}
static inline bool getYDirection()
{
return((READ(Y_DIR_PIN)!=0) ^ INVERT_Y_DIR);
}
static inline bool getXDirection()
{
return((READ(X_DIR_PIN)!=0) ^ INVERT_X_DIR);
}
static inline uint8_t isLargeMachine()
{
return flag0 & PRINTER_FLAG0_LARGE_MACHINE;
}
static inline void setLargeMachine(uint8_t b)
{
flag0 = (b ? flag0 | PRINTER_FLAG0_LARGE_MACHINE : flag0 & ~PRINTER_FLAG0_LARGE_MACHINE);
}
static inline uint8_t isAdvanceActivated()
{
return flag0 & PRINTER_FLAG0_SEPERATE_EXTRUDER_INT;
}
static inline void setAdvanceActivated(uint8_t b)
{
flag0 = (b ? flag0 | PRINTER_FLAG0_SEPERATE_EXTRUDER_INT : flag0 & ~PRINTER_FLAG0_SEPERATE_EXTRUDER_INT);
}
static inline uint8_t isHomed()
{
return flag1 & PRINTER_FLAG1_HOMED;
}
static inline void setHomed(uint8_t b)
{
flag1 = (b ? flag1 | PRINTER_FLAG1_HOMED : flag1 & ~PRINTER_FLAG1_HOMED);
}
static inline uint8_t isAllKilled()
{
return flag1 & PRINTER_FLAG1_ALLKILLED;
}
static inline void setAllKilled(uint8_t b)
{
flag1 = (b ? flag1 | PRINTER_FLAG1_ALLKILLED : flag1 & ~PRINTER_FLAG1_ALLKILLED);
}
static inline uint8_t isAutomount()
{
return flag1 & PRINTER_FLAG1_AUTOMOUNT;
}
static inline void setAutomount(uint8_t b)
{
flag1 = (b ? flag1 | PRINTER_FLAG1_AUTOMOUNT : flag1 & ~PRINTER_FLAG1_AUTOMOUNT);
}
static inline uint8_t isAnimation()
{
return flag1 & PRINTER_FLAG1_ANIMATION;
}
static inline void setAnimation(uint8_t b)
{
flag1 = (b ? flag1 | PRINTER_FLAG1_ANIMATION : flag1 & ~PRINTER_FLAG1_ANIMATION);
}
static inline uint8_t isUIErrorMessage()
{
return flag1 & PRINTER_FLAG1_UI_ERROR_MESSAGE;
}
static inline void setUIErrorMessage(uint8_t b)
{
flag1 = (b ? flag1 | PRINTER_FLAG1_UI_ERROR_MESSAGE : flag1 & ~PRINTER_FLAG1_UI_ERROR_MESSAGE);
}
static inline uint8_t isNoDestinationCheck()
{
return flag1 & PRINTER_FLAG1_NO_DESTINATION_CHECK;
}
static inline void setNoDestinationCheck(uint8_t b)
{
flag1 = (b ? flag1 | PRINTER_FLAG1_NO_DESTINATION_CHECK : flag1 & ~PRINTER_FLAG1_NO_DESTINATION_CHECK);
}
static inline uint8_t isPowerOn()
{
return flag1 & PRINTER_FLAG1_POWER_ON;
}
static inline void setPowerOn(uint8_t b)
{
flag1 = (b ? flag1 | PRINTER_FLAG1_POWER_ON : flag1 & ~PRINTER_FLAG1_POWER_ON);
}
static inline uint8_t isColdExtrusionAllowed()
{
return flag1 & PRINTER_FLAG1_ALLOW_COLD_EXTRUSION;
}
static inline void setColdExtrusionAllowed(uint8_t b)
{
flag1 = (b ? flag1 | PRINTER_FLAG1_ALLOW_COLD_EXTRUSION : flag1 & ~PRINTER_FLAG1_ALLOW_COLD_EXTRUSION);
if(b)
Com::printFLN(PSTR("Cold extrusion allowed"));
else
Com::printFLN(PSTR("Cold extrusion disallowed"));
}
static inline uint8_t isBlockingReceive()
{
return flag2 & PRINTER_FLAG2_BLOCK_RECEIVING;
}
static inline void setBlockingReceive(uint8_t b)
{
flag2 = (b ? flag2 | PRINTER_FLAG2_BLOCK_RECEIVING : flag2 & ~PRINTER_FLAG2_BLOCK_RECEIVING);
}
static inline uint8_t isAutoretract()
{
return flag2 & PRINTER_FLAG2_AUTORETRACT;
}
static inline void setAutoretract(uint8_t b)
{
flag2 = (b ? flag2 | PRINTER_FLAG2_AUTORETRACT : flag2 & ~PRINTER_FLAG2_AUTORETRACT);
Com::printFLN(PSTR("Autoretract:"),b);
}
static inline void toggleAnimation()
{
setAnimation(!isAnimation());
}
static inline float convertToMM(float x)
{
return (unitIsInches ? x*25.4 : x);
}
static inline bool isXMinEndstopHit()
{
#if X_MIN_PIN>-1 && MIN_HARDWARE_ENDSTOP_X
return READ(X_MIN_PIN) != ENDSTOP_X_MIN_INVERTING;
#else
return false;
#endif
}
static inline bool isYMinEndstopHit()
{
#if Y_MIN_PIN>-1 && MIN_HARDWARE_ENDSTOP_Y
return READ(Y_MIN_PIN) != ENDSTOP_Y_MIN_INVERTING;
#else
return false;
#endif
}
static inline bool isZMinEndstopHit()
{
#if Z_MIN_PIN>-1 && MIN_HARDWARE_ENDSTOP_Z
return READ(Z_MIN_PIN) != ENDSTOP_Z_MIN_INVERTING;
#else
return false;
#endif
}
static inline bool isXMaxEndstopHit()
{
#if X_MAX_PIN>-1 && MAX_HARDWARE_ENDSTOP_X
return READ(X_MAX_PIN) != ENDSTOP_X_MAX_INVERTING;
#else
return false;
#endif
}
static inline bool isYMaxEndstopHit()
{
#if Y_MAX_PIN>-1 && MAX_HARDWARE_ENDSTOP_Y
return READ(Y_MAX_PIN) != ENDSTOP_Y_MAX_INVERTING;
#else
return false;
#endif
}
static inline bool isZMaxEndstopHit()
{
#if Z_MAX_PIN>-1 && MAX_HARDWARE_ENDSTOP_Z
return READ(Z_MAX_PIN) != ENDSTOP_Z_MAX_INVERTING;
#else
return false;
#endif
}
static inline bool areAllSteppersDisabled()
{
return flag0 & PRINTER_FLAG0_STEPPER_DISABLED;
}
static inline void setAllSteppersDiabled()
{
flag0 |= PRINTER_FLAG0_STEPPER_DISABLED;
}
static inline void unsetAllSteppersDisabled()
{
flag0 &= ~PRINTER_FLAG0_STEPPER_DISABLED;
#if FAN_BOARD_PIN>-1
pwm_pos[NUM_EXTRUDER + 1] = 255;
#endif // FAN_BOARD_PIN
}
static inline bool isAnyTempsensorDefect()
{
return (flag0 & PRINTER_FLAG0_TEMPSENSOR_DEFECT);
}
static inline void setAnyTempsensorDefect()
{
flag0 |= PRINTER_FLAG0_TEMPSENSOR_DEFECT;
}
static inline bool isManualMoveMode()
{
return (flag0 & PRINTER_FLAG0_MANUAL_MOVE_MODE);
}
static inline void setManualMoveMode(bool on)
{
flag0 = (on ? flag0 | PRINTER_FLAG0_MANUAL_MOVE_MODE : flag0 & ~PRINTER_FLAG0_MANUAL_MOVE_MODE);
}
static inline bool isAutolevelActive()
{
return (flag0 & PRINTER_FLAG0_AUTOLEVEL_ACTIVE)!=0;
}
static void setAutolevelActive(bool on);
static inline void setZProbingActive(bool on)
{
flag0 = (on ? flag0 | PRINTER_FLAG0_ZPROBEING : flag0 & ~PRINTER_FLAG0_ZPROBEING);
}
static inline bool isZProbingActive()
{
return (flag0 & PRINTER_FLAG0_ZPROBEING);
}
static inline bool isZProbeHit()
{
#if FEATURE_Z_PROBE
return (Z_PROBE_ON_HIGH ? READ(Z_PROBE_PIN) : !READ(Z_PROBE_PIN));
#else
return false;
#endif
}
static inline void executeXYGantrySteps()
{
#if (GANTRY)
if(motorX <= -2)
{
WRITE(X_STEP_PIN,HIGH);
#if FEATURE_TWO_XSTEPPER
WRITE(X2_STEP_PIN,HIGH);
#endif
motorX += 2;
}
else if(motorX >= 2)
{
WRITE(X_STEP_PIN,HIGH);
#if FEATURE_TWO_XSTEPPER
WRITE(X2_STEP_PIN,HIGH);
#endif
motorX -= 2;
}
if(motorYorZ <= -2)
{
WRITE(Y_STEP_PIN,HIGH);
#if FEATURE_TWO_YSTEPPER
WRITE(Y2_STEP_PIN,HIGH);
#endif
motorYorZ += 2;
}
else if(motorYorZ >= 2)
{
WRITE(Y_STEP_PIN,HIGH);
#if FEATURE_TWO_YSTEPPER
WRITE(Y2_STEP_PIN,HIGH);
#endif
motorYorZ -= 2;
}
#endif
}
static inline void executeXZGantrySteps()
{
#if (GANTRY)
if(motorX <= -2)
{
WRITE(X_STEP_PIN,HIGH);
#if FEATURE_TWO_XSTEPPER
WRITE(X2_STEP_PIN,HIGH);
#endif
motorX += 2;
}
else if(motorX >= 2)
{
WRITE(X_STEP_PIN,HIGH);
#if FEATURE_TWO_XSTEPPER
WRITE(X2_STEP_PIN,HIGH);
#endif
motorX -= 2;
}
if(motorYorZ <= -2)
{
//ANALYZER_ON(ANALYZER_CH3); // I dont think i can use these as they are for the y - possible bug area though
WRITE(Z_STEP_PIN,HIGH);
#if FEATURE_TWO_ZSTEPPER
WRITE(Z2_STEP_PIN,HIGH);
#endif
motorYorZ += 2;
}
else if(motorYorZ >= 2)
{
//ANALYZER_ON(ANALYZER_CH3); // I dont think i can use these as they are for the y - possible bug area though
WRITE(Z_STEP_PIN,HIGH);
#if FEATURE_TWO_ZSTEPPER
WRITE(Z2_STEP_PIN,HIGH);
#endif
motorYorZ -= 2;
}
#endif
}
static inline void endXYZSteps()
{
WRITE(X_STEP_PIN,LOW);
WRITE(Y_STEP_PIN,LOW);
WRITE(Z_STEP_PIN,LOW);
#if FEATURE_TWO_XSTEPPER
WRITE(X2_STEP_PIN,LOW);
#endif
#if FEATURE_TWO_YSTEPPER
WRITE(Y2_STEP_PIN,LOW);
#endif
#if FEATURE_TWO_ZSTEPPER
WRITE(Z2_STEP_PIN,LOW);
#endif
}
static inline speed_t updateStepsPerTimerCall(speed_t vbase)
{
if(vbase>STEP_DOUBLER_FREQUENCY)
{
#if ALLOW_QUADSTEPPING
if(vbase>STEP_DOUBLER_FREQUENCY*2)
{
Printer::stepsPerTimerCall = 4;
return vbase>>2;
}
else
{
Printer::stepsPerTimerCall = 2;
return vbase>>1;
}
#else
Printer::stepsPerTimerCall = 2;
return vbase>>1;
#endif
}
else
{
Printer::stepsPerTimerCall = 1;
}
return vbase;
}
static inline void disableAllowedStepper()
{
#if DRIVE_SYSTEM == XZ_GANTRY || DRIVE_SYSTEM == ZX_GANTRY
if(DISABLE_X && DISABLE_Z)
{
disableXStepper();
disableZStepper();
}
if(DISABLE_Y) disableYStepper();
#else
#if GANTRY
if(DISABLE_X && DISABLE_Y)
{
disableXStepper();
disableYStepper();
}
#else
if(DISABLE_X) disableXStepper();
if(DISABLE_Y) disableYStepper();
#endif
if(DISABLE_Z) disableZStepper();
#endif
}
static inline float realXPosition()
{
return currentPosition[X_AXIS];
}
static inline float realYPosition()
{
return currentPosition[Y_AXIS];
}
static inline float realZPosition()
{
return currentPosition[Z_AXIS];
}
static inline void realPosition(float &xp, float &yp, float &zp)
{
xp = currentPosition[X_AXIS];
yp = currentPosition[Y_AXIS];
zp = currentPosition[Z_AXIS];
}
static inline void insertStepperHighDelay()
{
#if STEPPER_HIGH_DELAY>0
HAL::delayMicroseconds(STEPPER_HIGH_DELAY);
#endif
}
static void constrainDestinationCoords();
static void updateDerivedParameter();
static void updateCurrentPosition(bool copyLastCmd = false);
static void kill(uint8_t only_steppers);
static void updateAdvanceFlags();
static void setup();
static void defaultLoopActions();
static uint8_t setDestinationStepsFromGCode(GCode *com);
static uint8_t moveTo(float x,float y,float z,float e,float f);
static uint8_t moveToReal(float x,float y,float z,float e,float f);
static void homeAxis(bool xaxis,bool yaxis,bool zaxis); /// Home axis
static void setOrigin(float xOff,float yOff,float zOff);
static bool isPositionAllowed(float x,float y,float z);
static inline int getFanSpeed()
{
return (int)pwm_pos[NUM_EXTRUDER + 2];
}
#if NONLINEAR_SYSTEM
static inline void setDeltaPositions(long xaxis, long yaxis, long zaxis)
{
currentDeltaPositionSteps[A_TOWER] = xaxis;
currentDeltaPositionSteps[B_TOWER] = yaxis;
currentDeltaPositionSteps[C_TOWER] = zaxis;
}
static void deltaMoveToTopEndstops(float feedrate);
#endif
#if MAX_HARDWARE_ENDSTOP_Z
static float runZMaxProbe();
#endif
#if FEATURE_Z_PROBE
static float runZProbe(bool first,bool last,uint8_t repeat = Z_PROBE_REPETITIONS,bool runStartScript = true);
static void waitForZProbeStart();
#endif
// Moved outside FEATURE_Z_PROBE to allow auto-level functional test on
// system without Z-probe
#if FEATURE_AUTOLEVEL
static void transformToPrinter(float x,float y,float z,float &transX,float &transY,float &transZ);
static void transformFromPrinter(float x,float y,float z,float &transX,float &transY,float &transZ);
static void resetTransformationMatrix(bool silent);
static void buildTransformationMatrix(float h1,float h2,float h3);
#endif
#if DISTORTION_CORRECTION
static void measureDistortion(void);
static Distortion distortion;
#endif
static void MemoryPosition();
static void GoToMemoryPosition(bool x,bool y,bool z,bool e,float feed);
static void zBabystep();
static inline void resetWizardStack() {wizardStackPos = 0;}
static inline void pushWizardVar(wizardVar v) {wizardStack[wizardStackPos++] = v;}
static inline wizardVar popWizardVar() {return wizardStack[--wizardStackPos];}
static void showConfiguration();
static void setCaseLight(bool on);
static void reportCaseLightStatus();
private:
static void homeXAxis();
static void homeYAxis();
static void homeZAxis();
};
#endif // PRINTER_H_INCLUDED