Updated Repetier version

ESP8266-RGB-WiFiServer/ESP8266-RGB-WiFiServer.ino

@@ -63,6 +63,9 @@ WiFiServer server(port);
 
 
 void setup() {
+  // Set wifi mode to client
+  WiFi.mode(WIFI_STA);
+  
   // Initialize Serial connection
   Serial.begin(115200);
   delay(10);
@@ -73,8 +76,6 @@ void setup() {
   pinMode(bluePin, OUTPUT);
   
   // Connect to WiFi network
-  Serial.println();
-  Serial.println();
   Serial.print("Connecting to ");
   Serial.println(ssid);
   WiFi.begin(ssid, password);

Repetier/BedLeveling.cpp

@@ -0,0 +1,635 @@
+
+/*
+More and more printers now have automatic bed leveling using an ever increasing variety of methods.
+This makes the leveling routine one of the most complex parts of the firmware and there is not one
+way to level but hundreds of combinations.
+
+First you should decide on the correction method. Once we know how our bed is tilted we want to
+remove that. This correction is defined by BED_CORRECTION_METHOD and allows the following values:
+BED_CORRECTION_METHOD 0
+Use a rotation matrix. This will make z axis go up/down while moving in x/y direction to compensate
+the tilt. For multiple extruders make sure the height match the tilt of the bed or one will scratch.
+
+BED_CORRECTION_METHOD 1
+Motorized correction. This method needs a bed that is fixed on 3 points from which 2 have a motor
+to change the height. The positions are defined by
+BED_MOTOR_1_X, BED_MOTOR_1_Y, BED_MOTOR_2_X, BED_MOTOR_2_Y, BED_MOTOR_3_X, BED_MOTOR_3_Y
+Motor 2 and 3 are the one driven by motor driver 0 and 1. These can be extra motors like Felix Pro 1
+uses them or a system with 3 z axis where motors can be controlled individually like the Sparkcube
+does.
+
+Next we have to distinguish several methods of z probing sensors. Each have their own advantages and
+disadvantages. First the z probe has a position when activated and that position is defined by
+#define Z_PROBE_X_OFFSET 0
+#define Z_PROBE_Y_OFFSET 0
+This is needed since we need to know where we measure the height when the z probe triggers. When
+probing is activated you will see a move to make probe go over current extruder position. The
+position can be changed in eeprom later on.
+
+Some probes need to be activated/deactivated so we can use them. This is defined in the scripts
+#define Z_PROBE_START_SCRIPT ""
+#define Z_PROBE_FINISHED_SCRIPT ""
+
+Now when we probe we want to know the distance of the extruder to the bed. This is defined by
+#define Z_PROBE_HEIGHT 4
+The 4 means that when we trigger the distance of the nozzle tip is 4mm. If your switch tends
+to return different points you might repeat a measured point and use the average height:
+#define Z_PROBE_SWITCHING_DISTANCE 1
+#define Z_PROBE_REPETITIONS 5
+Switching distance is the z raise needed to turn back a signal reliably to off. Inductive sensors
+need only a bit while mechanical switches may require a bit more.
+
+Next thing to consider is the force for switching. Some beds use a cantilever design and pushing on
+the outside easily bends the bed. If your sensor needs some force to trigger you add the error of
+bending. For this reason you might add a bending correction. Currently you define
+#define BENDING_CORRECTION_A 0
+#define BENDING_CORRECTION_B 0
+#define BENDING_CORRECTION_C 0
+which are the deflections at the 3 z probe points. For all other possible measurements these values
+get interpolated. You can modify the values later on in eeprom. For force less sensors set them to 0.
+
+Next thing is endstop handling. Without bed leveling you normally home to minimum position for x,y and z.
+With bed leveling this is not that easy any more. Since we do bed leveling we already assume the bed is
+not leveled for x/y moves. So without correction we would hit the bed for different x/y positions at
+different heights. As a result we have no real minimum position. That makes a z min endstop quite useless.
+There is an exception to this. If your nozzle triggers z min or if a inductive sensor would trigger at a given
+position we could use that signal. With nozzle triggers you need to be careful as a drop of filament
+would change the height. The other problem is that while homing the auto leveling is not used. So
+the only position would be if the z min sensor is directly over the 0,0 coordinate which is the rotation point
+if we have matrix based correction. For motor based correction this will work everywhere correctly.
+
+So the only useful position for a z endstop is z max position. Apart from not having the bed tilt problem it
+also allows homing with a full bed so you can continue an aborted print with some gcode tweaking. With z max
+homing we adjust the error by simply changing the max. z height. One thing you need to remember is setting
+#define ENDSTOP_Z_BACK_ON_HOME 4
+so we release the z max endstop. This is very important if we move xy at z max. Auto leveling might want to
+increase z and the endstop might prevent it causing wrong position and a head crash if we later go down.
+The value should be larger then the maximum expected tilt.
+
+Now it is time to define how we measure the bed rotation. Here again we have several methods to choose.
+All methods need at least 3 points to define the bed rotation correctly. The quality we get comes
+from the selection of the right points and method.
+
+BED_LEVELING_METHOD 0
+This method measures at the 3 probe points and creates a plane through these points. If you have
+a really planar bed this gives the optimum result. The 3 points must not be in one line and have
+a long distance to increase numerical stability.
+
+BED_LEVELING_METHOD 1
+This measures a grid. Probe point 1 is the origin and points 2 and 3 span a grid. We measure
+BED_LEVELING_GRID_SIZE points in each direction and compute a regression plane through all
+points. This gives a good overall plane if you have small bumps measuring inaccuracies.
+
+BED_LEVELING_METHOD 2
+Bending correcting 4 point measurement. This is for cantilevered beds that have the rotation axis
+not at the side but inside the bed. Here we can assume no bending on the axis and a symmetric
+bending to both sides of the axis. So probe points 2 and 3 build the symmetric axis and
+point 1 is mirrored to 1m across the axis. Using the symmetry we then remove the bending
+from 1 and use that as plane.
+
+By now the leveling process is finished. All errors that remain are measuring errors and bumps on
+the bed it self. For deltas you can enable distortion correction to follow the bumps.
+
+*/
+
+#include "Repetier.h"
+
+#ifndef BED_LEVELING_METHOD
+#define BED_LEVELING_METHOD 0
+#endif
+
+#ifndef BED_CORRECTION_METHOD
+#define BED_CORRECTION_METHOD 0
+#endif
+
+#ifndef BED_LEVELING_GRID_SIZE
+#define BED_LEVELING_GRID_SIZE 5
+#endif
+
+#ifndef BED_LEVELING_REPETITIONS
+#define BED_LEVELING_REPETITIONS 1
+#endif
+
+#if FEATURE_AUTOLEVEL && FEATURE_Z_PROBE
+
+class Plane {
+	public:
+	// f(x, y) = ax + by + c
+	float a,b,c;
+	float z(float x,float y) {
+		return a * x + y * b + c;
+	}
+};
+class PlaneBuilder {
+	float sum_xx,sum_xy,sum_yy,sum_x,sum_y,sum_xz,sum_yz,sum_z,n;
+	public:
+	void reset() {
+		sum_xx = sum_xy = sum_yy = sum_x = sum_y = sum_xz = sum_yz = sum_z = n = 0;
+	}
+	void addPoint(float x,float y,float z) {
+		n++;
+		sum_xx += x * x;
+		sum_xy += x * y;
+		sum_yy += y * y;
+		sum_x += x;
+		sum_y += y;
+		sum_xz += x * z;
+		sum_yz += y * z;
+		sum_z += z;
+	}
+	void createPlane(Plane &plane) {
+		float det = (sum_x*(sum_xy*sum_y-sum_x*sum_yy)+sum_xx*(n*sum_yy-sum_y*sum_y)+sum_xy*(sum_x*sum_y-n*sum_xy));
+		plane.a = ((sum_xy*sum_y-sum_x*sum_yy)*sum_z+(sum_x*sum_y-n*sum_xy)*sum_yz+sum_xz*(n*sum_yy-sum_y*sum_y))   /det;
+		plane.b = ((sum_x*sum_xy-sum_xx*sum_y)*sum_z+(n*sum_xx-sum_x*sum_x)*sum_yz+sum_xz*(sum_x*sum_y-n*sum_xy))   /det;
+		plane.c = ((sum_xx*sum_yy-sum_xy*sum_xy)*sum_z+(sum_x*sum_xy-sum_xx*sum_y)*sum_yz+sum_xz*(sum_xy*sum_y-sum_x*sum_yy))/det;
+		Com::printF(PSTR("plane: a = "),plane.a,4);
+		Com::printF(PSTR(" b = "),plane.b,4);
+		Com::printFLN(PSTR(" c = "),plane.c,4);
+	}
+};
+
+bool measureAutolevelPlane(Plane &plane) {
+	PlaneBuilder builder;
+	builder.reset();
+	#if BED_LEVELING_METHOD == 0 // 3 point
+	float h;
+	Printer::moveTo(EEPROM::zProbeX1(),EEPROM::zProbeY1(),IGNORE_COORDINATE,IGNORE_COORDINATE,EEPROM::zProbeXYSpeed());
+	h = Printer::runZProbe(false,false);
+	if(h < -1)
+	return false;
+	builder.addPoint(EEPROM::zProbeX1(),EEPROM::zProbeY1(),h);
+	Printer::moveTo(EEPROM::zProbeX2(),EEPROM::zProbeY2(),IGNORE_COORDINATE,IGNORE_COORDINATE,EEPROM::zProbeXYSpeed());
+	h = Printer::runZProbe(false,false);
+	if(h < -1)
+	return false;
+	builder.addPoint(EEPROM::zProbeX2(),EEPROM::zProbeY2(),h);
+	Printer::moveTo(EEPROM::zProbeX3(),EEPROM::zProbeY3(),IGNORE_COORDINATE,IGNORE_COORDINATE,EEPROM::zProbeXYSpeed());
+	h = Printer::runZProbe(false,false);
+	if(h < -1)
+	return false;
+	builder.addPoint(EEPROM::zProbeX3(),EEPROM::zProbeY3(),h);
+	#elif BED_LEVELING_METHOD == 1 // linear regression
+	float delta = 1.0/(BED_LEVELING_GRID_SIZE - 1);
+	float ox = EEPROM::zProbeX1();
+	float oy = EEPROM::zProbeY1();
+	float ax = delta * (EEPROM::zProbeX2() - EEPROM::zProbeX1());
+	float ay = delta * (EEPROM::zProbeY2() - EEPROM::zProbeY1());
+	float bx = delta * (EEPROM::zProbeX3() - EEPROM::zProbeX1());
+	float by = delta * (EEPROM::zProbeY3() - EEPROM::zProbeY1());
+	for(int ix = 0; ix < BED_LEVELING_GRID_SIZE; ix++) {
+		for(int iy = 0; iy < BED_LEVELING_GRID_SIZE; iy++) {
+			float px = ox + static_cast<float>(ix) * ax + static_cast<float>(iy) * bx;
+			float py = oy + static_cast<float>(ix) * ay + static_cast<float>(iy) * by;
+			Printer::moveTo(px,py,IGNORE_COORDINATE,IGNORE_COORDINATE,EEPROM::zProbeXYSpeed());
+			float h = Printer::runZProbe(false,false);
+			if(h < -1)
+			return false;
+			builder.addPoint(px,py,h);
+		}
+	}
+	#elif BED_LEVELING_METHOD == 2 // 4 point symmetric
+	float h1,h2,h3,h4;
+	float apx = EEPROM::zProbeX1() - EEPROM::zProbeX2();
+	float apy = EEPROM::zProbeY1() - EEPROM::zProbeY2();
+	float abx = EEPROM::zProbeX3() - EEPROM::zProbeX2();
+	float aby = EEPROM::zProbeY3() - EEPROM::zProbeY2();
+	float ab2 = abx * abx + aby * aby;
+	float abap = apx * abx + apy * aby;
+	float t = abap / ab2;
+	float xx = EEPROM::zProbeX2() + t * abx;
+	float xy = EEPROM::zProbeY2() + t * aby;
+	float x1Mirror = EEPROM::zProbeX1() + 2.0 * (xx - EEPROM::zProbeX1());
+	float y1Mirror = EEPROM::zProbeY1() + 2.0 * (xy - EEPROM::zProbeY1());
+	Printer::moveTo(EEPROM::zProbeX1(),EEPROM::zProbeY1(),IGNORE_COORDINATE,IGNORE_COORDINATE,EEPROM::zProbeXYSpeed());
+	h1 = Printer::runZProbe(false,false);
+	if(h1 < -1)
+	return false;
+	Printer::moveTo(EEPROM::zProbeX2(),EEPROM::zProbeY2(),IGNORE_COORDINATE,IGNORE_COORDINATE,EEPROM::zProbeXYSpeed());
+	h2 = Printer::runZProbe(false,false);
+	if(h2 < -1)
+	return false;
+	Printer::moveTo(EEPROM::zProbeX3(),EEPROM::zProbeY3(),IGNORE_COORDINATE,IGNORE_COORDINATE,EEPROM::zProbeXYSpeed());
+	h3 = Printer::runZProbe(false,false);
+	if(h3 < -1)
+	return false;
+	Printer::moveTo(x1Mirror,y1Mirror,IGNORE_COORDINATE,IGNORE_COORDINATE,EEPROM::zProbeXYSpeed());
+	h4 = Printer::runZProbe(false,false);
+	if(h4 < -1)
+	return false;
+	t = h2 + (h3-h2) * t; // theoretical height for crossing point for symmetric axis
+	h1 = t - (h4-h1) * 0.5; // remove bending part
+	builder.addPoint(EEPROM::zProbeX1(),EEPROM::zProbeY1(),h1);
+	builder.addPoint(EEPROM::zProbeX2(),EEPROM::zProbeY2(),h2);
+	builder.addPoint(EEPROM::zProbeX3(),EEPROM::zProbeY3(),h3);
+	#else
+	#error Unknown bed leveling method
+	#endif
+	builder.createPlane(plane);
+	return true;
+}
+
+void correctAutolevel(GCode *code,Plane &plane) {
+	#if BED_CORRECTION_METHOD == 0 // rotation matrix
+	Printer::buildTransformationMatrix(plane.z(EEPROM::zProbeX1(),EEPROM::zProbeY1()),plane.z(EEPROM::zProbeX2(),EEPROM::zProbeY2()),plane.z(EEPROM::zProbeX3(),EEPROM::zProbeY3()));
+	#elif BED_CORRECTION_METHOD == 1 // motorized correction
+	#if !defined(NUM_MOTOR_DRIVERS) || NUM_MOTOR_DRIVERS < 2
+	#error You need to define 2 motors for motorized bed correction
+	#endif
+	Commands::waitUntilEndOfAllMoves(); // move steppers might be leveling steppers as well !
+	float h1 = plane.z(BED_MOTOR_1_X,BED_MOTOR_1_Y);
+	float h2 = plane.z(BED_MOTOR_2_X,BED_MOTOR_2_Y);
+	float h3 = plane.z(BED_MOTOR_3_X,BED_MOTOR_3_Y);
+	// h1 is reference heights, h2 => motor 0, h3 => motor 1
+	h2 -= h1;
+	h3 -= h1;
+	MotorDriverInterface *motor2 = getMotorDriver(0);
+	MotorDriverInterface *motor3 = getMotorDriver(1);
+	motor2->setCurrentAs(0);
+	motor3->setCurrentAs(0);
+	motor2->gotoPosition(h2);
+	motor3->gotoPosition(h3);
+	motor2->disable();
+	motor3->disable(); // now bed is even
+	Printer::currentPositionSteps[Z_AXIS] = h1 * Printer::axisStepsPerMM[Z_AXIS];
+	#else
+	#error Unknown bed correction method set
+	#endif
+}
+
+/*
+Implementation of the G32 command
+G32 S<0..2> - Autolevel print bed. S = 1 measure zLength, S = 2 Measure and store new zLength
+S = 0 : Do not update length - use this if you have not homed before or you mess up zlength!
+S = 1 : Measure zLength so homing works
+S = 2 : Like s = 1 plus store results in EEPROM for next connection.
+*/
+void runBedLeveling(GCode *com) {
+	float h1,h2,h3,hc,oldFeedrate = Printer::feedrate;
+	int s = com->hasS() ? com->S : -1;
+	#if DISTORTION_CORRECTION
+	bool distEnabled = Printer::distortion.isEnabled();
+	Printer::distortion.disable(false); // if level has changed, distortion is also invalid
+	#endif
+	Printer::setAutolevelActive(false); // iterate
+	Printer::resetTransformationMatrix(true); // in case we switch from matrix to motorized!
+	#if DRIVE_SYSTEM == DELTA
+	// It is not possible to go to the edges at the top, also users try
+	// it often and wonder why the coordinate system is then wrong.
+	// For that reason we ensure a correct behavior by code.
+	Printer::homeAxis(true, true, true);
+	Printer::moveTo(IGNORE_COORDINATE, IGNORE_COORDINATE, EEPROM::zProbeBedDistance() + EEPROM::zProbeHeight(), IGNORE_COORDINATE, Printer::homingFeedrate[Z_AXIS]);
+	#endif
+	Printer::startProbing(true);
+	//GCode::executeFString(Com::tZProbeStartScript);
+	Printer::coordinateOffset[X_AXIS] = Printer::coordinateOffset[Y_AXIS] = Printer::coordinateOffset[Z_AXIS] = 0;
+	Plane plane;
+#if BED_CORRECTION_METHOD == 1
+	for(int r = 0; r < BED_LEVELING_REPETITIONS; r++) {
+#if DRIVE_SYSTEM == DELTA
+		if(r > 0) {
+			Printer::finishProbing();
+			Printer::homeAxis(true, true, true);
+			Printer::moveTo(IGNORE_COORDINATE, IGNORE_COORDINATE, EEPROM::zProbeBedDistance() + EEPROM::zProbeHeight(), IGNORE_COORDINATE, Printer::homingFeedrate[Z_AXIS]);
+			Printer::startProbing(true);
+		}
+#endif		
+#endif		
+		if(!measureAutolevelPlane(plane)) {
+			Com::printErrorFLN(PSTR("Probing had returned errors - autoleveling canceled."));
+			return;
+		}
+		correctAutolevel(com,plane);
+		
+		// Leveling is finished now update own positions and store leveling data if needed
+		float currentZ = plane.z((float)Printer::currentPositionSteps[X_AXIS] * Printer::invAxisStepsPerMM[X_AXIS],(float)Printer::currentPositionSteps[Y_AXIS] * Printer::invAxisStepsPerMM[Y_AXIS]);
+		Com::printF(PSTR("CurrentZ:"),currentZ);Com::printFLN(PSTR(" atZ:"),Printer::currentPosition[Z_AXIS]);
+		// With max z endstop we adjust zlength so after next homing we have also a calibrated printer
+		Printer::zMin = 0;
+		#if MAX_HARDWARE_ENDSTOP_Z
+		float xRot,yRot,zRot;
+		#if BED_CORRECTION_METHOD != 1
+		Printer::transformFromPrinter(Printer::currentPosition[X_AXIS],Printer::currentPosition[Y_AXIS],Printer::currentPosition[Z_AXIS],xRot,yRot,zRot);
+		Com::printFLN(PSTR("Z after rotation:"),zRot);
+		#else
+		zRot = Printer::currentPosition[Z_AXIS];
+		#endif
+		// With max z endstop we adjust zlength so after next homing we have also a calibrated printer
+		if(s != 0) {
+		  Printer::zLength += currentZ - zRot;
+		   Com::printFLN(Com::tZProbePrinterHeight, Printer::zLength);
+		}
+		#endif
+		Printer::currentPositionSteps[Z_AXIS] = currentZ * Printer::axisStepsPerMM[Z_AXIS];
+		Printer::updateCurrentPosition(true);
+#if BED_CORRECTION_METHOD == 1
+		if(fabs(plane.a) < 0.00025 && fabsf(plane.b) < 0.00025 )
+		break;	// we reached achievable precision so we can stop
+	}
+#endif	
+	Printer::updateDerivedParameter();
+	Printer::finishProbing();
+#if BED_CORRECTION_METHOD != 1	
+	Printer::setAutolevelActive(true); // only for software correction or we can spare the comp. time
+#endif	
+	if(s >= 2) {
+		EEPROM::storeDataIntoEEPROM();
+	}
+	Printer::updateCurrentPosition(true);
+	Commands::printCurrentPosition(PSTR("G32 "));
+	#if DISTORTION_CORRECTION
+	if(distEnabled)
+		Printer::distortion.enable(false); // if level has changed, distortion is also invalid
+	#endif
+	#if DRIVE_SYSTEM == DELTA
+	   Printer::homeAxis(true, true, true); // shifting z makes positioning invalid, need to recalibrate
+	#endif
+	Printer::feedrate = oldFeedrate;
+}
+
+#endif
+
+void Printer::setAutolevelActive(bool on)
+{
+	#if FEATURE_AUTOLEVEL
+	if(on == isAutolevelActive()) return;
+	flag0 = (on ? flag0 | PRINTER_FLAG0_AUTOLEVEL_ACTIVE : flag0 & ~PRINTER_FLAG0_AUTOLEVEL_ACTIVE);
+	if(on)
+	Com::printInfoFLN(Com::tAutolevelEnabled);
+	else
+	Com::printInfoFLN(Com::tAutolevelDisabled);
+	updateCurrentPosition(false);
+	#endif // FEATURE_AUTOLEVEL
+}
+#if MAX_HARDWARE_ENDSTOP_Z
+float Printer::runZMaxProbe()
+{
+	#if NONLINEAR_SYSTEM
+	long startZ = realDeltaPositionSteps[Z_AXIS] = currentDeltaPositionSteps[Z_AXIS]; // update real
+	#endif
+	Commands::waitUntilEndOfAllMoves();
+	long probeDepth = 2*(Printer::zMaxSteps-Printer::zMinSteps);
+	stepsRemainingAtZHit = -1;
+	setZProbingActive(true);
+	PrintLine::moveRelativeDistanceInSteps(0,0,probeDepth,0,EEPROM::zProbeSpeed(),true,true);
+	if(stepsRemainingAtZHit < 0)
+	{
+		Com::printErrorFLN(Com::tZProbeFailed);
+		return -1;
+	}
+	setZProbingActive(false);
+	currentPositionSteps[Z_AXIS] -= stepsRemainingAtZHit;
+	#if NONLINEAR_SYSTEM
+	probeDepth -= (realDeltaPositionSteps[Z_AXIS] - startZ);
+	#else
+	probeDepth -= stepsRemainingAtZHit;
+	#endif
+	float distance = (float)probeDepth * invAxisStepsPerMM[Z_AXIS];
+	Com::printF(Com::tZProbeMax,distance);
+	Com::printF(Com::tSpaceXColon,realXPosition());
+	Com::printFLN(Com::tSpaceYColon,realYPosition());
+	PrintLine::moveRelativeDistanceInSteps(0,0,-probeDepth,0,EEPROM::zProbeSpeed(),true,true);
+	return distance;
+}
+#endif
+
+#if FEATURE_Z_PROBE
+void Printer::startProbing(bool runScript) {
+	float oldOffX = Printer::offsetX;
+	float oldOffY = Printer::offsetY;
+	float oldOffZ = Printer::offsetZ;
+	if(runScript)
+	GCode::executeFString(Com::tZProbeStartScript);
+	float maxStartHeight = EEPROM::zProbeBedDistance() + (EEPROM::zProbeHeight() > 0 ? EEPROM::zProbeHeight() : 0) + 0.1;
+	if(currentPosition[Z_AXIS] > maxStartHeight) {
+		moveTo(IGNORE_COORDINATE, IGNORE_COORDINATE, maxStartHeight, IGNORE_COORDINATE, homingFeedrate[Z_AXIS]);
+	}
+	Printer::offsetX = -EEPROM::zProbeXOffset();
+	Printer::offsetY = -EEPROM::zProbeYOffset();
+	Printer::offsetZ = 0; // we correct this with probe height
+	PrintLine::moveRelativeDistanceInSteps((Printer::offsetX - oldOffX) * Printer::axisStepsPerMM[X_AXIS],
+	(Printer::offsetY - oldOffY) * Printer::axisStepsPerMM[Y_AXIS],
+	0, 0, EEPROM::zProbeXYSpeed(), true, ALWAYS_CHECK_ENDSTOPS);
+}
+
+void Printer::finishProbing() {
+	float oldOffX = Printer::offsetX;
+	float oldOffY = Printer::offsetY;
+	float oldOffZ = Printer::offsetZ;
+	GCode::executeFString(Com::tZProbeEndScript);
+	if(Extruder::current)
+	{
+		Printer::offsetX = -Extruder::current->xOffset * Printer::invAxisStepsPerMM[X_AXIS];
+		Printer::offsetY = -Extruder::current->yOffset * Printer::invAxisStepsPerMM[Y_AXIS];
+		Printer::offsetZ = -Extruder::current->zOffset * Printer::invAxisStepsPerMM[Z_AXIS];
+	}
+	PrintLine::moveRelativeDistanceInSteps((Printer::offsetX - oldOffX) * Printer::axisStepsPerMM[X_AXIS],
+	(Printer::offsetY - oldOffY) * Printer::axisStepsPerMM[Y_AXIS],
+	(Printer::offsetZ - oldOffZ) * Printer::axisStepsPerMM[Z_AXIS], 0, EEPROM::zProbeXYSpeed(), true, ALWAYS_CHECK_ENDSTOPS);
+}
+
+/*
+This is the most important function for bed leveling. It does
+1. Run probe start script if first = true and runStartScript = true
+2. Position zProbe at current position if first = true. If we are more then maxStartHeight away from bed we also go down to that distance.
+3. Measure the the steps until probe hits the bed.
+4. Undo positioning to z probe and run finish script if last = true.
+
+Now we compute the nozzle height as follows:
+a) Compute average height from repeated measurements
+b) Add zProbeHeight to correct difference between triggering point and nozzle height above bed
+c) If Z_PROBE_Z_OFFSET_MODE == 1 we add zProbeZOffset() that is coating thickness if we measure below coating with indictive sensor.
+d) Add distortion correction.
+e) Add bending correction
+
+Then we return the measured and corrected z distance.
+*/
+float Printer::runZProbe(bool first,bool last,uint8_t repeat,bool runStartScript)
+{
+	float oldOffX = Printer::offsetX;
+	float oldOffY = Printer::offsetY;
+	float oldOffZ = Printer::offsetZ;
+	if(first)
+	startProbing(runStartScript);
+	Commands::waitUntilEndOfAllMoves();
+	int32_t sum = 0, probeDepth;
+	int32_t shortMove = static_cast<int32_t>((float)Z_PROBE_SWITCHING_DISTANCE * axisStepsPerMM[Z_AXIS]); // distance to go up for repeated moves
+	int32_t lastCorrection = currentPositionSteps[Z_AXIS]; // starting position
+	#if NONLINEAR_SYSTEM
+	realDeltaPositionSteps[Z_AXIS] = currentDeltaPositionSteps[Z_AXIS]; // update real
+	#endif
+	//int32_t updateZ = 0;
+	waitForZProbeStart();
+	for(int8_t r = 0; r < repeat; r++)
+	{
+		probeDepth = 2 * (Printer::zMaxSteps - Printer::zMinSteps); // probe should always hit within this distance
+		stepsRemainingAtZHit = -1; // Marker that we did not hit z probe
+		//int32_t offx = axisStepsPerMM[X_AXIS] * EEPROM::zProbeXOffset();
+		//int32_t offy = axisStepsPerMM[Y_AXIS] * EEPROM::zProbeYOffset();
+		//PrintLine::moveRelativeDistanceInSteps(-offx,-offy,0,0,EEPROM::zProbeXYSpeed(),true,true);
+		setZProbingActive(true);
+		PrintLine::moveRelativeDistanceInSteps(0, 0, -probeDepth, 0, EEPROM::zProbeSpeed(), true, true);
+		if(stepsRemainingAtZHit < 0)
+		{
+			Com::printErrorFLN(Com::tZProbeFailed);
+			return -1;
+		}
+		setZProbingActive(false);
+		#if NONLINEAR_SYSTEM
+		stepsRemainingAtZHit = realDeltaPositionSteps[C_TOWER] - currentDeltaPositionSteps[C_TOWER]; // nonlinear moves may split z so stepsRemainingAtZHit is only what is left from last segment not total move. This corrects the problem.
+		#endif
+		#if DRIVE_SYSTEM == DELTA
+		currentDeltaPositionSteps[A_TOWER] += stepsRemainingAtZHit; // Update difference
+		currentDeltaPositionSteps[B_TOWER] += stepsRemainingAtZHit;
+		currentDeltaPositionSteps[C_TOWER] += stepsRemainingAtZHit;
+		#endif
+		currentPositionSteps[Z_AXIS] += stepsRemainingAtZHit; // now current position is correct
+		sum += lastCorrection - currentPositionSteps[Z_AXIS];
+		if(r + 1 < repeat) // go only shortest possible move up for repetitions
+		PrintLine::moveRelativeDistanceInSteps(0, 0, shortMove, 0, EEPROM::zProbeSpeed(), true, false);
+	}
+	float distance = static_cast<float>(sum) * invAxisStepsPerMM[Z_AXIS] / static_cast<float>(repeat) + EEPROM::zProbeHeight();
+	#if Z_PROBE_Z_OFFSET_MODE == 1
+	distance += EEPROM::zProbeZOffset(); // We measured including coating, so we need to add coating thickness!
+	#endif
+	#if DISTORTION_CORRECTION
+	float zCorr = 0;
+	if(Printer::distortion.isEnabled()) {
+		zCorr = distortion.correct(currentPositionSteps[X_AXIS] + EEPROM::zProbeXOffset() * axisStepsPerMM[X_AXIS],currentPositionSteps[Y_AXIS]
+		+ EEPROM::zProbeYOffset() * axisStepsPerMM[Y_AXIS],0) * invAxisStepsPerMM[Z_AXIS];
+		distance += zCorr;
+	}
+	#endif
+	distance += bendingCorrectionAt(currentPosition[X_AXIS], currentPosition[Y_AXIS]);
+	Com::printF(Com::tZProbe, distance);
+	Com::printF(Com::tSpaceXColon, realXPosition());
+	#if DISTORTION_CORRECTION
+	if(Printer::distortion.isEnabled()) {
+		Com::printF(Com::tSpaceYColon, realYPosition());
+		Com::printFLN(PSTR(" zCorr:"), zCorr);
+	} else {
+		Com::printFLN(Com::tSpaceYColon, realYPosition());		
+	}
+	#else
+	Com::printFLN(Com::tSpaceYColon, realYPosition());
+	#endif
+	// Go back to start position
+	PrintLine::moveRelativeDistanceInSteps(0, 0, lastCorrection - currentPositionSteps[Z_AXIS], 0, EEPROM::zProbeSpeed(), true, false);
+	//PrintLine::moveRelativeDistanceInSteps(offx,offy,0,0,EEPROM::zProbeXYSpeed(),true,true);
+	if(last)
+	finishProbing();
+	return distance;
+}
+
+float Printer::bendingCorrectionAt(float x, float y) {
+	RVector3 p0(EEPROM::zProbeX1(),EEPROM::zProbeY1(),EEPROM::bendingCorrectionA());
+	RVector3 p1(EEPROM::zProbeX2(),EEPROM::zProbeY2(),EEPROM::bendingCorrectionB());
+	RVector3 p2(EEPROM::zProbeX3(),EEPROM::zProbeY3(),EEPROM::bendingCorrectionC());
+	RVector3 a = p1-p0,b = p2 - p0;
+	RVector3 n = a.cross(b);
+	RVector3 l0(x,y,0);
+	return ((p0 - l0).scalar(n)) / n.z;
+}
+
+void Printer::waitForZProbeStart()
+{
+	#if Z_PROBE_WAIT_BEFORE_TEST
+	Endstops::update();
+	Endstops::update(); // double test to get right signal. Needed for crosstalk protection.
+	if(Endstops::zProbe()) return;
+	#if UI_DISPLAY_TYPE != NO_DISPLAY
+	uid.setStatusP(Com::tHitZProbe);
+	uid.refreshPage();
+	#endif
+	#ifdef DEBUG_PRINT
+	debugWaitLoop = 3;
+	#endif
+	while(!Endstops::zProbe())
+	{
+		defaultLoopActions();
+		Endstops::update();
+		Endstops::update(); // double test to get right signal. Needed for crosstalk protection.
+	}
+	#ifdef DEBUG_PRINT
+	debugWaitLoop = 4;
+	#endif
+	HAL::delayMilliseconds(30);
+	while(Endstops::zProbe())
+	{
+		defaultLoopActions();
+		Endstops::update();
+		Endstops::update(); // double test to get right signal. Needed for crosstalk protection.
+	}
+	HAL::delayMilliseconds(30);
+	UI_CLEAR_STATUS;
+	#endif
+}
+#endif
+
+#if FEATURE_AUTOLEVEL
+void Printer::transformToPrinter(float x,float y,float z,float &transX,float &transY,float &transZ)
+{
+	#if FEATURE_AXISCOMP
+	// Axis compensation:
+	x = x + y * EEPROM::axisCompTanXY() + z * EEPROM::axisCompTanXZ();
+	y = y + z * EEPROM::axisCompTanYZ();
+	#endif
+	transX = x * autolevelTransformation[0] + y * autolevelTransformation[3] + z * autolevelTransformation[6];
+	transY = x * autolevelTransformation[1] + y * autolevelTransformation[4] + z * autolevelTransformation[7];
+	transZ = x * autolevelTransformation[2] + y * autolevelTransformation[5] + z * autolevelTransformation[8];
+}
+
+void Printer::transformFromPrinter(float x,float y,float z,float &transX,float &transY,float &transZ)
+{
+	transX = x * autolevelTransformation[0] + y * autolevelTransformation[1] + z * autolevelTransformation[2];
+	transY = x * autolevelTransformation[3] + y * autolevelTransformation[4] + z * autolevelTransformation[5];
+	transZ = x * autolevelTransformation[6] + y * autolevelTransformation[7] + z * autolevelTransformation[8];
+	#if FEATURE_AXISCOMP
+	// Axis compensation:
+	transY = transY - transZ * EEPROM::axisCompTanYZ();
+	transX = transX - transY * EEPROM::axisCompTanXY() - transZ * EEPROM::axisCompTanXZ();
+	#endif
+}
+
+void Printer::resetTransformationMatrix(bool silent)
+{
+	autolevelTransformation[0] = autolevelTransformation[4] = autolevelTransformation[8] = 1;
+	autolevelTransformation[1] = autolevelTransformation[2] = autolevelTransformation[3] =
+	autolevelTransformation[5] = autolevelTransformation[6] = autolevelTransformation[7] = 0;
+	if(!silent)
+	Com::printInfoFLN(Com::tAutolevelReset);
+}
+
+void Printer::buildTransformationMatrix(float h1,float h2,float h3)
+{
+	float ax = EEPROM::zProbeX2()-EEPROM::zProbeX1();
+	float ay = EEPROM::zProbeY2()-EEPROM::zProbeY1();
+	float az = h1-h2;
+	float bx = EEPROM::zProbeX3()-EEPROM::zProbeX1();
+	float by = EEPROM::zProbeY3()-EEPROM::zProbeY1();
+	float bz = h1-h3;
+	// First z direction
+	autolevelTransformation[6] = ay * bz - az * by;
+	autolevelTransformation[7] = az * bx - ax * bz;
+	autolevelTransformation[8] = ax * by - ay * bx;
+	float len = sqrt(autolevelTransformation[6] * autolevelTransformation[6] + autolevelTransformation[7] * autolevelTransformation[7] + autolevelTransformation[8] * autolevelTransformation[8]);
+	if(autolevelTransformation[8] < 0) len = -len;
+	autolevelTransformation[6] /= len;
+	autolevelTransformation[7] /= len;
+	autolevelTransformation[8] /= len;
+	autolevelTransformation[3] = 0;
+	autolevelTransformation[4] = autolevelTransformation[8];
+	autolevelTransformation[5] = -autolevelTransformation[7];
+	// cross(y,z)
+	autolevelTransformation[0] = autolevelTransformation[4] * autolevelTransformation[8] - autolevelTransformation[5] * autolevelTransformation[7];
+	autolevelTransformation[1] = autolevelTransformation[5] * autolevelTransformation[6];// - autolevelTransformation[3] * autolevelTransformation[8];
+	autolevelTransformation[2] = /*autolevelTransformation[3] * autolevelTransformation[7]*/ - autolevelTransformation[4] * autolevelTransformation[6];
+	len = sqrt(autolevelTransformation[0] * autolevelTransformation[0] + autolevelTransformation[1] * autolevelTransformation[1] + autolevelTransformation[2] * autolevelTransformation[2]);
+	autolevelTransformation[0] /= len;
+	autolevelTransformation[1] /= len;
+	autolevelTransformation[2] /= len;
+	len = sqrt(autolevelTransformation[4] * autolevelTransformation[4] + autolevelTransformation[5] * autolevelTransformation[5]);
+	autolevelTransformation[4] /= len;
+	autolevelTransformation[5] /= len;
+	Com::printArrayFLN(Com::tTransformationMatrix,autolevelTransformation, 9, 6);
+}
+#endif

Repetier/Commands.cpp

@@ -21,7 +21,7 @@
 
 #include "Repetier.h"
 
-const uint8_t sensitive_pins[] PROGMEM = SENSITIVE_PINS; // Sensitive pin list for M42
+const int8_t sensitive_pins[] PROGMEM = SENSITIVE_PINS; // Sensitive pin list for M42
 int Commands::lowestRAMValue = MAX_RAM;
 int Commands::lowestRAMValueSend = MAX_RAM;
 
@@ -161,6 +161,7 @@ void Commands::printCurrentPosition(FSTRINGPARAM(s))
 
 void Commands::printTemperatures(bool showRaw)
 {
+#if NUM_EXTRUDER > 0
     float temp = Extruder::current->tempControl.currentTemperatureC;
 #if HEATED_BED_SENSOR_TYPE == 0
     Com::printF(Com::tTColon,temp);
@@ -198,8 +199,15 @@ void Commands::printTemperatures(bool showRaw)
             Com::printF(Com::tColon,(1023 << (2 - ANALOG_REDUCE_BITS)) - extruder[i].tempControl.currentTemperature);
         }
     }
+#elif NUM_EXTRUDER == 1
+    if(showRaw)
+    {
+            Com::printF(Com::tSpaceRaw,(int)0);
+            Com::printF(Com::tColon,(1023 << (2 - ANALOG_REDUCE_BITS)) - extruder[0].tempControl.currentTemperature);
+    }
 #endif
     Com::println();
+#endif
 }
 void Commands::changeFeedrateMultiply(int factor)
 {
@@ -222,26 +230,38 @@ void Commands::changeFlowrateMultiply(int factor)
     Com::printFLN(Com::tFlowMultiply, factor);
 }
 
+#if FEATURE_FAN_CONTROL
 uint8_t fanKickstart;
-void Commands::setFanSpeed(int speed,bool wait)
+#endif
+#if FEATURE_FAN2_CONTROL
+uint8_t fan2Kickstart;
+#endif
+
+void Commands::setFanSpeed(int speed, bool immediately)
 {
 #if FAN_PIN >- 1 && FEATURE_FAN_CONTROL
+    if(Printer::fanSpeed == speed)
+        return;
     speed = constrain(speed,0,255);
     Printer::setMenuMode(MENU_MODE_FAN_RUNNING,speed != 0);
-    if(wait)
+    Printer::fanSpeed = speed;
-        Commands::waitUntilEndOfAllMoves(); // use only if neededthis to change the speed exactly at that point, but it may cause blobs if you do!
+    if(PrintLine::linesCount == 0 || immediately) {
-    if(speed != pwm_pos[NUM_EXTRUDER + 2])
+        if(Printer::mode == PRINTER_MODE_FFF)
         {
-        Com::printFLN(Com::tFanspeed,speed); // send only new values to break update loops!
+	        for(fast8_t i = 0; i < PRINTLINE_CACHE_SIZE; i++)
-#if FAN_KICKSTART_TIME
+			    PrintLine::lines[i].secondSpeed = speed;         // fill all printline buffers with new fan speed value
-        if(fanKickstart == 0 && speed > pwm_pos[NUM_EXTRUDER + 2] && speed < 85)
-        {
-            if(pwm_pos[NUM_EXTRUDER + 2]) fanKickstart = FAN_KICKSTART_TIME/100;
-            else                          fanKickstart = FAN_KICKSTART_TIME/25;
         }
+		Printer::setFanSpeedDirectly(speed);
+	}
+    Com::printFLN(Com::tFanspeed,speed); // send only new values to break update loops!
 #endif
 }
-    pwm_pos[NUM_EXTRUDER + 2] = speed;
+void Commands::setFan2Speed(int speed)
+{
+	#if FAN2_PIN >- 1 && FEATURE_FAN2_CONTROL
+	speed = constrain(speed,0,255);
+	Printer::setFan2SpeedDirectly(speed);
+	Com::printFLN(Com::tFan2speed,speed); // send only new values to break update loops!
 	#endif
 }
 
@@ -252,9 +272,10 @@ void Commands::reportPrinterUsage()
     Com::printF(Com::tPrintedFilament, dist, 2);
     Com::printF(Com::tSpacem);
     bool alloff = true;
+#if NUM_EXTRUDER > 0
     for(uint8_t i = 0; i < NUM_EXTRUDER; i++)
         if(tempController[i]->targetTemperatureC > 15) alloff = false;
-
+#endif
     int32_t seconds = (alloff ? 0 : (HAL::timeInMilliseconds() - Printer::msecondsPrinting) / 1000) + HAL::eprGetInt32(EPR_PRINTING_TIME);
     int32_t tmp = seconds / 86400;
     seconds -= tmp * 86400;
@@ -906,7 +927,7 @@ void Commands::processArc(GCode *com)
     PrintLine::arc(position, target, offset, r, isclockwise);
 }
 #endif
-
+extern void runBedLeveling(GCode *com);
 /**
   \brief Execute the G command stored in com.
 */
@@ -917,6 +938,13 @@ void Commands::processGCode(GCode *com)
     {
     case 0: // G0 -> G1
     case 1: // G1
+#if defined(SUPPORT_LASER) && SUPPORT_LASER
+        { // disable laser for G0 moves
+        bool laserOn = LaserDriver::laserOn;
+        if(com->G == 0 && Printer::mode == PRINTER_MODE_LASER) {
+            LaserDriver::laserOn = false;
+        }
+#endif // defined
         if(com->hasS()) Printer::setNoDestinationCheck(com->S != 0);
         if(Printer::setDestinationStepsFromGCode(com)) // For X Y Z E F
 #if NONLINEAR_SYSTEM
@@ -948,11 +976,26 @@ void Commands::processGCode(GCode *com)
                 Com::printFLN(PSTR("Buffer corrupted"));
         }
 #endif
+#if defined(SUPPORT_LASER) && SUPPORT_LASER
+            LaserDriver::laserOn = laserOn;
+        }
+#endif // defined
         break;
 #if ARC_SUPPORT
     case 2: // CW Arc
     case 3: // CCW Arc MOTION_MODE_CW_ARC: case MOTION_MODE_CCW_ARC:
+#if defined(SUPPORT_LASER) && SUPPORT_LASER
+		{ // disable laser for G0 moves
+		bool laserOn = LaserDriver::laserOn;
+		if(com->G == 0 && Printer::mode == PRINTER_MODE_LASER) {
+			LaserDriver::laserOn = false;
+		}
+#endif // defined
         processArc(com);
+#if defined(SUPPORT_LASER) && SUPPORT_LASER
+		LaserDriver::laserOn = laserOn;
+		}
+#endif // defined
         break;
 #endif
     case 4: // G4 dwell
@@ -1074,7 +1117,10 @@ void Commands::processGCode(GCode *com)
         break;
 #if FEATURE_AUTOLEVEL
     case 32: // G32 Auto-Bed leveling
+		runBedLeveling(com);
+#if 0
     {
+		
 #if DISTORTION_CORRECTION
         Printer::distortion.disable(true); // if level has changed, distortion is also invalid
 #endif
@@ -1082,7 +1128,7 @@ void Commands::processGCode(GCode *com)
 #if DRIVE_SYSTEM == DELTA
         // It is not possible to go to the edges at the top, also users try
         // it often and wonder why the coordinate system is then wrong.
-        // For that reason we ensure a correct behaviour by code.
+        // For that reason we ensure a correct behavior by code.
         Printer::homeAxis(true, true, true);
         Printer::moveTo(IGNORE_COORDINATE, IGNORE_COORDINATE, EEPROM::zProbeBedDistance() + EEPROM::zProbeHeight(), IGNORE_COORDINATE, Printer::homingFeedrate[Z_AXIS]);
 #endif
@@ -1099,18 +1145,6 @@ void Commands::processGCode(GCode *com)
         Printer::moveTo(EEPROM::zProbeX3(),EEPROM::zProbeY3(),IGNORE_COORDINATE,IGNORE_COORDINATE,EEPROM::zProbeXYSpeed());
         h3 = Printer::runZProbe(false,true);
         if(h3 < -1) break;
-        // Zprobe with force feedback may bed bed differently for different points.
-        // these settings allow correction of the bending distance so leveling is correct afterwards.
-        // Values are normally negative with bending amount on trigger.
-#ifdef ZPROBE_1_BENDING_CORRECTION
-        h1 += ZPROBE_1_BENDING_CORRECTION;
-#endif
-#ifdef ZPROBE_2_BENDING_CORRECTION
-        h2 += ZPROBE_2_BENDING_CORRECTION;
-#endif
-#ifdef ZPROBE_3_BENDING_CORRECTION
-        h3 += ZPROBE_3_BENDING_CORRECTION;
-#endif
 #if defined(MOTORIZED_BED_LEVELING) && defined(NUM_MOTOR_DRIVERS) && NUM_MOTOR_DRIVERS >= 2
         // h1 is reference heights, h2 => motor 0, h3 => motor 1
         h2 -= h1;
@@ -1179,8 +1213,29 @@ void Commands::processGCode(GCode *com)
 #endif
         Printer::feedrate = oldFeedrate;
     }
+#endif	
     break;
 #endif
+#endif
+#if DISTORTION_CORRECTION
+	case 33: {
+		if(com->hasL()) { // G33 L0 - List distortion matrix
+			Printer::distortion.showMatrix();
+		} else if(com->hasR()) { // G33 R0 - Reset distortion matrix
+			Printer::distortion.resetCorrection();
+		} else if(com->hasX() || com->hasY() || com->hasZ()) { // G33 X<xpos> Y<ypos> Z<zCorrection> - Set correction for nearest point
+			if(com->hasX() && com->hasY() && com->hasZ()) {
+				Printer::distortion.set(com->X, com->Y, com->Z);
+			} else {
+				Com::printErrorFLN(PSTR("You need to define X, Y and Z to set a point!"));
+			}
+		} else { // G33
+			float oldFeedrate = Printer::feedrate;
+			Printer::measureDistortion();
+			Printer::feedrate = oldFeedrate;
+		}
+	}
+		break;
 #endif
     case 90: // G90
         Printer::relativeCoordinateMode = false;
@@ -1345,6 +1400,7 @@ void Commands::processGCode(GCode *com)
             EEPROM::setDeltaTowerZOffsetSteps(offz);
         }
 #endif
+        PrintLine::moveRelativeDistanceInSteps(0, 0, -5*Printer::axisStepsPerMM[Z_AXIS], 0, Printer::homingFeedrate[Z_AXIS], true, true);
         Printer::homeAxis(true,true,true);
     }
     break;
@@ -1371,10 +1427,11 @@ void Commands::processGCode(GCode *com)
         Com::printFLN(Com::tTower2,offy);
         Com::printFLN(Com::tTower3,offz);
         Printer::setAutolevelActive(oldAuto);
+        PrintLine::moveRelativeDistanceInSteps(0, 0, Printer::axisStepsPerMM[Z_AXIS] * -ENDSTOP_Z_BACK_MOVE, 0, Printer::homingFeedrate[Z_AXIS] / ENDSTOP_X_RETEST_REDUCTION_FACTOR, true, false);
         Printer::homeAxis(true,true,true);
     }
     break;
-    case 134: // G134
+    case 135: // G135
         Com::printF(PSTR("CompDelta:"),Printer::currentDeltaPositionSteps[A_TOWER]);
         Com::printF(Com::tComma,Printer::currentDeltaPositionSteps[B_TOWER]);
         Com::printFLN(Com::tComma,Printer::currentDeltaPositionSteps[C_TOWER]);
@@ -1389,6 +1446,31 @@ void Commands::processGCode(GCode *com)
         break;
 
 #endif // DRIVE_SYSTEM
+#if FEATURE_Z_PROBE
+    case 134: // - G134 Px Sx Zx - Calibrate nozzle height difference (need z probe in nozzle!) Px = reference extruder, Sx = only measure extrude x against reference, Zx = add to measured z distance for Sx for correction.
+        {
+            float z = com->hasZ() ? com->Z : 0;
+            int p = com->hasP() ? com->P : 0;
+            int s = com->hasS() ? com->S : -1;
+            extruder[p].zOffset = 0;
+            Extruder::selectExtruderById(p);
+            float refHeight = Printer::runZProbe(true,false,true);
+            for(int i = 0;i < NUM_EXTRUDER;i++) {
+                if(i == p) continue;
+                if(s >= 0 && i != s) continue;
+                extruder[i].zOffset = 0;
+                Extruder::selectExtruderById(i);
+                float height = Printer::runZProbe(false,false);
+                extruder[i].zOffset = (height - refHeight + z)*Printer::axisStepsPerMM[Z_AXIS];
+            }
+            Extruder::selectExtruderById(p);
+            Printer::runZProbe(false,true);
+#if EEPROM_MODE != 0
+            EEPROM::storeDataIntoEEPROM(0);
+#endif
+        }
+        break;
+#endif
 #if defined(NUM_MOTOR_DRIVERS) && NUM_MOTOR_DRIVERS > 0
     case 201:
         commandG201(*com);
@@ -1417,13 +1499,56 @@ void Commands::processGCode(GCode *com)
 */
 void Commands::processMCode(GCode *com)
 {
-    uint32_t codenum; //throw away variable
     switch( com->M )
     {
-
+    case 3: // Spindle/laser on
+#if defined(SUPPORT_LASER) && SUPPORT_LASER
+        if(Printer::mode == PRINTER_MODE_LASER) {
+            if(com->hasS())
+                LaserDriver::intensity = constrain(com->S,0,255);
+            LaserDriver::laserOn = true;
+            Com::printFLN(PSTR("LaserOn:"),(int)LaserDriver::intensity);
+        }
+#endif // defined
+#if defined(SUPPORT_CNC) && SUPPORT_CNC
+        if(Printer::mode == PRINTER_MODE_CNC) {
+            waitUntilEndOfAllMoves();
+            CNCDriver::spindleOnCW(com->hasS() ? com->S : 0);
+        }
+#endif // defined
+        break;
+    case 4: // Spindle CCW
+#if defined(SUPPORT_CNC) && SUPPORT_CNC
+        if(Printer::mode == PRINTER_MODE_CNC) {
+            waitUntilEndOfAllMoves();
+            CNCDriver::spindleOnCCW(com->hasS() ? com->S : 0);
+        }
+#endif // defined
+        break;
+    case 5: // Spindle/laser off
+#if defined(SUPPORT_LASER) && SUPPORT_LASER
+        if(Printer::mode == PRINTER_MODE_LASER) {
+            LaserDriver::laserOn = false;
+        }
+#endif // defined
+#if defined(SUPPORT_CNC) && SUPPORT_CNC
+        if(Printer::mode == PRINTER_MODE_CNC) {
+            waitUntilEndOfAllMoves();
+            CNCDriver::spindleOff();
+        }
+#endif // defined
+        break;
 #if SDSUPPORT
     case 20: // M20 - list SD card
+#if JSON_OUTPUT
+       if (com->hasString() && com->text[1] == '2') { // " S2 P/folder"
+            if (com->text[3] == 'P') {
+                sd.lsJSON(com->text + 4);
+            }
+        } else sd.ls();
+#else
         sd.ls();
+#endif
         break;
     case 21: // M21 - init SD card
         sd.mount();
@@ -1473,6 +1598,13 @@ void Commands::processMCode(GCode *com)
             sd.makeDirectory(com->text);
         }
         break;
+#endif
+#if JSON_OUTPUT && SDSUPPORT
+    case 36: // M36 JSON File Info
+        if (com->hasString()) {
+            sd.JSONFileInfo(com->text);
+        }
+        break;
 #endif
     case 42: //M42 -Change pin status via gcode
         if (com->hasP())
@@ -1687,9 +1819,10 @@ void Commands::processMCode(GCode *com)
     previousMillisCmd = HAL::timeInMilliseconds();
     break;
     case 190: // M190 - Wait bed for heater to reach target.
+		{
 #if HAVE_HEATED_BED
         if(Printer::debugDryrun()) break;
-        UI_STATUS_UPD(UI_TEXT_HEATING_BED);
+        UI_STATUS_UPD_F(Com::translatedF(UI_TEXT_HEATING_BED_ID));
         Commands::waitUntilEndOfAllMoves();
 #if HAVE_HEATED_BED
         if (com->hasS()) Extruder::setHeatedBedTemperature(com->S,com->hasF() && com->F > 0);
@@ -1697,6 +1830,7 @@ void Commands::processMCode(GCode *com)
         if(abs(heatedBedController.currentTemperatureC - heatedBedController.targetTemperatureC) < SKIP_M190_IF_WITHIN) break;
 #endif
         EVENT_WAITING_HEATER(-1);
+	    uint32_t codenum; //throw away variable
         codenum = HAL::timeInMilliseconds();
         while(heatedBedController.currentTemperatureC + 0.5 < heatedBedController.targetTemperatureC && heatedBedController.targetTemperatureC > 25.0)
         {
@@ -1712,7 +1846,9 @@ void Commands::processMCode(GCode *com)
 #endif
         UI_CLEAR_STATUS;
         previousMillisCmd = HAL::timeInMilliseconds();
+		}
         break;
+#if NUM_TEMPERATURE_LOOPS > 0
     case 116: // Wait for temperatures to reach target temperature
         for(fast8_t h = 0; h < NUM_TEMPERATURE_LOOPS; h++)
         {
@@ -1721,42 +1857,48 @@ void Commands::processMCode(GCode *com)
             EVENT_HEATING_FINISHED(h < NUM_EXTRUDER ? h : -1);
         }
         break;
-
+#endif
 #if FAN_PIN>-1 && FEATURE_FAN_CONTROL
     case 106: // M106 Fan On
         if(!(Printer::flag2 & PRINTER_FLAG2_IGNORE_M106_COMMAND))
         {
-            setFanSpeed(com->hasS() ? com->S : 255, com->hasP());
+            if(com->hasP() && com->P == 1)
+	            setFan2Speed(com->hasS() ? com->S : 255);
+			else
+	            setFanSpeed(com->hasS() ? com->S : 255);
         }
         break;
     case 107: // M107 Fan Off
-        setFanSpeed(0, com->hasP());
+        if(com->hasP() && com->P == 1)
+	        setFan2Speed(0);
+		else
+	        setFanSpeed(0);
         break;
 #endif
     case 111: // M111 enable/disable run time debug flags
-        if(com->hasS()) Printer::debugLevel = com->S;
+        if(com->hasS()) Printer::setDebugLevel(static_cast<uint8_t>(com->S));
         if(com->hasP())
         {
-            if (com->P > 0) Printer::debugLevel |= com->P;
+            if (com->P > 0) Printer::debugSet(static_cast<uint8_t>(com->P));
-            else Printer::debugLevel &= ~(-com->P);
+            else Printer::debugReset(static_cast<uint8_t>(-com->P));
         }
         if(Printer::debugDryrun())   // simulate movements without printing
         {
-            Extruder::setTemperatureForExtruder(0, 0);
 #if NUM_EXTRUDER > 1
             for(uint8_t i = 0; i < NUM_EXTRUDER; i++)
                 Extruder::setTemperatureForExtruder(0, i);
 #else
             Extruder::setTemperatureForExtruder(0, 0);
 #endif
-#if HEATED_BED_TYPE!=0
+#if HAVE_HEATED_BED != 0
-            target_bed_raw = 0;
+            Extruder::setHeatedBedTemperature(0,false);
 #endif
         }
         break;
     case 115: // M115
         Com::printFLN(Com::tFirmware);
         reportPrinterUsage();
+        Printer::reportPrinterMode();
         break;
     case 114: // M114
         printCurrentPosition(PSTR("M114 "));
@@ -1783,6 +1925,7 @@ void Commands::processMCode(GCode *com)
     case 163: // M163 S<extruderNum> P<weight>  - Set weight for this mixing extruder drive
         if(com->hasS() && com->hasP() && com->S < NUM_EXTRUDER && com->S >= 0)
             Extruder::setMixingWeight(com->S, com->P);
+		Extruder::recomputeMixingExtruderSteps();
         break;
     case 164: /// M164 S<virtNum> P<0 = dont store eeprom,1 = store to eeprom> - Store weights as virtual extruder S
         if(!com->hasS() || com->S < 0 || com->S >= VIRTUAL_EXTRUDER) break; // ignore illigal values
@@ -1894,6 +2037,22 @@ void Commands::processMCode(GCode *com)
     case 221: // M221 S<Extrusion flow multiplier in percent>
         changeFlowrateMultiply(com->getS(100));
         break;
+    case 228: // M228 P<pin> S<state 0/1> - Wait for pin getting state S
+        if(!com->hasS() || !com->hasP())
+            break;
+        {
+            bool comp = com->S;
+            if(com->hasX()) {
+                if(com->X == 0)
+                    HAL::pinMode(com->S,INPUT);
+                else
+                    HAL::pinMode(com->S,INPUT_PULLUP);
+            }
+            do {
+                Commands::checkForPeriodicalActions(true);
+            } while(HAL::digitalRead(com->P) != comp);
+        }
+        break;
 #if USE_ADVANCE
     case 223: // M223 Extruder interrupt test
         if(com->hasS())
@@ -2088,6 +2247,38 @@ void Commands::processMCode(GCode *com)
     case 402: // M402 Go to stored position
         Printer::GoToMemoryPosition(com->hasX(),com->hasY(),com->hasZ(),com->hasE(),(com->hasF() ? com->F : Printer::feedrate));
         break;
+#if JSON_OUTPUT
+    case 408:
+        Printer::showJSONStatus(com->hasS() ? static_cast<int>(com->S) : 0);
+        break;
+#endif
+    case 450:
+        Printer::reportPrinterMode();
+        break;
+    case 451:
+        Printer::mode = PRINTER_MODE_FFF;
+        Printer::reportPrinterMode();
+        break;
+    case 452:
+#if defined(SUPPORT_LASER) && SUPPORT_LASER
+        Printer::mode = PRINTER_MODE_LASER;
+#endif
+        Printer::reportPrinterMode();
+        break;
+    case 453:
+#if defined(SUPPORT_CNC) && SUPPORT_CNC
+        Printer::mode = PRINTER_MODE_CNC;
+#endif
+        Printer::reportPrinterMode();
+        break;
+#if FAN_THERMO_PIN > -1
+	case 460: // M460 X<minTemp> Y<maxTemp> : Set temperature range for thermo controlled fan
+		if(com->hasX())
+			Printer::thermoMinTemp = com->X;
+		if(com->hasY())
+			Printer::thermoMaxTemp = com->Y;
+		break;
+#endif
     case 500: // M500
     {
 #if EEPROM_MODE != 0
@@ -2251,6 +2442,31 @@ void Commands::processMCode(GCode *com)
         dacCommitEeprom();
 #endif
         break;
+#if 0 && UI_DISPLAY_TYPE != NO_DISPLAY
+    // some debuggingcommands normally disabled
+    case 888:
+        Com::printFLN(PSTR("Selected language:"),(int)Com::selectedLanguage);
+        Com::printF(PSTR("Translation:"));
+        Com::printFLN(Com::translatedF(0));
+        break;
+    case 889:
+        uid.showLanguageSelectionWizard();
+        break;
+    case 890:
+        {
+            if(com->hasX() && com->hasY()) {
+                float c = Printer::bendingCorrectionAt(com->X,com->Y);
+                Com::printF(PSTR("Bending at ("),com->X);
+                Com::printF(PSTR(","),com->Y);
+                Com::printFLN(PSTR(") = "),c);
+            }
+        }
+        break;
+    case 891:
+        if(com->hasS())
+            EEPROM::setVersion(com->S);
+        break;
+#endif
     default:
         if(!EVENT_UNHANDLED_M_CODE(com) && Printer::debugErrors())
         {
@@ -2291,6 +2507,14 @@ void Commands::executeGCode(GCode *com)
             com->printCommand();
         }
     }
+#ifdef DEBUG_DRYRUN_ERROR
+    if(Printer::debugDryrun()) {
+        Com::printFLN("Dryrun was enabled");
+        com->printCommand();
+        Printer::debugReset(8);
+    }
+#endif
+
 }
 
 void Commands::emergencyStop()
@@ -2303,7 +2527,7 @@ void Commands::emergencyStop()
     Extruder::manageTemperatures();
     for(uint8_t i = 0; i < NUM_EXTRUDER + 3; i++)
         pwm_pos[i] = 0;
-#if EXT0_HEATER_PIN > -1
+#if EXT0_HEATER_PIN > -1 && NUM_EXTRUDER > 0
     WRITE(EXT0_HEATER_PIN,HEATER_PINS_INVERTED);
 #endif
 #if defined(EXT1_HEATER_PIN) && EXT1_HEATER_PIN > -1 && NUM_EXTRUDER > 1
@@ -2324,10 +2548,10 @@ void Commands::emergencyStop()
 #if FAN_PIN > -1 && FEATURE_FAN_CONTROL
     WRITE(FAN_PIN, 0);
 #endif
-#if HEATED_BED_HEATER_PIN > -1
+#if HAVE_HEATED_BED && HEATED_BED_HEATER_PIN > -1
     WRITE(HEATED_BED_HEATER_PIN, HEATER_PINS_INVERTED);
 #endif
-    UI_STATUS_UPD(UI_TEXT_KILLED);
+    UI_STATUS_UPD_F(Com::translatedF(UI_TEXT_KILLED_ID));
     HAL::delayMilliseconds(200);
     InterruptProtectedBlock noInts;
     while(1) {}
@@ -2349,5 +2573,3 @@ void Commands::writeLowestFreeRAM()
         Com::printFLN(Com::tFreeRAM, lowestRAMValue);
     }
 }
-
-

Repetier/Commands.h

@@ -37,7 +37,8 @@ public:
     static void waitUntilEndOfAllBuffers();
     static void printCurrentPosition(FSTRINGPARAM(s));
     static void printTemperatures(bool showRaw = false);
-    static void setFanSpeed(int speed,bool wait); /// Set fan speed 0..255
+    static void setFanSpeed(int speed, bool immediately = false); /// Set fan speed 0..255
+    static void setFan2Speed(int speed); /// Set fan speed 0..255
     static void changeFeedrateMultiply(int factorInPercent);
     static void changeFlowrateMultiply(int factorInPercent);
     static void reportPrinterUsage();
@@ -50,5 +51,3 @@ private:
 };
 
 #endif // COMMANDS_H_INCLUDED
-
-

Repetier/Communication.cpp

@@ -21,15 +21,23 @@
 
 #include "Repetier.h"
 
+#if UI_DISPLAY_TYPE != NO_DISPLAY
+uint8_t Com::selectedLanguage;
+#endif
+
+#ifndef MACHINE_TYPE
 #if DRIVE_SYSTEM == DELTA
-FSTRINGVALUE(Com::tFirmware,"FIRMWARE_NAME:Repetier_" REPETIER_VERSION " FIRMWARE_URL:https://github.com/repetier/Repetier-Firmware/ PROTOCOL_VERSION:1.0 MACHINE_TYPE:Delta EXTRUDER_COUNT:" XSTR(NUM_EXTRUDER) " REPETIER_PROTOCOL:3")
+#define MACHINE_TYPE "Delta"
+#elif DRIVE_SYSTEM == CARTESIAN
+#define MACHINE_TYPE "Mendel"
 #else
-#if DRIVE_SYSTEM == CARTESIAN
+#define MACHINE_TYPE "Core_XY"
-FSTRINGVALUE(Com::tFirmware,"FIRMWARE_NAME:Repetier_" REPETIER_VERSION " FIRMWARE_URL:https://github.com/repetier/Repetier-Firmware/ PROTOCOL_VERSION:1.0 MACHINE_TYPE:Mendel EXTRUDER_COUNT:" XSTR(NUM_EXTRUDER) " REPETIER_PROTOCOL:3")
-#else
-FSTRINGVALUE(Com::tFirmware,"FIRMWARE_NAME:Repetier_" REPETIER_VERSION " FIRMWARE_URL:https://github.com/repetier/Repetier-Firmware/ PROTOCOL_VERSION:1.0 MACHINE_TYPE:Core_XY EXTRUDER_COUNT:" XSTR(NUM_EXTRUDER) " REPETIER_PROTOCOL:3")
 #endif
 #endif
+#ifndef FIRMWARE_URL
+#define FIRMWARE_URL "https://github.com/repetier/Repetier-Firmware/"
+#endif // FIRMWARE_URL
+FSTRINGVALUE(Com::tFirmware,"FIRMWARE_NAME:Repetier_" REPETIER_VERSION " FIRMWARE_URL:" FIRMWARE_URL " PROTOCOL_VERSION:1.0 MACHINE_TYPE:" MACHINE_TYPE " EXTRUDER_COUNT:" XSTR(NUM_EXTRUDER) " REPETIER_PROTOCOL:3")
 FSTRINGVALUE(Com::tDebug,"Debug:")
 FSTRINGVALUE(Com::tOk,"ok")
 FSTRINGVALUE(Com::tNewline,"\r\n")
@@ -83,9 +91,23 @@ FSTRINGVALUE(Com::tSpaceRaw," RAW")
 FSTRINGVALUE(Com::tColon,":")
 FSTRINGVALUE(Com::tSlash,"/")
 FSTRINGVALUE(Com::tSpaceSlash," /")
+#if JSON_OUTPUT
+FSTRINGVALUE(Com::tJSONDir,"{\"dir\":\"")
+FSTRINGVALUE(Com::tJSONFiles,"\",\"files\":[")
+FSTRINGVALUE(Com::tJSONArrayEnd,"]}")
+FSTRINGVALUE(Com::tJSONErrorStart,"{\"err\":\"")
+FSTRINGVALUE(Com::tJSONErrorEnd,"\"}")
+FSTRINGVALUE(Com::tJSONFileInfoStart, "{\"err\":0,\"size\":");
+FSTRINGVALUE(Com::tJSONFileInfoHeight, ",\"height\":");
+FSTRINGVALUE(Com::tJSONFileInfoLayerHeight, ",\"layerHeight\":");
+FSTRINGVALUE(Com::tJSONFileInfoFilament, ",\"filament\":[");
+FSTRINGVALUE(Com::tJSONFileInfoGeneratedBy, "],\"generatedBy\":\"");
+FSTRINGVALUE(Com::tJSONFileInfoName, ",\"fileName\":\"");
+#endif // JSON_OUTPUT
 FSTRINGVALUE(Com::tSpeedMultiply,"SpeedMultiply:")
 FSTRINGVALUE(Com::tFlowMultiply,"FlowMultiply:")
 FSTRINGVALUE(Com::tFanspeed,"Fanspeed:")
+FSTRINGVALUE(Com::tFan2speed,"Fanspeed2:")
 FSTRINGVALUE(Com::tPrintedFilament,"Printed filament:")
 FSTRINGVALUE(Com::tPrintingTime,"Printing time:")
 FSTRINGVALUE(Com::tSpacem,"m ")
@@ -122,7 +144,6 @@ FSTRINGVALUE(Com::tEEPROMUpdated,"EEPROM updated")
 
 FSTRINGVALUE(Com::tLinearLColon,"linear L:")
 FSTRINGVALUE(Com::tQuadraticKColon," quadratic K:")
-FSTRINGVALUE(Com::tExtruderJam, UI_TEXT_EXTRUDER_JAM)
 FSTRINGVALUE(Com::tFilamentSlipping,"Filament slipping")
 FSTRINGVALUE(Com::tPauseCommunication,"// action:pause")
 FSTRINGVALUE(Com::tContinueCommunication,"// action:resume")
@@ -235,6 +256,7 @@ FSTRINGVALUE(Com::tWait,WAITING_IDENTIFIER)
 #if EEPROM_MODE == 0
 FSTRINGVALUE(Com::tNoEEPROMSupport,"No EEPROM support compiled.\r\n")
 #else
+FSTRINGVALUE(Com::tZProbeOffsetZ, "Coating thickness [mm]")
 #if FEATURE_Z_PROBE
 FSTRINGVALUE(Com::tZProbeHeight,"Z-probe height [mm]")
 FSTRINGVALUE(Com::tZProbeBedDitance,"Max. z-probe - bed dist. [mm]")
@@ -242,12 +264,15 @@ FSTRINGVALUE(Com::tZProbeOffsetX,"Z-probe offset x [mm]")
 FSTRINGVALUE(Com::tZProbeOffsetY,"Z-probe offset y [mm]")
 FSTRINGVALUE(Com::tZProbeSpeed,"Z-probe speed [mm/s]")
 FSTRINGVALUE(Com::tZProbeSpeedXY,"Z-probe x-y-speed [mm/s]")
-FSTRINGVALUE(Com::tZProbeX1,"Z-probe X1")
+FSTRINGVALUE(Com::tZProbeX1,"Z-probe X1 [mm]")
-FSTRINGVALUE(Com::tZProbeY1,"Z-probe Y1")
+FSTRINGVALUE(Com::tZProbeY1,"Z-probe Y1 [mm]")
-FSTRINGVALUE(Com::tZProbeX2,"Z-probe X2")
+FSTRINGVALUE(Com::tZProbeX2,"Z-probe X2 [mm]")
-FSTRINGVALUE(Com::tZProbeY2,"Z-probe Y2")
+FSTRINGVALUE(Com::tZProbeY2,"Z-probe Y2 [mm]")
-FSTRINGVALUE(Com::tZProbeX3,"Z-probe X3")
+FSTRINGVALUE(Com::tZProbeX3,"Z-probe X3 [mm]")
-FSTRINGVALUE(Com::tZProbeY3,"Z-probe Y3")
+FSTRINGVALUE(Com::tZProbeY3,"Z-probe Y3 [mm]")
+FSTRINGVALUE(Com::zZProbeBendingCorA,"Z-probe bending correction A [mm]")
+FSTRINGVALUE(Com::zZProbeBendingCorB,"Z-probe bending correction B [mm]")
+FSTRINGVALUE(Com::zZProbeBendingCorC,"Z-probe bending correction C [mm]")
 #endif
 #if FEATURE_AXISCOMP
 FSTRINGVALUE(Com::tAxisCompTanXY,"tanXY Axis Compensation")
@@ -267,6 +292,7 @@ FSTRINGVALUE(Com::tEPR1,"EPR:1 ")
 FSTRINGVALUE(Com::tEPR2,"EPR:2 ")
 FSTRINGVALUE(Com::tEPR3,"EPR:3 ")
 FSTRINGVALUE(Com::tEPRBaudrate,"Baudrate")
+FSTRINGVALUE(Com::tLanguage,"Language")
 FSTRINGVALUE(Com::tEPRFilamentPrinted,"Filament printed [m]")
 FSTRINGVALUE(Com::tEPRPrinterActive,"Printer active [s]")
 FSTRINGVALUE(Com::tEPRMaxInactiveTime,"Max. inactive time [ms,0=off]")
@@ -281,6 +307,7 @@ FSTRINGVALUE(Com::tEPRXBacklash,"X backlash [mm]")
 FSTRINGVALUE(Com::tEPRYBacklash,"Y backlash [mm]")
 FSTRINGVALUE(Com::tEPRZBacklash,"Z backlash [mm]")
 FSTRINGVALUE(Com::tEPRMaxJerk,"Max. jerk [mm/s]")
+FSTRINGVALUE(Com::tEPRAccelerationFactorAtTop,"Acceleration factor at top [%,100=like bottom]")
 #if DRIVE_SYSTEM==DELTA
 FSTRINGVALUE(Com::tEPRZAcceleration,"Acceleration [mm/s^2]")
 FSTRINGVALUE(Com::tEPRZTravelAcceleration,"Travel acceleration [mm/s^2]")
@@ -357,8 +384,8 @@ FSTRINGVALUE(Com::tEPRAdvanceL,"advance L [0=off]")
 
 #endif
 #if SDSUPPORT
-FSTRINGVALUE(Com::tSDRemoved,UI_TEXT_SD_REMOVED)
+//FSTRINGVALUE(Com::tSDRemoved,UI_TEXT_SD_REMOVED)
-FSTRINGVALUE(Com::tSDInserted,UI_TEXT_SD_INSERTED)
+//FSTRINGVALUE(Com::tSDInserted,UI_TEXT_SD_INSERTED)
 FSTRINGVALUE(Com::tSDInitFail,"SD init fail")
 FSTRINGVALUE(Com::tErrorWritingToFile,"error writing to file")
 FSTRINGVALUE(Com::tBeginFileList,"Begin file list")
@@ -401,6 +428,12 @@ FSTRINGVALUE(Com::tExtrDot,"Extr.")
 FSTRINGVALUE(Com::tMCPEpromSettings,  "MCP4728 DAC EEPROM Settings:")
 FSTRINGVALUE(Com::tMCPCurrentSettings,"MCP4728 DAC Current Settings:")
 #endif
+FSTRINGVALUE(Com::tPrinterModeFFF,"PrinterMode:FFF")
+FSTRINGVALUE(Com::tPrinterModeLaser,"PrinterMode:Laser")
+FSTRINGVALUE(Com::tPrinterModeCNC,"PrinterMode:CNC")
+#ifdef STARTUP_GCODE
+FSTRINGVALUE(Com::tStartupGCode,STARTUP_GCODE)
+#endif
 
 void Com::config(FSTRINGPARAM(text)) {
     printF(tConfig);
@@ -590,4 +623,3 @@ void Com::printFloat(float number, uint8_t digits)
   }
 }
 
-

Repetier/Communication.h

@@ -67,6 +67,19 @@ FSTRINGVAR(tFreeRAM)
 FSTRINGVAR(tXColon)
 FSTRINGVAR(tSlash)
 FSTRINGVAR(tSpaceSlash)
+#if JSON_OUTPUT
+FSTRINGVAR(tJSONDir)
+FSTRINGVAR(tJSONFiles)
+FSTRINGVAR(tJSONArrayEnd)
+FSTRINGVAR(tJSONErrorStart)
+FSTRINGVAR(tJSONErrorEnd)
+FSTRINGVAR(tJSONFileInfoStart)
+FSTRINGVAR(tJSONFileInfoHeight)
+FSTRINGVAR(tJSONFileInfoLayerHeight)
+FSTRINGVAR(tJSONFileInfoFilament)
+FSTRINGVAR(tJSONFileInfoGeneratedBy)
+FSTRINGVAR(tJSONFileInfoName)
+#endif
 FSTRINGVAR(tSpaceXColon)
 FSTRINGVAR(tSpaceYColon)
 FSTRINGVAR(tSpaceZColon)
@@ -82,6 +95,7 @@ FSTRINGVAR(tColon)
 FSTRINGVAR(tSpeedMultiply)
 FSTRINGVAR(tFlowMultiply)
 FSTRINGVAR(tFanspeed)
+FSTRINGVAR(tFan2speed)
 FSTRINGVAR(tPrintedFilament)
 FSTRINGVAR(tPrintingTime)
 FSTRINGVAR(tSpacem)
@@ -117,7 +131,6 @@ FSTRINGVAR(tCommaSpeedEqual)
 FSTRINGVAR(tLinearLColon)
 FSTRINGVAR(tQuadraticKColon)
 FSTRINGVAR(tEEPROMUpdated)
-FSTRINGVAR(tExtruderJam)
 FSTRINGVAR(tFilamentSlipping)
 FSTRINGVAR(tPauseCommunication)
 FSTRINGVAR(tContinueCommunication)
@@ -236,6 +249,7 @@ FSTRINGVAR(tWait)
 #if EEPROM_MODE==0
 FSTRINGVAR(tNoEEPROMSupport)
 #else
+FSTRINGVAR(tZProbeOffsetZ)
 #if FEATURE_Z_PROBE
 FSTRINGVAR(tZProbeHeight)
 FSTRINGVAR(tZProbeOffsetX)
@@ -248,6 +262,9 @@ FSTRINGVAR(tZProbeX2)
 FSTRINGVAR(tZProbeY2)
 FSTRINGVAR(tZProbeX3)
 FSTRINGVAR(tZProbeY3)
+FSTRINGVAR(zZProbeBendingCorA)
+FSTRINGVAR(zZProbeBendingCorB)
+FSTRINGVAR(zZProbeBendingCorC)
 #endif
 #if FEATURE_AUTOLEVEL
 FSTRINGVAR(tAutolevelActive)
@@ -265,6 +282,7 @@ FSTRINGVAR(tEPR0)
 FSTRINGVAR(tEPR1)
 FSTRINGVAR(tEPR2)
 FSTRINGVAR(tEPR3)
+FSTRINGVAR(tLanguage)
 FSTRINGVAR(tEPRBaudrate)
 FSTRINGVAR(tEPRFilamentPrinted)
 FSTRINGVAR(tEPRPrinterActive)
@@ -282,6 +300,7 @@ FSTRINGVAR(tEPRYBacklash)
 FSTRINGVAR(tEPRZBacklash)
 FSTRINGVAR(tEPRZAcceleration)
 FSTRINGVAR(tEPRZTravelAcceleration)
+FSTRINGVAR(tEPRAccelerationFactorAtTop)
 FSTRINGVAR(tEPRZStepsPerMM)
 FSTRINGVAR(tEPRZMaxFeedrate)
 FSTRINGVAR(tEPRZHomingFeedrate)
@@ -342,8 +361,8 @@ FSTRINGVAR(tEPRAdvanceK)
 FSTRINGVAR(tEPRAdvanceL)
 #endif
 #if SDSUPPORT
-FSTRINGVAR(tSDRemoved)
+//FSTRINGVAR(tSDRemoved)
-FSTRINGVAR(tSDInserted)
+//FSTRINGVAR(tSDInserted)
 FSTRINGVAR(tSDInitFail)
 FSTRINGVAR(tErrorWritingToFile)
 FSTRINGVAR(tBeginFileList)
@@ -386,6 +405,12 @@ FSTRINGVAR(tExtrDot)
 FSTRINGVAR(tMCPEpromSettings)
 FSTRINGVAR(tMCPCurrentSettings)
 #endif
+FSTRINGVAR(tPrinterModeFFF)
+FSTRINGVAR(tPrinterModeLaser)
+FSTRINGVAR(tPrinterModeCNC)
+#ifdef STARTUP_GCODE
+FSTRINGVAR(tStartupGCode)
+#endif
 
 static void config(FSTRINGPARAM(text));
 static void config(FSTRINGPARAM(text),int value);
@@ -422,6 +447,11 @@ static inline void print(char c) {HAL::serialWriteByte(c);}
 static void printFloat(float number, uint8_t digits);
 static inline void print(float number) {printFloat(number, 6);}
 static inline void println() {HAL::serialWriteByte('\r');HAL::serialWriteByte('\n');}
+#if UI_DISPLAY_TYPE != NO_DISPLAY
+static const char* translatedF(int textId);
+static void selectLanguage(fast8_t lang);
+static uint8_t selectedLanguage;
+#endif
     protected:
     private:
 };
@@ -444,5 +474,3 @@ static inline void println() {HAL::serialWriteByte('\r');HAL::serialWriteByte('\
 #endif
 
 #endif // COMMUNICATION_H
-
-

Repetier/Configuration.h

@@ -43,8 +43,17 @@
 // ################## EDIT THESE SETTINGS MANUALLY ################
 // ################ END MANUAL SETTINGS ##########################
 
+#undef FAN_PIN
 #define FAN_PIN -1
+#undef FAN_BOARD_PIN
 #define FAN_BOARD_PIN -1
+#define FAN_THERMO_PIN -1
+#define FAN_THERMO_MIN_PWM 128
+#define FAN_THERMO_MAX_PWM 255
+#define FAN_THERMO_MIN_TEMP 45
+#define FAN_THERMO_MAX_TEMP 60
+#define FAN_THERMO_THERMISTOR_PIN -1
+#define FAN_THERMO_THERMISTOR_TYPE 1
 
 //#define EXTERNALSERIAL  use Arduino serial library instead of build in. Requires more ram, has only 63 byte input buffer.
 // Uncomment the following line if you are using arduino compatible firmware made for Arduino version earlier then 1.0
@@ -77,7 +86,7 @@
 #define EXT0_STEP_PIN ORIG_E0_STEP_PIN
 #define EXT0_DIR_PIN ORIG_E0_DIR_PIN
 #define EXT0_INVERSE 0
-#define EXT0_ENABLE_PIN E0_ENABLE_PIN
+#define EXT0_ENABLE_PIN ORIG_E0_ENABLE_PIN
 #define EXT0_ENABLE_ON 0
 #define EXT0_MAX_FEEDRATE 50
 #define EXT0_MAX_START_FEEDRATE 20
@@ -112,7 +121,7 @@
 #define EXT1_STEP_PIN ORIG_E1_STEP_PIN
 #define EXT1_DIR_PIN ORIG_E1_DIR_PIN
 #define EXT1_INVERSE 0
-#define EXT1_ENABLE_PIN E1_ENABLE_PIN
+#define EXT1_ENABLE_PIN ORIG_E1_ENABLE_PIN
 #define EXT1_ENABLE_ON 0
 #define EXT1_MAX_FEEDRATE 50
 #define EXT1_MAX_START_FEEDRATE 20
@@ -198,11 +207,60 @@
 #define MIN_DEFECT_TEMPERATURE -10
 #define MAX_DEFECT_TEMPERATURE 290
 
+// ##########################################################################################
+// ##                             Laser configuration                                      ##
+// ##########################################################################################
+
+/*
+If the firmware is in laser mode, it can control a laser output to cut or engrave materials.
+Please use this feature only if you know about safety and required protection. Lasers are
+dangerous and can hurt or make you blind!!!
+
+The default laser driver only supports laser on and off. Here you control the eíntensity with
+your feedrate. For exchangeable diode lasers this is normally enough. If you need more control
+you can set the intensity in a range 0-255 with a custom extension to the driver. See driver.h
+and comments on how to extend the functions non invasive with our event system.
+
+If you have a laser - powder system you will like your E override. If moves contain a
+increasing extruder position it will laser that move. With this trick you can
+use existing fdm slicers to laser the output. Laser width is extrusion width.
+
+Other tools may use M3 and M5 to enable/disable laser. Here G1/G2/G3 moves have laser enabled
+and G0 moves have it disables.
+
+In any case, laser only enables while moving. At the end of a move it gets
+automatically disabled.
+*/
+
+#define SUPPORT_LASER 0
+#define LASER_PIN -1
+#define LASER_ON_HIGH 1
+
+// ##                              CNC configuration                                       ##
+
+/*
+If the firmware is in CNC mode, it can control a mill with M3/M4/M5. It works
+similar to laser mode, but mill keeps enabled during G0 moves and it allows
+setting rpm (only with event extension that supports this) and milling direction.
+It also can add a delay to wait for spindle to run on full speed.
+*/
+
+#define SUPPORT_CNC 0
+#define CNC_WAIT_ON_ENABLE 300
+#define CNC_WAIT_ON_DISABLE 0
+#define CNC_ENABLE_PIN -1
+#define CNC_ENABLE_WITH 1
+#define CNC_DIRECTION_PIN -1
+#define CNC_DIRECTION_CW 1
+
+
+#define DEFAULT_PRINTER_MODE 0
+
 // ################ Endstop configuration #####################
 
 #define ENDSTOP_PULLUP_X_MIN true
-#define ENDSTOP_X_MIN_INVERTING true
+#define ENDSTOP_X_MIN_INVERTING false
-#define MIN_HARDWARE_ENDSTOP_X true
+#define MIN_HARDWARE_ENDSTOP_X false
 #define ENDSTOP_PULLUP_Y_MIN true
 #define ENDSTOP_Y_MIN_INVERTING true
 #define MIN_HARDWARE_ENDSTOP_Y true
@@ -210,8 +268,8 @@
 #define ENDSTOP_Z_MIN_INVERTING false
 #define MIN_HARDWARE_ENDSTOP_Z false
 #define ENDSTOP_PULLUP_X_MAX true
-#define ENDSTOP_X_MAX_INVERTING false
+#define ENDSTOP_X_MAX_INVERTING true
-#define MAX_HARDWARE_ENDSTOP_X false
+#define MAX_HARDWARE_ENDSTOP_X true
 #define ENDSTOP_PULLUP_Y_MAX true
 #define ENDSTOP_Y_MAX_INVERTING false
 #define MAX_HARDWARE_ENDSTOP_Y false
@@ -220,10 +278,10 @@
 #define MAX_HARDWARE_ENDSTOP_Z true
 #define max_software_endstop_r true
 
-#define min_software_endstop_x false
+#define min_software_endstop_x true
 #define min_software_endstop_y false
 #define min_software_endstop_z true
-#define max_software_endstop_x true
+#define max_software_endstop_x false
 #define max_software_endstop_y true
 #define max_software_endstop_z false
 #define ENDSTOP_X_BACK_MOVE 5
@@ -232,7 +290,7 @@
 #define ENDSTOP_X_RETEST_REDUCTION_FACTOR 3
 #define ENDSTOP_Y_RETEST_REDUCTION_FACTOR 3
 #define ENDSTOP_Z_RETEST_REDUCTION_FACTOR 3
-#define ENDSTOP_X_BACK_ON_HOME 1
+#define ENDSTOP_X_BACK_ON_HOME 10
 #define ENDSTOP_Y_BACK_ON_HOME 1
 #define ENDSTOP_Z_BACK_ON_HOME 0
 #define ALWAYS_CHECK_ENDSTOPS 0
@@ -249,23 +307,27 @@
 #define INVERT_X_DIR 0
 #define INVERT_Y_DIR 0
 #define INVERT_Z_DIR 0
-#define X_HOME_DIR -1
+#define X_HOME_DIR 1
 #define Y_HOME_DIR -1
 #define Z_HOME_DIR 1
-#define X_MAX_LENGTH 200
+#define X_MAX_LENGTH 155
-#define Y_MAX_LENGTH 180
+#define Y_MAX_LENGTH 155
-#define Z_MAX_LENGTH 135
+#define Z_MAX_LENGTH 145
 #define X_MIN_POS 0
 #define Y_MIN_POS 0
 #define Z_MIN_POS 0
 #define DISTORTION_CORRECTION 0
-#define DISTORTION_CORRECTION_POINTS 5
+#define DISTORTION_CORRECTION_POINTS 3
 #define DISTORTION_CORRECTION_R 100
-#define DISTORTION_PERMANENT 1
+#define DISTORTION_PERMANENT 0
 #define DISTORTION_UPDATE_FREQUENCY 15
 #define DISTORTION_START_DEGRADE 0.5
 #define DISTORTION_END_HEIGHT 1
 #define DISTORTION_EXTRAPOLATE_CORNERS 0
+#define DISTORTION_XMIN 0
+#define DISTORTION_YMIN 0
+#define DISTORTION_XMAX 155
+#define DISTORTION_YMAX 155
 
 // ##########################################################################################
 // ##                           Movement settings                                          ##
@@ -312,6 +374,8 @@
 #define MAX_TRAVEL_ACCELERATION_UNITS_PER_SQ_SECOND_X 1000
 #define MAX_TRAVEL_ACCELERATION_UNITS_PER_SQ_SECOND_Y 1000
 #define MAX_TRAVEL_ACCELERATION_UNITS_PER_SQ_SECOND_Z 500
+#define INTERPOLATE_ACCELERATION_WITH_Z 0
+#define ACCELERATION_FACTOR_TOP 100
 #define MAX_JERK 20
 #define MAX_ZJERK 0.3
 #define PRINTLINE_CACHE_SIZE 16
@@ -320,15 +384,19 @@
 #define FEATURE_TWO_XSTEPPER 0
 #define X2_STEP_PIN   ORIG_E1_STEP_PIN
 #define X2_DIR_PIN    ORIG_E1_DIR_PIN
-#define X2_ENABLE_PIN E1_ENABLE_PIN
+#define X2_ENABLE_PIN ORIG_E1_ENABLE_PIN
 #define FEATURE_TWO_YSTEPPER 0
 #define Y2_STEP_PIN   ORIG_E1_STEP_PIN
 #define Y2_DIR_PIN    ORIG_E1_DIR_PIN
-#define Y2_ENABLE_PIN E1_ENABLE_PIN
+#define Y2_ENABLE_PIN ORIG_E1_ENABLE_PIN
 #define FEATURE_TWO_ZSTEPPER 0
 #define Z2_STEP_PIN   ORIG_E1_STEP_PIN
 #define Z2_DIR_PIN    ORIG_E1_DIR_PIN
-#define Z2_ENABLE_PIN E1_ENABLE_PIN
+#define Z2_ENABLE_PIN ORIG_E1_ENABLE_PIN
+#define FEATURE_THREE_ZSTEPPER 0
+#define Z3_STEP_PIN   ORIG_E2_STEP_PIN
+#define Z3_DIR_PIN    ORIG_E2_DIR_PIN
+#define Z3_ENABLE_PIN ORIG_E2_ENABLE_PIN
 #define FEATURE_DITTO_PRINTING 0
 #define USE_ADVANCE 0
 #define ENABLE_QUADRATIC_ADVANCE 0
@@ -343,8 +411,10 @@
 #define ACK_WITH_LINENUMBER 1
 #define WAITING_IDENTIFIER "wait"
 #define ECHO_ON_EXECUTE 1
-#define EEPROM_MODE 0
+#define EEPROM_MODE 2
+#undef PS_ON_PIN
 #define PS_ON_PIN ORIG_PS_ON_PIN
+#define JSON_OUTPUT 0
 
 /* ======== Servos =======
 Control the servos with
@@ -379,20 +449,33 @@ WARNING: Servos can draw a considerable amount of current. Make sure your system
 #define Z_PROBE_X_OFFSET 6.4
 #define Z_PROBE_Y_OFFSET 0
 #define Z_PROBE_WAIT_BEFORE_TEST 0
-#define Z_PROBE_SPEED 8
+#define Z_PROBE_SPEED 100
 #define Z_PROBE_XY_SPEED 150
 #define Z_PROBE_SWITCHING_DISTANCE 1
 #define Z_PROBE_REPETITIONS 1
-#define Z_PROBE_HEIGHT 7.4
+#define Z_PROBE_HEIGHT 6.9
 #define Z_PROBE_START_SCRIPT ""
 #define Z_PROBE_FINISHED_SCRIPT ""
 #define FEATURE_AUTOLEVEL 1
-#define Z_PROBE_X1 20
+#define Z_PROBE_X1 5
-#define Z_PROBE_Y1 20
+#define Z_PROBE_Y1 5
-#define Z_PROBE_X2 160
+#define Z_PROBE_X2 150
-#define Z_PROBE_Y2 20
+#define Z_PROBE_Y2 5
-#define Z_PROBE_X3 100
+#define Z_PROBE_X3 150
-#define Z_PROBE_Y3 160
+#define Z_PROBE_Y3 150
+#define BED_LEVELING_METHOD 0
+#define BED_CORRECTION_METHOD 0
+#define BED_LEVELING_GRID_SIZE 5
+#define BED_LEVELING_REPETITIONS 5
+#define BED_MOTOR_1_X 0
+#define BED_MOTOR_1_Y 0
+#define BED_MOTOR_2_X 200
+#define BED_MOTOR_2_Y 0
+#define BED_MOTOR_3_X 100
+#define BED_MOTOR_3_Y 200
+#define BENDING_CORRECTION_A 0
+#define BENDING_CORRECTION_B 0
+#define BENDING_CORRECTION_C 0
 #define FEATURE_AXISCOMP 0
 #define AXISCOMP_TANXY 0
 #define AXISCOMP_TANYZ 0
@@ -400,6 +483,7 @@ WARNING: Servos can draw a considerable amount of current. Make sure your system
 
 #ifndef SDSUPPORT  // Some boards have sd support on board. These define the values already in pins.h
 #define SDSUPPORT 0
+#undef SDCARDDETECT
 #define SDCARDDETECT -1
 #define SDCARDDETECTINVERTED 0
 #endif
@@ -410,8 +494,19 @@ WARNING: Servos can draw a considerable amount of current. Make sure your system
 #define FEATURE_MEMORY_POSITION 0
 #define FEATURE_CHECKSUM_FORCED 0
 #define FEATURE_FAN_CONTROL 0
+#define FEATURE_FAN2_CONTROL 0
 #define FEATURE_CONTROLLER 0
-#define UI_LANGUAGE 0
+#define LANGUAGE_EN_ACTIVE 1
+#define LANGUAGE_DE_ACTIVE 1
+#define LANGUAGE_NL_ACTIVE 1
+#define LANGUAGE_PT_ACTIVE 1
+#define LANGUAGE_IT_ACTIVE 1
+#define LANGUAGE_ES_ACTIVE 1
+#define LANGUAGE_SE_ACTIVE 1
+#define LANGUAGE_FR_ACTIVE 1
+#define LANGUAGE_CZ_ACTIVE 1
+#define LANGUAGE_PL_ACTIVE 1
+#define LANGUAGE_TR_ACTIVE 1
 #define UI_PRINTER_NAME "RepRap"
 #define UI_PRINTER_COMPANY "Home made"
 #define UI_PAGES_DURATION 4000
@@ -471,7 +566,7 @@ Values must be in range 1..255
     "zStepsPerMM": 200,
     "xInvert": 0,
     "xInvertEnable": 0,
-    "eepromMode": 0,
+    "eepromMode": 2,
     "yInvert": 0,
     "yInvertEnable": 0,
     "zInvert": 0,
@@ -515,7 +610,7 @@ Values must be in range 1..255
                 "name": "Extruder 0",
                 "step": "ORIG_E0_STEP_PIN",
                 "dir": "ORIG_E0_DIR_PIN",
-                "enable": "E0_ENABLE_PIN"
+                "enable": "ORIG_E0_ENABLE_PIN"
             },
             "advanceBacklashSteps": 0,
             "decoupleTestPeriod": 12,
@@ -560,7 +655,7 @@ Values must be in range 1..255
                 "name": "Extruder 1",
                 "step": "ORIG_E1_STEP_PIN",
                 "dir": "ORIG_E1_DIR_PIN",
-                "enable": "E1_ENABLE_PIN"
+                "enable": "ORIG_E1_ENABLE_PIN"
             },
             "advanceBacklashSteps": 0,
             "decoupleTestPeriod": 12,
@@ -570,10 +665,10 @@ Values must be in range 1..255
     ],
     "uiLanguage": 0,
     "uiController": 0,
-    "xMinEndstop": 1,
+    "xMinEndstop": 0,
     "yMinEndstop": 1,
     "zMinEndstop": 0,
-    "xMaxEndstop": 0,
+    "xMaxEndstop": 1,
     "yMaxEndstop": 0,
     "zMaxEndstop": 1,
     "motherboard": 33,
@@ -617,18 +712,18 @@ Values must be in range 1..255
     "xMinPos": 0,
     "yMinPos": 0,
     "zMinPos": 0,
-    "xLength": 200,
+    "xLength": 155,
-    "yLength": 180,
+    "yLength": 155,
-    "zLength": 135,
+    "zLength": 145,
     "alwaysCheckEndstops": "0",
     "disableX": "0",
     "disableY": "0",
     "disableZ": "0",
     "disableE": "0",
-    "xHomeDir": "-1",
+    "xHomeDir": "1",
     "yHomeDir": "-1",
     "zHomeDir": "1",
-    "xEndstopBack": 1,
+    "xEndstopBack": 10,
     "yEndstopBack": 1,
     "zEndstopBack": 0,
     "deltaSegmentsPerSecondPrint": 180,
@@ -673,21 +768,28 @@ Values must be in range 1..255
         "name": "Extruder 1",
         "step": "ORIG_E1_STEP_PIN",
         "dir": "ORIG_E1_DIR_PIN",
-        "enable": "E1_ENABLE_PIN"
+        "enable": "ORIG_E1_ENABLE_PIN"
     },
     "mirrorY": 0,
     "mirrorYMotor": {
         "name": "Extruder 1",
         "step": "ORIG_E1_STEP_PIN",
         "dir": "ORIG_E1_DIR_PIN",
-        "enable": "E1_ENABLE_PIN"
+        "enable": "ORIG_E1_ENABLE_PIN"
     },
     "mirrorZ": 0,
     "mirrorZMotor": {
         "name": "Extruder 1",
         "step": "ORIG_E1_STEP_PIN",
         "dir": "ORIG_E1_DIR_PIN",
-        "enable": "E1_ENABLE_PIN"
+        "enable": "ORIG_E1_ENABLE_PIN"
+    },
+    "mirrorZ3": "0",
+    "mirrorZ3Motor": {
+        "name": "Extruder 2",
+        "step": "ORIG_E2_STEP_PIN",
+        "dir": "ORIG_E2_DIR_PIN",
+        "enable": "ORIG_E2_ENABLE_PIN"
     },
     "dittoPrinting": "0",
     "featureServos": "0",
@@ -766,17 +868,20 @@ Values must be in range 1..255
     "userTable0": {
         "r1": 0,
         "r2": 4700,
-        "temps": []
+        "temps": [],
+        "numEntries": 0
     },
     "userTable1": {
         "r1": 0,
         "r2": 4700,
-        "temps": []
+        "temps": [],
+        "numEntries": 0
     },
     "userTable2": {
         "r1": 0,
         "r2": 4700,
-        "temps": []
+        "temps": [],
+        "numEntries": 0
     },
     "tempHysteresis": 0,
     "pidControlRange": 20,
@@ -792,6 +897,15 @@ Values must be in range 1..255
     "sdExtendedDir": "1",
     "featureFanControl": "0",
     "fanPin": -1,
+    "featureFan2Control": "0",
+    "fan2Pin": "ORIG_FAN2_PIN",
+    "fanThermoPin": -1,
+    "fanThermoMinPWM": 128,
+    "fanThermoMaxPWM": 255,
+    "fanThermoMinTemp": 45,
+    "fanThermoMaxTemp": 60,
+    "fanThermoThermistorPin": -1,
+    "fanThermoThermistorType": 1,
     "scalePidToMax": 0,
     "zProbePin": "ORIG_Z_MIN_PIN",
     "zProbeBedDistance": 10,
@@ -800,18 +914,18 @@ Values must be in range 1..255
     "zProbeXOffset": 6.4,
     "zProbeYOffset": 0,
     "zProbeWaitBeforeTest": "0",
-    "zProbeSpeed": 8,
+    "zProbeSpeed": 100,
     "zProbeXYSpeed": 150,
-    "zProbeHeight": 7.4,
+    "zProbeHeight": 6.9,
     "zProbeStartScript": "",
     "zProbeFinishedScript": "",
     "featureAutolevel": "1",
-    "zProbeX1": 20,
+    "zProbeX1": 5,
-    "zProbeY1": 20,
+    "zProbeY1": 5,
-    "zProbeX2": 160,
+    "zProbeX2": 150,
-    "zProbeY2": 20,
+    "zProbeY2": 5,
-    "zProbeX3": 100,
+    "zProbeX3": 150,
-    "zProbeY3": 160,
+    "zProbeY3": 150,
     "zProbeSwitchingDistance": 1,
     "zProbeRepetitions": 1,
     "sdSupport": "0",
@@ -849,13 +963,17 @@ Values must be in range 1..255
     "pauseStartCommands": "",
     "pauseEndCommands": "",
     "distortionCorrection": "0",
-    "distortionCorrectionPoints": 5,
+    "distortionCorrectionPoints": 3,
     "distortionCorrectionR": 100,
-    "distortionPermanent": "1",
+    "distortionPermanent": "0",
     "distortionUpdateFrequency": 15,
     "distortionStartDegrade": 0.5,
     "distortionEndDegrade": 1,
     "distortionExtrapolateCorners": "0",
+    "distortionXMin": 0,
+    "distortionXMax": 155,
+    "distortionYMin": 0,
+    "distortionYMax": 155,
     "sdRunOnStop": "",
     "sdStopHeaterMotorsOnStop": "1",
     "featureRetraction": "0",
@@ -966,6 +1084,46 @@ Values must be in range 1..255
     "zProbeZOffsetMode": 0,
     "zProbeZOffset": 0,
     "uiBedCoating": "1",
+    "langEN": "1",
+    "langDE": "1",
+    "langNL": "1",
+    "langPT": "1",
+    "langIT": "1",
+    "langES": "1",
+    "langSE": "1",
+    "langFR": "1",
+    "langCZ": "1",
+    "langPL": "1",
+    "langTR": "1",
+    "interpolateAccelerationWithZ": 0,
+    "accelerationFactorTop": 100,
+    "bendingCorrectionA": 0,
+    "bendingCorrectionB": 0,
+    "bendingCorrectionC": 0,
+    "preventZDisableOnStepperTimeout": "0",
+    "supportLaser": "0",
+    "laserPin": -1,
+    "laserOnHigh": "1",
+    "defaultPrinterMode": 0,
+    "supportCNC": "0",
+    "cncWaitOnEnable": 300,
+    "cncWaitOnDisable": 0,
+    "cncEnablePin": -1,
+    "cncEnableWith": "1",
+    "cncDirectionPin": -1,
+    "cncDirectionCW": "1",
+    "startupGCode": "",
+    "jsonOutput": "0",
+    "bedLevelingMethod": 0,
+    "bedCorrectionMethod": 0,
+    "bedLevelingGridSize": 5,
+    "bedLevelingRepetitions": 5,
+    "bedMotor1X": 0,
+    "bedMotor1Y": 0,
+    "bedMotor2X": 200,
+    "bedMotor2Y": 0,
+    "bedMotor3X": 100,
+    "bedMotor3Y": 200,
     "hasMAX6675": false,
     "hasMAX31855": false,
     "hasGeneric1": false,
@@ -975,7 +1133,7 @@ Values must be in range 1..255
     "hasUser1": false,
     "hasUser2": false,
     "numExtruder": 2,
-    "version": 92.4,
+    "version": 92.8,
     "primaryPortName": ""
 }
 ========== End configuration string ==========

Repetier/Drivers.cpp

@@ -18,7 +18,8 @@ MOTOR_DRIVER_5(motorDriver5);
 MOTOR_DRIVER_6(motorDriver6);
 #endif
 
-MotorDriverInterface *motorDrivers[NUM_MOTOR_DRIVERS] = {
+MotorDriverInterface *motorDrivers[NUM_MOTOR_DRIVERS] =
+{
     &motorDriver1
 #if NUM_MOTOR_DRIVERS > 1
     , &motorDriver2
@@ -37,14 +38,16 @@ MotorDriverInterface *motorDrivers[NUM_MOTOR_DRIVERS] = {
 #endif
 };
 
-MotorDriverInterface *getMotorDriver(int idx) {
+MotorDriverInterface *getMotorDriver(int idx)
+{
     return motorDrivers[idx];
 }
 
 /**
 Run motor P until it is at position X
 */
-void commandG201(GCode &code) {
+void commandG201(GCode &code)
+{
     int id = 0;
     if(code.hasP())
         id = code.P;
@@ -55,7 +58,8 @@ void commandG201(GCode &code) {
 }
 
 //G202 P<motorId> X<setpos>  - Mark current position as X
-void commandG202(GCode &code) {
+void commandG202(GCode &code)
+{
     int id = 0;
     if(code.hasP())
         id = code.P;
@@ -65,7 +69,8 @@ void commandG202(GCode &code) {
     motorDrivers[id]->setCurrentAs(code.X);
 }
 //G203 P<motorId>            - Report current motor position
-void commandG203(GCode &code) {
+void commandG203(GCode &code)
+{
     int id = 0;
     if(code.hasP())
         id = code.P;
@@ -75,7 +80,8 @@ void commandG203(GCode &code) {
     Com::printFLN(PSTR("Pos:"),motorDrivers[id]->getPosition());
 }
 //G204 P<motorId> S<0/1>     - Enable/disable motor
-void commandG204(GCode &code) {
+void commandG204(GCode &code)
+{
     int id = 0;
     if(code.hasP())
         id = code.P;
@@ -88,15 +94,122 @@ void commandG204(GCode &code) {
         motorDrivers[id]->disable();
 }
 
-void disableAllMotorDrivers() {
+void disableAllMotorDrivers()
+{
     for(int i = 0; i < NUM_MOTOR_DRIVERS; i++)
         motorDrivers[i]->disable();
 }
-void initializeAllMotorDrivers() {
+void initializeAllMotorDrivers()
+{
     for(int i = 0; i < NUM_MOTOR_DRIVERS; i++)
         motorDrivers[i]->initialize();
 }
 
 #endif // NUM_MOTOR_DRIVERS
 
+#if defined(SUPPORT_LASER) && SUPPORT_LASER
+uint8_t LaserDriver::intensity = 255; // Intensity to use for next move queued if we want lasers. This is NOT the current value!
+bool LaserDriver::laserOn = false;
+void LaserDriver::initialize()
+{
+    if(EVENT_INITALIZE_LASER)
+    {
+#if LASER_PIN > -1
+        SET_OUTPUT(LASER_PIN);
+#endif
+    }
+    changeIntensity(0);
+}
+void LaserDriver::changeIntensity(uint8_t newIntensity)
+{
+    if(EVENT_SET_LASER(newIntensity))
+    {
+        // Default implementation
+#if LASER_PIN > -1
+        WRITE(LASER_PIN,(LASER_ON_HIGH ? newIntensity > 199 : newIntensity < 200));
+#endif
+    }
+}
+#endif // SUPPORT_LASER
 
+#if defined(SUPPORT_CNC) && SUPPORT_CNC
+/**
+The CNC driver differs a bit from laser driver. Here only M3,M4,M5 have an influence on the spindle.
+The motor also keeps running for G0 moves. M3 and M4 wait for old moves to be finished and then enables
+the motor. It then waits CNC_WAIT_ON_ENABLE milliseconds for the spindle to reach target speed.
+*/
+
+int8_t CNCDriver::direction = 0;
+/** Initialize cnc pins. EVENT_INITALIZE_CNC should return false to prevent default initalization.*/
+void CNCDriver::initialize()
+{
+    if(EVENT_INITALIZE_CNC)
+    {
+#if CNC_ENABLE_PIN > -1
+        SET_OUTPUT(CNC_ENABLE_PIN);
+        WRITE(CNC_ENABLE_PIN,!CNC_ENABLE_WITH);
+#endif
+#if CNC_DIRECTION_PIN > -1
+        SET_OUTPUT(CNC_DIRECTION_PIN);
+#endif
+    }
+}
+/** Turns off spindle. For event override implement
+EVENT_SPINDLE_OFF
+returning false.
+*/
+void CNCDriver::spindleOff()
+{
+    if(direction == 0) return; // already off
+    if(EVENT_SPINDLE_OFF)
+    {
+#if CNC_ENABLE_PIN > -1
+        WRITE(CNC_ENABLE_PIN,!CNC_ENABLE_WITH);
+#endif
+    }
+    HAL::delayMilliseconds(CNC_WAIT_ON_DISABLE);
+	direction = 0;
+}
+/** Turns spindle on. Default implementation uses a enable pin CNC_ENABLE_PIN. If
+CNC_DIRECTION_PIN is not -1 it sets direction to CNC_DIRECTION_CW. rpm is ignored.
+To override with event system, return false for the event
+EVENT_SPINDLE_CW(rpm)
+*/
+void CNCDriver::spindleOnCW(int32_t rpm)
+{
+    if(direction == 1)
+        return;
+    spindleOff();
+    direction = 1;
+    if(EVENT_SPINDLE_CW(rpm)) {
+#if CNC_DIRECTION_PIN > -1
+        WRITE(CNC_DIRECTION_PIN, CNC_DIRECTION_CW);
+#endif
+#if CNC_ENABLE_PIN > -1
+        WRITE(CNC_ENABLE_PIN, CNC_ENABLE_WITH);
+#endif
+    }
+    HAL::delayMilliseconds(CNC_WAIT_ON_ENABLE);
+}
+/** Turns spindle on. Default implementation uses a enable pin CNC_ENABLE_PIN. If
+CNC_DIRECTION_PIN is not -1 it sets direction to !CNC_DIRECTION_CW. rpm is ignored.
+To override with event system, return false for the event
+EVENT_SPINDLE_CCW(rpm)
+*/
+void CNCDriver::spindleOnCCW(int32_t rpm)
+{
+    if(direction == -1)
+        return;
+    spindleOff();
+    direction = -1;
+    if(EVENT_SPINDLE_CW(rpm)) {
+#if CNC_DIRECTION_PIN > -1
+        WRITE(CNC_DIRECTION_PIN, !CNC_DIRECTION_CW);
+#endif
+#if CNC_ENABLE_PIN > -1
+        WRITE(CNC_ENABLE_PIN, CNC_ENABLE_WITH);
+#endif
+    }
+    HAL::delayMilliseconds(CNC_WAIT_ON_ENABLE);
+}
+#endif

Repetier/Drivers.h

@@ -101,6 +101,53 @@ extern MotorDriverInterface *getMotorDriver(int idx);
 extern void initializeAllMotorDrivers();
 #endif
 
+
+#if defined(SUPPORT_LASER) && SUPPORT_LASER
+/**
+With laser support you can exchange a extruder by a laser. A laser gets controlled by a digital pin.
+By default all intensities > 200 are always on, and lower values are always off. You can overwrite
+this with a programmed event EVENT_SET_LASER(intensity) that return false to signal the default
+implementation that it has set it's value already.
+EVENT_INITALIZE_LASER should return false to prevent default initialization.
+*/
+class LaserDriver {
+public:
+    static uint8_t intensity; // Intensity to use for next move queued. This is NOT the current value!
+    static bool laserOn; // Enabled by M3?
+    static void initialize();
+    static void changeIntensity(uint8_t newIntensity);
+};
+#endif
+
+#if defined(SUPPORT_CNC) && SUPPORT_CNC
+/**
+The CNC driver differs a bit from laser driver. Here only M3,M4,M5 have an influence on the spindle.
+The motor also keeps running for G0 moves. M3 and M4 wait for old moves to be finished and then enables
+the motor. It then waits CNC_WAIT_ON_ENABLE milliseconds for the spindle to reach target speed.
+*/
+class CNCDriver {
+public:
+    static int8_t direction;
+    /** Initialize cnc pins. EVENT_INITALIZE_CNC should return false to prevent default initalization.*/
+    static void initialize();
+    /** Turns off spindle. For event override implement
+    EVENT_SPINDLE_OFF
+    returning false.
+    */
+    static void spindleOff();
+    /** Turns spindle on. Default implementation uses a enable pin CNC_ENABLE_PIN. If
+    CNC_DIRECTION_PIN is not -1 it sets direction to CNC_DIRECTION_CW. rpm is ignored.
+    To override with event system, return false for the event
+    EVENT_SPINDLE_CW(rpm)
+    */
+    static void spindleOnCW(int32_t rpm);
+    /** Turns spindle on. Default implementation uses a enable pin CNC_ENABLE_PIN. If
+    CNC_DIRECTION_PIN is not -1 it sets direction to !CNC_DIRECTION_CW. rpm is ignored.
+    To override with event system, return false for the event
+    EVENT_SPINDLE_CCW(rpm)
+    */
+    static void spindleOnCCW(int32_t rpm);
+};
+#endif
+
 #endif // DRIVERS_H_INCLUDED
-
-

Repetier/Eeprom.cpp

@@ -385,6 +385,9 @@ void EEPROM::storeDataIntoEEPROM(uint8_t corrupted)
     HAL::eprSetByte(EPR_AUTOLEVEL_ACTIVE,Printer::isAutolevelActive());
     for(uint8_t i = 0; i < 9; i++)
         HAL::eprSetFloat(EPR_AUTOLEVEL_MATRIX + (((int)i) << 2),Printer::autolevelTransformation[i]);
+#endif
+#if UI_DISPLAY_TYPE != NO_DISPLAY
+    HAL::eprSetByte(EPR_SELECTED_LANGUAGE,Com::selectedLanguage);
 #endif
     // now the extruder
     for(uint8_t i = 0; i < NUM_EXTRUDER; i++)
@@ -453,6 +456,7 @@ void EEPROM::initalizeUncached()
     HAL::eprSetFloat(EPR_Z_PROBE_XY_SPEED,Z_PROBE_XY_SPEED);
     HAL::eprSetFloat(EPR_Z_PROBE_X_OFFSET,Z_PROBE_X_OFFSET);
     HAL::eprSetFloat(EPR_Z_PROBE_Y_OFFSET,Z_PROBE_Y_OFFSET);
+    HAL::eprSetFloat(EPR_Z_PROBE_Z_OFFSET,Z_PROBE_Z_OFFSET);
     HAL::eprSetFloat(EPR_Z_PROBE_X1,Z_PROBE_X1);
     HAL::eprSetFloat(EPR_Z_PROBE_Y1,Z_PROBE_Y1);
     HAL::eprSetFloat(EPR_Z_PROBE_X2,Z_PROBE_X2);
@@ -463,6 +467,7 @@ void EEPROM::initalizeUncached()
     HAL::eprSetFloat(EPR_AXISCOMP_TANYZ,AXISCOMP_TANYZ);
     HAL::eprSetFloat(EPR_AXISCOMP_TANXZ,AXISCOMP_TANXZ);
     HAL::eprSetFloat(EPR_Z_PROBE_BED_DISTANCE,Z_PROBE_BED_DISTANCE);
+    Printer::zBedOffset = HAL::eprGetFloat(EPR_Z_PROBE_Z_OFFSET);
 #if DRIVE_SYSTEM == DELTA
     HAL::eprSetFloat(EPR_DELTA_DIAGONAL_ROD_LENGTH,DELTA_DIAGONAL_ROD);
     HAL::eprSetFloat(EPR_DELTA_HORIZONTAL_RADIUS,ROD_RADIUS);
@@ -495,6 +500,10 @@ void EEPROM::initalizeUncached()
     HAL::eprSetFloat(EPR_RETRACTION_UNDO_EXTRA_LONG_LENGTH,RETRACTION_UNDO_EXTRA_LONG_LENGTH);
     HAL::eprSetFloat(EPR_RETRACTION_UNDO_SPEED,RETRACTION_UNDO_SPEED);
     HAL::eprSetByte(EPR_AUTORETRACT_ENABLED,AUTORETRACT_ENABLED);
+    HAL::eprSetFloat(EPR_BENDING_CORRECTION_A,BENDING_CORRECTION_A);
+    HAL::eprSetFloat(EPR_BENDING_CORRECTION_B,BENDING_CORRECTION_B);
+    HAL::eprSetFloat(EPR_BENDING_CORRECTION_C,BENDING_CORRECTION_C);
+    HAL::eprSetFloat(EPR_ACCELERATION_FACTOR_TOP,Z_ACCELERATION_TOP);
 
 }
 
@@ -502,6 +511,7 @@ void EEPROM::readDataFromEEPROM(bool includeExtruder)
 {
 #if EEPROM_MODE != 0
     uint8_t version = HAL::eprGetByte(EPR_VERSION); // This is the saved version. Don't copy data not set in older versions!
+    //Com::printFLN(PSTR("Detected EEPROM version:"),(int)version);
     baudrate = HAL::eprGetInt32(EPR_BAUDRATE);
     maxInactiveTime = HAL::eprGetInt32(EPR_MAX_INACTIVE_TIME);
     stepperInactiveTime = HAL::eprGetInt32(EPR_STEPPER_INACTIVE_TIME);
@@ -705,6 +715,21 @@ void EEPROM::readDataFromEEPROM(bool includeExtruder)
             HAL::eprSetFloat(EPR_RETRACTION_UNDO_SPEED,RETRACTION_UNDO_SPEED);
             HAL::eprSetByte(EPR_AUTORETRACT_ENABLED,AUTORETRACT_ENABLED);
         }
+        if(version < 14) {
+            HAL::eprSetFloat(EPR_Z_PROBE_Z_OFFSET,Z_PROBE_Z_OFFSET);
+        }
+        if(version < 15) {
+            HAL::eprSetByte(EPR_SELECTED_LANGUAGE, 254); // activate selector on startup
+#if UI_DISPLAY_TYPE != NO_DISPLAY
+            Com::selectedLanguage = 254;
+#endif
+        }
+        if(version < 16) {
+            HAL::eprSetFloat(EPR_BENDING_CORRECTION_A,BENDING_CORRECTION_A);
+            HAL::eprSetFloat(EPR_BENDING_CORRECTION_B,BENDING_CORRECTION_B);
+            HAL::eprSetFloat(EPR_BENDING_CORRECTION_C,BENDING_CORRECTION_C);
+            HAL::eprSetFloat(EPR_ACCELERATION_FACTOR_TOP,ACCELERATION_FACTOR_TOP);
+        }
         /*        if (version<8) {
         #if DRIVE_SYSTEM==DELTA
                   // Prior to verion 8, the cartesian max was stored in the zmax
@@ -723,6 +748,10 @@ void EEPROM::readDataFromEEPROM(bool includeExtruder)
 
         storeDataIntoEEPROM(false); // Store new fields for changed version
     }
+    Printer::zBedOffset = HAL::eprGetFloat(EPR_Z_PROBE_Z_OFFSET);
+#if UI_DISPLAY_TYPE != NO_DISPLAY
+    Com::selectLanguage(HAL::eprGetByte(EPR_SELECTED_LANGUAGE));
+#endif
     Printer::updateDerivedParameter();
     Extruder::initHeatedBed();
 #endif
@@ -762,7 +791,7 @@ void EEPROM::init()
                 if(newcheck != HAL::eprGetByte(EPR_INTEGRITY_BYTE))
                     HAL::eprSetByte(EPR_INTEGRITY_BYTE,newcheck);
             }
-            Com::printFLN(PSTR("EEprom baud rate restored from configuration."));
+            Com::printFLN(PSTR("EEPROM baud rate restored from configuration."));
             Com::printFLN(PSTR("RECOMPILE WITH USE_CONFIGURATION_BAUD_RATE == 0 to alter baud rate via EEPROM"));
         }
     }
@@ -805,6 +834,7 @@ With
 void EEPROM::writeSettings()
 {
 #if EEPROM_MODE != 0
+    writeByte(EPR_SELECTED_LANGUAGE,Com::tLanguage);
     writeLong(EPR_BAUDRATE, Com::tEPRBaudrate);
     writeFloat(EPR_PRINTING_DISTANCE, Com::tEPRFilamentPrinted);
     writeLong(EPR_PRINTING_TIME, Com::tEPRPrinterActive);
@@ -852,6 +882,9 @@ void EEPROM::writeSettings()
 #if DRIVE_SYSTEM == DELTA
     writeFloat(EPR_Z_MAX_ACCEL, Com::tEPRZAcceleration);
     writeFloat(EPR_Z_MAX_TRAVEL_ACCEL, Com::tEPRZTravelAcceleration);
+#if defined(INTERPOLATE_ACCELERATION_WITH_Z) && INTERPOLATE_ACCELERATION_WITH_Z != 0
+    writeFloat(EPR_ACCELERATION_FACTOR_TOP, Com::tEPRAccelerationFactorAtTop);
+#endif
     writeFloat(EPR_DELTA_DIAGONAL_ROD_LENGTH, Com::tEPRDiagonalRodLength);
     writeFloat(EPR_DELTA_HORIZONTAL_RADIUS, Com::tEPRHorizontalRadius);
     writeFloat(EPR_DELTA_MAX_RADIUS, Com::tEPRDeltaMaxRadius);
@@ -876,8 +909,12 @@ void EEPROM::writeSettings()
     writeFloat(EPR_X_MAX_TRAVEL_ACCEL, Com::tEPRXTravelAcceleration);
     writeFloat(EPR_Y_MAX_TRAVEL_ACCEL, Com::tEPRYTravelAcceleration);
     writeFloat(EPR_Z_MAX_TRAVEL_ACCEL, Com::tEPRZTravelAcceleration);
+#if defined(INTERPOLATE_ACCELERATION_WITH_Z) && INTERPOLATE_ACCELERATION_WITH_Z != 0
+    writeFloat(EPR_ACCELERATION_FACTOR_TOP, Com::tEPRAccelerationFactorAtTop);
 #endif
 #endif
+#endif
+    writeFloat(EPR_Z_PROBE_Z_OFFSET, Com::tZProbeOffsetZ);
 #if FEATURE_Z_PROBE
     writeFloat(EPR_Z_PROBE_HEIGHT, Com::tZProbeHeight);
     writeFloat(EPR_Z_PROBE_BED_DISTANCE, Com::tZProbeBedDitance);
@@ -891,6 +928,9 @@ void EEPROM::writeSettings()
     writeFloat(EPR_Z_PROBE_Y2, Com::tZProbeY2);
     writeFloat(EPR_Z_PROBE_X3, Com::tZProbeX3);
     writeFloat(EPR_Z_PROBE_Y3, Com::tZProbeY3);
+    writeFloat(EPR_BENDING_CORRECTION_A, Com::zZProbeBendingCorA);
+    writeFloat(EPR_BENDING_CORRECTION_B, Com::zZProbeBendingCorB);
+    writeFloat(EPR_BENDING_CORRECTION_C, Com::zZProbeBendingCorC);
 #endif
 #if FEATURE_AUTOLEVEL
     writeByte(EPR_AUTOLEVEL_ACTIVE, Com::tAutolevelActive);
@@ -1092,5 +1132,3 @@ void EEPROM::setZCorrection(int32_t c,int index)
 
 #endif
 
-
-

Repetier/Eeprom.h

@@ -20,7 +20,7 @@
 #define _EEPROM_H
 
 // Id to distinguish version changes
-#define EEPROM_PROTOCOL_VERSION 13
+#define EEPROM_PROTOCOL_VERSION 16
 
 /** Where to start with our datablock in memory. Can be moved if you
 have problems with other modules using the eeprom */
@@ -121,6 +121,12 @@ have problems with other modules using the eeprom */
 #define EPR_RETRACTION_UNDO_EXTRA_LONG_LENGTH 1012
 #define EPR_RETRACTION_UNDO_SPEED             1016
 #define EPR_AUTORETRACT_ENABLED               1020
+#define EPR_Z_PROBE_Z_OFFSET			      1024
+#define EPR_SELECTED_LANGUAGE                 1028
+#define EPR_ACCELERATION_FACTOR_TOP           1032
+#define EPR_BENDING_CORRECTION_A              1036
+#define EPR_BENDING_CORRECTION_B              1040
+#define EPR_BENDING_CORRECTION_C              1044
 
 #if EEPROM_MODE != 0
 #define EEPROM_FLOAT(x) HAL::eprGetFloat(EPR_##x)
@@ -128,9 +134,9 @@ have problems with other modules using the eeprom */
 #define EEPROM_BYTE(x) HAL::eprGetByte(EPR_##x)
 #define EEPROM_SET_BYTE(x,val) HAL::eprSetByte(EPR_##x,val)
 #else
-#define EEPROM_FLOAT(x) (x)
+#define EEPROM_FLOAT(x) (float)(x)
-#define EEPROM_INT32(x) (x)
+#define EEPROM_INT32(x) (int32_t)(x)
-#define EEPROM_BYTE(x) (x)
+#define EEPROM_BYTE(x) (uint8_t)(x)
 #define EEPROM_SET_BYTE(x,val)
 #endif
 
@@ -189,7 +195,26 @@ public:
     static void writeSettings();
     static void update(GCode *com);
     static void updatePrinterUsage();
-
+    static inline void setVersion(uint8_t v) {
+#if EEPROM_MODE != 0
+        HAL::eprSetByte(EPR_VERSION,v);
+        HAL::eprSetByte(EPR_INTEGRITY_BYTE,computeChecksum());
+#endif
+    }
+    static inline uint8_t getStoredLanguage() {
+#if EEPROM_MODE != 0
+        return HAL::eprGetByte(EPR_SELECTED_LANGUAGE);
+#else
+        return 0;
+#endif
+    }
+    static inline float zProbeZOffset() {
+#if EEPROM_MODE != 0
+	    return HAL::eprGetFloat(EPR_Z_PROBE_Z_OFFSET);
+#else
+	    return Z_PROBE_Z_OFFSET;
+#endif
+    }
     static inline float zProbeSpeed() {
 #if EEPROM_MODE != 0
         return HAL::eprGetFloat(EPR_Z_PROBE_SPEED);
@@ -516,7 +541,34 @@ static inline void setTowerZFloor(float newZ) {
         return 0;
 #endif
     }
+    static inline float bendingCorrectionA() {
+#if EEPROM_MODE != 0
+        return HAL::eprGetFloat(EPR_BENDING_CORRECTION_A);
+#else
+        return BENDING_CORRECTION_A;
+#endif
+    }
+    static inline float bendingCorrectionB() {
+#if EEPROM_MODE != 0
+        return HAL::eprGetFloat(EPR_BENDING_CORRECTION_B);
+#else
+        return BENDING_CORRECTION_B;
+#endif
+    }
+    static inline float bendingCorrectionC() {
+#if EEPROM_MODE != 0
+        return HAL::eprGetFloat(EPR_BENDING_CORRECTION_C);
+#else
+        return BENDING_CORRECTION_C;
+#endif
+    }
+    static inline float accelarationFactorTop() {
+#if EEPROM_MODE != 0
+        return HAL::eprGetFloat(EPR_ACCELERATION_FACTOR_TOP);
+#else
+        return ACCELERATION_FACTOR_TOP;
+#endif
+    }
+
 };
 #endif
-
-

Repetier/Events.h

@@ -50,6 +50,21 @@ Each of the following events describe the parameter and when it is called.
 // Gets called if a nextPrevius actions gets executed.
 #define EVENT_START_NEXTPREVIOUS(action,increment) {}
 
+// Called to initalize laser pins. Return false to prevent default initalization.
+#define EVENT_INITALIZE_LASER true
+// Set laser to intensity level 0 = off, 255 = full. Return false if you have overridden the setting routine.
+// with true the default solution will set it as digital value.
+#define EVENT_SET_LASER(intensity) true
+
+// Called to initalize cnc pins. Return false to prevent default initalization.
+#define EVENT_INITALIZE_CNC true
+// Turn off spindle
+#define EVENT_SPINDLE_OFF true
+// Turn spindle clockwise
+#define EVENT_SPINDLE_CW(rpm) true
+// Turn spindle counter clockwise
+#define EVENT_SPINDLE_CCW(rpm) true
+
 // Allow adding new G and M codes. To implement it create a function
 // bool eventUnhandledGCode(GCode *com)
 // that returns true if it handled the code, otherwise false.
@@ -67,5 +82,3 @@ Each of the following events describe the parameter and when it is called.
 #define EVENT_INITIALIZE {}
 
 #endif // EVENTS_H_INCLUDED
-
-

Repetier/Extruder.cpp

@@ -66,11 +66,35 @@ void Extruder::manageTemperatures()
     HAL::pingWatchdog();
 #endif // FEATURE_WATCHDOG
     uint8_t errorDetected = 0;
+#ifdef RED_BLUE_STATUS_LEDS
     bool hot = false;
+#endif
+	bool newDefectFound = false;
     millis_t time = HAL::timeInMilliseconds(); // compare time for decouple tests
+#if NUM_TEMPERATURE_LOOPS > 0
     for(uint8_t controller = 0; controller < NUM_TEMPERATURE_LOOPS; controller++)
     {
         TemperatureController *act = tempController[controller];
+        // Get Temperature
+        act->updateCurrentTemperature();
+#if FAN_THERMO_PIN > -1
+		// Special case thermistor controlled fan
+        if(act == &thermoController) {
+			if(act->currentTemperatureC < Printer::thermoMinTemp)
+				pwm_pos[PWM_FAN_THERMO] = 0;
+			else if(act->currentTemperatureC > Printer::thermoMaxTemp)
+				pwm_pos[PWM_FAN_THERMO] = FAN_THERMO_MAX_PWM;
+			else {
+				// Interpolate target speed
+				float out = FAN_THERMO_MIN_PWM + (FAN_THERMO_MAX_PWM-FAN_THERMO_MIN_PWM) * (act->currentTemperatureC - Printer::thermoMinTemp) / (Printer::thermoMaxTemp - Printer::thermoMinTemp);
+				if(out > 255)
+					pwm_pos[PWM_FAN_THERMO] = FAN_THERMO_MAX_PWM;
+				else
+					pwm_pos[PWM_FAN_THERMO] = static_cast<uint8_t>(out);
+			}
+			continue;
+		}
+#endif
         // Handle automatic cooling of extruders
         if(controller < NUM_EXTRUDER)
         {
@@ -87,25 +111,22 @@ void Extruder::manageTemperatures()
                     }
                 }
 #if SHARED_COOLER_BOARD_EXT
-                if(pwm_pos[NUM_EXTRUDER + 1]) enable = true;
+                if(pwm_pos[PWM_BOARD_FAN]) enable = true;
 #endif
                 extruder[0].coolerPWM = (enable ? extruder[0].coolerSpeed : 0);
-            }
+            } // controller == 0
 #else
             if(act->currentTemperatureC < EXTRUDER_FAN_COOL_TEMP && act->targetTemperatureC < EXTRUDER_FAN_COOL_TEMP)
                 extruder[controller].coolerPWM = 0;
             else
                 extruder[controller].coolerPWM = extruder[controller].coolerSpeed;
 #endif // NUM_EXTRUDER
-        }
+        } // extruder controller
         // do skip temperature control while auto tuning is in progress
         if(controller == autotuneIndex) continue;
 #if MIXING_EXTRUDER
         if(controller > 0 && controller < NUM_EXTRUDER) continue; // Mixing extruder only test for ext 0
-#endif
+#endif // MIXING_EXTRUDER
-
-        // Get Temperature
-        act->updateCurrentTemperature();
 
 
         // Check for obvious sensor errors
@@ -119,14 +140,36 @@ void Extruder::manageTemperatures()
                 act->flags |= TEMPERATURE_CONTROLLER_FLAG_SENSDEFECT;
                 if(!Printer::isAnyTempsensorDefect())
                 {
+					newDefectFound = true;
                     Printer::setAnyTempsensorDefect();
                     reportTempsensorError();
                 }
                 EVENT_HEATER_DEFECT(controller);
             }
         }
+#if HAVE_HEATED_BED
+		else if(controller == NUM_EXTRUDER && Extruder::getHeatedBedTemperature() > HEATED_BED_MAX_TEMP + 5) {
+            errorDetected = 1;
+            if(extruderTempErrors < 10)    // Ignore short temporary failures
+            extruderTempErrors++;
+            else
+            {
+	            act->flags |= TEMPERATURE_CONTROLLER_FLAG_SENSDEFECT;
+				Com::printErrorFLN(PSTR("Heated bed exceeded max temperature!"));
+	            if(!Printer::isAnyTempsensorDefect())
+	            {
+					newDefectFound = true;
+		            Printer::setAnyTempsensorDefect();
+		            reportTempsensorError();
+	            }
+	            EVENT_HEATER_DEFECT(controller);
+            }			
+		}
+#endif // HAVE_HEATED_BED
+#ifdef RED_BLUE_STATUS_LEDS
         if(act->currentTemperatureC > 50)
             hot = true;
+#endif // RED_BLUE_STATUS_LEDS
         if(Printer::isAnyTempsensorDefect()) continue;
         uint8_t on = act->currentTemperatureC >= act->targetTemperatureC ? LOW : HIGH;
         // Make a sound if alarm was set on reaching target temperature
@@ -137,7 +180,7 @@ void Extruder::manageTemperatures()
         }
 
         // Run test if heater and sensor are decoupled
-        bool decoupleTestRequired = act->decoupleTestPeriod > 0 && (time - act->lastDecoupleTest) > act->decoupleTestPeriod; // time enough for temperature change?
+        bool decoupleTestRequired = !errorDetected && act->decoupleTestPeriod > 0 && (time - act->lastDecoupleTest) > act->decoupleTestPeriod; // time enough for temperature change?
         if(decoupleTestRequired && act->isDecoupleFullOrHold() && Printer::isPowerOn()) // Only test when powered
         {
             if(act->isDecoupleFull()) // Phase 1: Heating fully until target range is reached
@@ -149,7 +192,12 @@ void Extruder::manageTemperatures()
                     if(extruderTempErrors > 10)   // Ignore short temporary failures
                     {
                         act->flags |= TEMPERATURE_CONTROLLER_FLAG_SENSDECOUPLED;
+						
+						if(!Printer::isAnyTempsensorDefect())
+						{
 							Printer::setAnyTempsensorDefect();
+							newDefectFound = true;
+						}
                         UI_ERROR_P(Com::tHeaterDecoupled);
                         Com::printErrorFLN(Com::tHeaterDecoupledWarning);
                         Com::printF(PSTR("Error:Temp. raised to slow. Rise = "),act->currentTemperatureC - act->lastDecoupleTemp);
@@ -173,7 +221,11 @@ void Extruder::manageTemperatures()
                     if(extruderTempErrors > 10)   // Ignore short temporary failures
                     {
                         act->flags |= TEMPERATURE_CONTROLLER_FLAG_SENSDECOUPLED;
+						if(!Printer::isAnyTempsensorDefect())
+						{
 							Printer::setAnyTempsensorDefect();
+							newDefectFound = true;
+						}
                         UI_ERROR_P(Com::tHeaterDecoupled);
                         Com::printErrorFLN(Com::tHeaterDecoupledWarning);
                         Com::printF(PSTR("Error:Could not hold temperature "),act->lastDecoupleTemp);
@@ -218,7 +270,7 @@ void Extruder::manageTemperatures()
                 pidTerm += dgain;
 #if SCALE_PID_TO_MAX == 1
                 pidTerm = (pidTerm * act->pidMax) * 0.0039215;
-#endif
+#endif // SCALE_PID_TO_MAX
                 output = constrain((int)pidTerm, 0, act->pidMax);
             }
             else if(act->heatManager == HTR_DEADTIME)     // dead-time control
@@ -229,7 +281,7 @@ void Extruder::manageTemperatures()
                 output = (act->currentTemperatureC + act->tempIState * act->deadTime > act->targetTemperatureC ? 0 : act->pidDriveMax);
             }
             else // bang bang and slow bang bang
-#endif
+#endif // TEMP_PID
                 if(act->heatManager == HTR_SLOWBANG)    // Bang-bang with reduced change frequency to save relais life
                 {
                     if (time - act->lastTemperatureUpdate > HEATED_BED_SET_INTERVAL)
@@ -251,19 +303,22 @@ void Extruder::manageTemperatures()
 #ifdef MAXTEMP
         if(act->currentTemperatureC > MAXTEMP) // Force heater off if MAXTEMP is exceeded
             output = 0;
-#endif
+#endif // MAXTEMP
         pwm_pos[act->pwmIndex] = output; // set pwm signal
 #if LED_PIN > -1
         if(act == &Extruder::current->tempControl)
             WRITE(LED_PIN,on);
-#endif
+#endif // LED_PIN
     } // for controller
 
 #ifdef RED_BLUE_STATUS_LEDS
-    if(Printer::isAnyTempsensorDefect()) {
+    if(Printer::isAnyTempsensorDefect())
+    {
         WRITE(BLUE_STATUS_LED,HIGH);
         WRITE(RED_STATUS_LED,HIGH);
-    } else {
+    }
+    else
+    {
         WRITE(BLUE_STATUS_LED,!hot);
         WRITE(RED_STATUS_LED,hot);
     }
@@ -271,14 +326,12 @@ void Extruder::manageTemperatures()
 
     if(errorDetected == 0 && extruderTempErrors > 0)
         extruderTempErrors--;
-    if(Printer::isAnyTempsensorDefect()
+    if(newDefectFound)
-#if HAVE_HEATED_BED
-            || Extruder::getHeatedBedTemperature() > HEATED_BED_MAX_TEMP + 5
-#endif
-      )
     {
+		Com::printFLN(PSTR("Disabling all heaters due to detected sensor defect."));
         for(uint8_t i = 0; i < NUM_TEMPERATURE_LOOPS; i++)
         {
+			tempController[i]->targetTemperatureC = 0;
             pwm_pos[tempController[i]->pwmIndex] = 0;
         }
 #if defined(KILL_IF_SENSOR_DEFECT) && KILL_IF_SENSOR_DEFECT > 0
@@ -286,12 +339,13 @@ void Extruder::manageTemperatures()
         {
 #if SDSUPPORT
             sd.stopPrint();
-#endif
+#endif // SDSUPPORT
             Printer::kill(0);
         }
-#endif
+#endif // KILL_IF_SENSOR_DEFECT
-        Printer::debugLevel |= 8; // Go into dry mode
+        Printer::debugSet(8); // Go into dry mode
-    }
+    } // any sensor defect
+#endif // NUM_TEMPERATURE_LOOPS
 
 }
 
@@ -509,7 +563,7 @@ void TemperatureController::updateTempControlVars()
 
 /** \brief Select extruder ext_num.
 
-This function changes and initalizes a new extruder. This is also called, after the eeprom values are changed.
+This function changes and initializes a new extruder. This is also called, after the eeprom values are changed.
 */
 void Extruder::selectExtruderById(uint8_t extruderId)
 {
@@ -520,10 +574,14 @@ void Extruder::selectExtruderById(uint8_t extruderId)
     activeMixingExtruder = extruderId;
     for(uint8_t i = 0; i < NUM_EXTRUDER; i++)
         Extruder::setMixingWeight(i, extruder[i].virtualWeights[extruderId]);
+	Com::printFLN(PSTR("SelectExtruder:"),static_cast<int>(extruderId));
     extruderId = 0;
 #endif
     if(extruderId >= NUM_EXTRUDER)
         extruderId = 0;
+#if !MIXING_EXTRUDER
+	Com::printFLN(PSTR("SelectExtruder:"),static_cast<int>(extruderId));
+#endif
 #if NUM_EXTRUDER > 1 && MIXING_EXTRUDER == 0
     bool executeSelect = false;
     if(extruderId != Extruder::current->id)
@@ -536,19 +594,23 @@ void Extruder::selectExtruderById(uint8_t extruderId)
     Extruder::current->extrudePosition = Printer::currentPositionSteps[E_AXIS];
     Extruder::current = &extruder[extruderId];
 #ifdef SEPERATE_EXTRUDER_POSITIONS
-    // Use seperate extruder positions only if beeing told. Slic3r e.g. creates a continuous extruder position increment
+    // Use separate extruder positions only if being told. Slic3r e.g. creates a continuous extruder position increment
     Printer::currentPositionSteps[E_AXIS] = Extruder::current->extrudePosition;
 #endif
+	#if MIXING_EXTRUDER
+		recomputeMixingExtruderSteps();
+	#else
 		Printer::destinationSteps[E_AXIS] = Printer::currentPositionSteps[E_AXIS];
 		Printer::axisStepsPerMM[E_AXIS] = Extruder::current->stepsPerMM;
 		Printer::invAxisStepsPerMM[E_AXIS] = 1.0f / Printer::axisStepsPerMM[E_AXIS];
+	#endif
     Printer::maxFeedrate[E_AXIS] = Extruder::current->maxFeedrate;
 //   max_start_speed_units_per_second[E_AXIS] = Extruder::current->maxStartFeedrate;
     Printer::maxAccelerationMMPerSquareSecond[E_AXIS] = Printer::maxTravelAccelerationMMPerSquareSecond[E_AXIS] = Extruder::current->maxAcceleration;
     Printer::maxTravelAccelerationStepsPerSquareSecond[E_AXIS] =
         Printer::maxPrintAccelerationStepsPerSquareSecond[E_AXIS] = Printer::maxAccelerationMMPerSquareSecond[E_AXIS] * Printer::axisStepsPerMM[E_AXIS];
 #if USE_ADVANCE
-    Printer::maxExtruderSpeed = (uint8_t)floor(HAL::maxExtruderTimerFrequency() / (Extruder::current->maxFeedrate*Extruder::current->stepsPerMM));
+    Printer::maxExtruderSpeed = (ufast8_t)floor(HAL::maxExtruderTimerFrequency() / (Extruder::current->maxFeedrate * Extruder::current->stepsPerMM));
 #if CPU_ARCH == ARCH_ARM
     if(Printer::maxExtruderSpeed > 40) Printer::maxExtruderSpeed = 40;
 #else
@@ -581,9 +643,25 @@ void Extruder::selectExtruderById(uint8_t extruderId)
 #endif
 #endif
 }
+#if MIXING_EXTRUDER
+	void Extruder::recomputeMixingExtruderSteps() {
+		int32_t sum_w = 0;
+		float sum = 0;
+		for(fast8_t i = 0; i < NUM_EXTRUDER; i++) {
+			sum_w += extruder[i].mixingW;
+			sum += extruder[i].stepsPerMM * extruder[i].mixingW;
+		}
+		sum /= sum_w;
+		Printer::currentPositionSteps[E_AXIS] =  Printer::currentPositionSteps[E_AXIS] * sum / Printer::axisStepsPerMM[E_AXIS]; // reposition according resolution change
+	    Printer::destinationSteps[E_AXIS] = Printer::currentPositionSteps[E_AXIS];
+	    Printer::axisStepsPerMM[E_AXIS] = sum;
+	    Printer::invAxisStepsPerMM[E_AXIS] = 1.0f / Printer::axisStepsPerMM[E_AXIS];
+	}
+#endif
 
 void Extruder::setTemperatureForExtruder(float temperatureInCelsius, uint8_t extr, bool beep, bool wait)
 {
+#if NUM_EXTRUDER > 0
 #if MIXING_EXTRUDER
     extr = 0; // map any virtual extruder number to 0
 #endif // MIXING_EXTRUDER
@@ -609,12 +687,14 @@ void Extruder::setTemperatureForExtruder(float temperatureInCelsius, uint8_t ext
     {
         TemperatureController *tc2 = tempController[1];
         tc2->setTargetTemperature(temperatureInCelsius);
+        tc2->updateTempControlVars();
         if(temperatureInCelsius >= EXTRUDER_FAN_COOL_TEMP) extruder[1].coolerPWM = extruder[1].coolerSpeed;
 #if NUM_EXTRUDER > 2
         if(Extruder::dittoMode > 1 && extr == 0)
         {
             TemperatureController *tc2 = tempController[2];
             tc2->setTargetTemperature(temperatureInCelsius);
+            tc2->updateTempControlVars();
             if(temperatureInCelsius >= EXTRUDER_FAN_COOL_TEMP) extruder[2].coolerPWM = extruder[2].coolerSpeed;
         }
 #endif
@@ -623,6 +703,7 @@ void Extruder::setTemperatureForExtruder(float temperatureInCelsius, uint8_t ext
         {
             TemperatureController *tc2 = tempController[3];
             tc2->setTargetTemperature(temperatureInCelsius);
+            tc2->updateTempControlVars();
             if(temperatureInCelsius >= EXTRUDER_FAN_COOL_TEMP) extruder[3].coolerPWM = extruder[3].coolerSpeed;
         }
 #endif
@@ -635,7 +716,7 @@ void Extruder::setTemperatureForExtruder(float temperatureInCelsius, uint8_t ext
       )
     {
         Extruder *actExtruder = &extruder[extr];
-        UI_STATUS_UPD(UI_TEXT_HEATING_EXTRUDER);
+        UI_STATUS_UPD_F(Com::translatedF(UI_TEXT_HEATING_EXTRUDER_ID));
         EVENT_WAITING_HEATER(actExtruder->id);
         bool dirRising = actExtruder->tempControl.targetTemperature > actExtruder->tempControl.currentTemperature;
         millis_t printedTime = HAL::timeInMilliseconds();
@@ -696,6 +777,7 @@ void Extruder::setTemperatureForExtruder(float temperatureInCelsius, uint8_t ext
         Printer::filamentPrinted = 0;  // new print, new counter
         Printer::flag2 &= ~PRINTER_FLAG2_RESET_FILAMENT_USAGE;
     }
+#endif
 }
 
 void Extruder::setHeatedBedTemperature(float temperatureInCelsius,bool beep)
@@ -708,9 +790,9 @@ void Extruder::setHeatedBedTemperature(float temperatureInCelsius,bool beep)
     if(beep && temperatureInCelsius>30) heatedBedController.setAlarm(true);
     Com::printFLN(Com::tTargetBedColon,heatedBedController.targetTemperatureC,0);
     if(temperatureInCelsius > 15)
-        pwm_pos[NUM_EXTRUDER + 1] = 255;    // turn on the mainboard cooling fan
+        pwm_pos[PWM_BOARD_FAN] = 255;    // turn on the mainboard cooling fan
     else if(Printer::areAllSteppersDisabled())
-        pwm_pos[NUM_EXTRUDER + 1] = 0;      // turn off the mainboard cooling fan only if steppers disabled
+        pwm_pos[PWM_BOARD_FAN] = 0;      // turn off the mainboard cooling fan only if steppers disabled
 #endif
 }
 
@@ -738,6 +820,45 @@ void Extruder::setMixingWeight(uint8_t extr,int weight)
 }
 void Extruder::step()
 {
+    if(PrintLine::cur != NULL && PrintLine::cur->isAllEMotors()) {
+#if NUM_EXTRUDER > 0
+        WRITE(EXT0_STEP_PIN, START_STEP_WITH_HIGH);
+#if EXTRUDER_JAM_CONTROL && defined(EXT0_JAM_PIN) && EXT0_JAM_PIN > -1
+        TEST_EXTRUDER_JAM(0)
+#endif
+#endif
+#if NUM_EXTRUDER > 1
+        WRITE(EXT1_STEP_PIN, START_STEP_WITH_HIGH);
+#if EXTRUDER_JAM_CONTROL && defined(EXT1_JAM_PIN) && EXT1_JAM_PIN > -1
+        TEST_EXTRUDER_JAM(1)
+#endif
+#endif
+#if NUM_EXTRUDER > 2
+        WRITE(EXT2_STEP_PIN, START_STEP_WITH_HIGH);
+#if EXTRUDER_JAM_CONTROL && defined(EXT2_JAM_PIN) && EXT2_JAM_PIN > -1
+        TEST_EXTRUDER_JAM(2)
+#endif
+#endif
+#if NUM_EXTRUDER > 3
+        WRITE(EXT3_STEP_PIN, START_STEP_WITH_HIGH);
+#if EXTRUDER_JAM_CONTROL && defined(EXT3_JAM_PIN) && EXT3_JAM_PIN > -1
+        TEST_EXTRUDER_JAM(3)
+#endif
+#endif
+#if NUM_EXTRUDER > 4
+        WRITE(EXT4_STEP_PIN, START_STEP_WITH_HIGH);
+#if EXTRUDER_JAM_CONTROL && defined(EXT4_JAM_PIN) && EXT4_JAM_PIN > -1
+        TEST_EXTRUDER_JAM(4)
+#endif
+#endif
+#if NUM_EXTRUDER > 5
+        WRITE(EXT5_STEP_PIN, START_STEP_WITH_HIGH);
+#if EXTRUDER_JAM_CONTROL && defined(EXT5_JAM_PIN) && EXT5_JAM_PIN > -1
+        TEST_EXTRUDER_JAM(5)
+#endif
+#endif
+        return;
+    }
     uint8_t best = 255,i;
     int bestError;
     if(mixingDir)
@@ -775,7 +896,7 @@ void Extruder::step()
 #if NUM_EXTRUDER > 0
     if(best == 0)
     {
-        WRITE(EXT0_STEP_PIN, HIGH);
+        WRITE(EXT0_STEP_PIN, START_STEP_WITH_HIGH);
 #if EXTRUDER_JAM_CONTROL && defined(EXT0_JAM_PIN) && EXT0_JAM_PIN > -1
         TEST_EXTRUDER_JAM(0)
 #endif
@@ -784,7 +905,7 @@ void Extruder::step()
 #if NUM_EXTRUDER > 1
     if(best == 1)
     {
-        WRITE(EXT1_STEP_PIN, HIGH);
+        WRITE(EXT1_STEP_PIN, START_STEP_WITH_HIGH);
 #if EXTRUDER_JAM_CONTROL && defined(EXT1_JAM_PIN) && EXT1_JAM_PIN > -1
         TEST_EXTRUDER_JAM(1)
 #endif
@@ -793,7 +914,7 @@ void Extruder::step()
 #if NUM_EXTRUDER > 2
     if(best == 2)
     {
-        WRITE(EXT2_STEP_PIN, HIGH);
+        WRITE(EXT2_STEP_PIN, START_STEP_WITH_HIGH);
 #if EXTRUDER_JAM_CONTROL && defined(EXT2_JAM_PIN) && EXT2_JAM_PIN > -1
         TEST_EXTRUDER_JAM(2)
 #endif
@@ -802,7 +923,7 @@ void Extruder::step()
 #if NUM_EXTRUDER > 3
     if(best == 3)
     {
-        WRITE(EXT3_STEP_PIN, HIGH);
+        WRITE(EXT3_STEP_PIN, START_STEP_WITH_HIGH);
 #if EXTRUDER_JAM_CONTROL && defined(EXT3_JAM_PIN) && EXT3_JAM_PIN > -1
         TEST_EXTRUDER_JAM(3)
 #endif
@@ -811,7 +932,7 @@ void Extruder::step()
 #if NUM_EXTRUDER > 4
     if(best == 4)
     {
-        WRITE(EXT4_STEP_PIN, HIGH);
+        WRITE(EXT4_STEP_PIN, START_STEP_WITH_HIGH);
 #if EXTRUDER_JAM_CONTROL && defined(EXT4_JAM_PIN) && EXT4_JAM_PIN > -1
         TEST_EXTRUDER_JAM(4)
 #endif
@@ -820,7 +941,7 @@ void Extruder::step()
 #if NUM_EXTRUDER > 5
     if(best == 5)
     {
-        WRITE(EXT5_STEP_PIN, HIGH);
+        WRITE(EXT5_STEP_PIN, START_STEP_WITH_HIGH);
 #if EXTRUDER_JAM_CONTROL && defined(EXT5_JAM_PIN) && EXT5_JAM_PIN > -1
         TEST_EXTRUDER_JAM(5)
 #endif
@@ -831,22 +952,22 @@ void Extruder::step()
 void Extruder::unstep()
 {
 #if NUM_EXTRUDER > 0
-    WRITE(EXT0_STEP_PIN, LOW);
+    WRITE(EXT0_STEP_PIN, !START_STEP_WITH_HIGH);
 #endif
 #if NUM_EXTRUDER > 1
-    WRITE(EXT1_STEP_PIN, LOW);
+    WRITE(EXT1_STEP_PIN, !START_STEP_WITH_HIGH);
 #endif
 #if NUM_EXTRUDER > 2
-    WRITE(EXT2_STEP_PIN, LOW);
+    WRITE(EXT2_STEP_PIN, !START_STEP_WITH_HIGH);
 #endif
 #if NUM_EXTRUDER > 3
-    WRITE(EXT3_STEP_PIN, LOW);
+    WRITE(EXT3_STEP_PIN, !START_STEP_WITH_HIGH);
 #endif
 #if NUM_EXTRUDER > 4
-    WRITE(EXT4_STEP_PIN, LOW);
+    WRITE(EXT4_STEP_PIN, !START_STEP_WITH_HIGH);
 #endif
 #if NUM_EXTRUDER > 5
-    WRITE(EXT5_STEP_PIN, LOW);
+    WRITE(EXT5_STEP_PIN, !START_STEP_WITH_HIGH);
 #endif
 }
 
@@ -925,7 +1046,7 @@ Call this function only, if interrupts are disabled.
 void Extruder::step()
 {
 #if NUM_EXTRUDER == 1
-    WRITE(EXT0_STEP_PIN, HIGH);
+    WRITE(EXT0_STEP_PIN, START_STEP_WITH_HIGH);
 #if EXTRUDER_JAM_CONTROL && defined(EXT0_JAM_PIN) && EXT0_JAM_PIN > -1
     TEST_EXTRUDER_JAM(0)
 #endif
@@ -934,21 +1055,21 @@ void Extruder::step()
     {
     case 0:
 #if NUM_EXTRUDER > 0
-        WRITE(EXT0_STEP_PIN,HIGH);
+        WRITE(EXT0_STEP_PIN,START_STEP_WITH_HIGH);
 #if EXTRUDER_JAM_CONTROL && defined(EXT0_JAM_PIN) && EXT0_JAM_PIN > -1
         TEST_EXTRUDER_JAM(0)
 #endif
 #if FEATURE_DITTO_PRINTING
         if(Extruder::dittoMode)
         {
-            WRITE(EXT1_STEP_PIN,HIGH);
+            WRITE(EXT1_STEP_PIN,START_STEP_WITH_HIGH);
 #if EXTRUDER_JAM_CONTROL && defined(EXT1_JAM_PIN) && EXT1_JAM_PIN > -1
             TEST_EXTRUDER_JAM(1)
 #endif
 #if NUM_EXTRUDER > 2
             if(Extruder::dittoMode > 1)
             {
-                WRITE(EXT2_STEP_PIN,HIGH);
+                WRITE(EXT2_STEP_PIN,START_STEP_WITH_HIGH);
 #if EXTRUDER_JAM_CONTROL && defined(EXT2_JAM_PIN) && EXT2_JAM_PIN > -1
                 TEST_EXTRUDER_JAM(2)
 #endif
@@ -957,7 +1078,7 @@ void Extruder::step()
 #if NUM_EXTRUDER > 3
             if(Extruder::dittoMode > 2)
             {
-                WRITE(EXT3_STEP_PIN,HIGH);
+                WRITE(EXT3_STEP_PIN,START_STEP_WITH_HIGH);
 #if EXTRUDER_JAM_CONTROL && defined(EXT3_JAM_PIN) && EXT3_JAM_PIN > -1
                 TEST_EXTRUDER_JAM(3)
 #endif
@@ -969,7 +1090,7 @@ void Extruder::step()
         break;
 #if defined(EXT1_STEP_PIN) && NUM_EXTRUDER > 1
     case 1:
-        WRITE(EXT1_STEP_PIN,HIGH);
+        WRITE(EXT1_STEP_PIN,START_STEP_WITH_HIGH);
 #if EXTRUDER_JAM_CONTROL && defined(EXT1_JAM_PIN) && EXT1_JAM_PIN > -1
         TEST_EXTRUDER_JAM(1)
 #endif
@@ -977,7 +1098,7 @@ void Extruder::step()
 #endif
 #if defined(EXT2_STEP_PIN) && NUM_EXTRUDER > 2
     case 2:
-        WRITE(EXT2_STEP_PIN,HIGH);
+        WRITE(EXT2_STEP_PIN,START_STEP_WITH_HIGH);
 #if EXTRUDER_JAM_CONTROL && defined(EXT2_JAM_PIN) && EXT2_JAM_PIN > -1
         TEST_EXTRUDER_JAM(2)
 #endif
@@ -985,7 +1106,7 @@ void Extruder::step()
 #endif
 #if defined(EXT3_STEP_PIN) && NUM_EXTRUDER > 3
     case 3:
-        WRITE(EXT3_STEP_PIN,HIGH);
+        WRITE(EXT3_STEP_PIN,START_STEP_WITH_HIGH);
 #if EXTRUDER_JAM_CONTROL && defined(EXT3_JAM_PIN) && EXT3_JAM_PIN > -1
         TEST_EXTRUDER_JAM(3)
 #endif
@@ -993,7 +1114,7 @@ void Extruder::step()
 #endif
 #if defined(EXT4_STEP_PIN) && NUM_EXTRUDER > 4
     case 4:
-        WRITE(EXT4_STEP_PIN,HIGH);
+        WRITE(EXT4_STEP_PIN,START_STEP_WITH_HIGH);
 #if EXTRUDER_JAM_CONTROL && defined(EXT4_JAM_PIN) && EXT4_JAM_PIN > -1
         TEST_EXTRUDER_JAM(4)
 #endif
@@ -1001,7 +1122,7 @@ void Extruder::step()
 #endif
 #if defined(EXT5_STEP_PIN) && NUM_EXTRUDER > 5
     case 5:
-        WRITE(EXT5_STEP_PIN,HIGH);
+        WRITE(EXT5_STEP_PIN,START_STEP_WITH_HIGH);
 #if EXTRUDER_JAM_CONTROL && defined(EXT5_JAM_PIN) && EXT5_JAM_PIN > -1
         TEST_EXTRUDER_JAM(5)
 #endif
@@ -1019,27 +1140,27 @@ Call this function only, if interrupts are disabled.
 void Extruder::unstep()
 {
 #if NUM_EXTRUDER == 1
-    WRITE(EXT0_STEP_PIN,LOW);
+    WRITE(EXT0_STEP_PIN,!START_STEP_WITH_HIGH);
 #else
     switch(Extruder::current->id)
     {
     case 0:
 #if NUM_EXTRUDER > 0
-        WRITE(EXT0_STEP_PIN,LOW);
+        WRITE(EXT0_STEP_PIN,!START_STEP_WITH_HIGH);
 #if FEATURE_DITTO_PRINTING
         if(Extruder::dittoMode)
         {
-            WRITE(EXT1_STEP_PIN,LOW);
+            WRITE(EXT1_STEP_PIN,!START_STEP_WITH_HIGH);
 #if NUM_EXTRUDER > 2
             if(Extruder::dittoMode > 1)
             {
-                WRITE(EXT2_STEP_PIN,LOW);
+                WRITE(EXT2_STEP_PIN,!START_STEP_WITH_HIGH);
             }
 #endif
 #if NUM_EXTRUDER > 3
             if(Extruder::dittoMode > 2)
             {
-                WRITE(EXT3_STEP_PIN,LOW);
+                WRITE(EXT3_STEP_PIN,!START_STEP_WITH_HIGH);
             }
 #endif // NUM_EXTRUDER > 3
         }
@@ -1048,27 +1169,27 @@ void Extruder::unstep()
         break;
 #if defined(EXT1_STEP_PIN) && NUM_EXTRUDER > 1
     case 1:
-        WRITE(EXT1_STEP_PIN,LOW);
+        WRITE(EXT1_STEP_PIN,!START_STEP_WITH_HIGH);
         break;
 #endif
 #if defined(EXT2_STEP_PIN) && NUM_EXTRUDER > 2
     case 2:
-        WRITE(EXT2_STEP_PIN,LOW);
+        WRITE(EXT2_STEP_PIN,!START_STEP_WITH_HIGH);
         break;
 #endif
 #if defined(EXT3_STEP_PIN) && NUM_EXTRUDER > 3
     case 3:
-        WRITE(EXT3_STEP_PIN,LOW);
+        WRITE(EXT3_STEP_PIN,!START_STEP_WITH_HIGH);
         break;
 #endif
 #if defined(EXT4_STEP_PIN) && NUM_EXTRUDER > 4
     case 4:
-        WRITE(EXT4_STEP_PIN,LOW);
+        WRITE(EXT4_STEP_PIN,!START_STEP_WITH_HIGH);
         break;
 #endif
 #if defined(EXT5_STEP_PIN) && NUM_EXTRUDER > 5
     case 5:
-        WRITE(EXT5_STEP_PIN,LOW);
+        WRITE(EXT5_STEP_PIN,!START_STEP_WITH_HIGH);
         break;
 #endif
     }
@@ -1283,7 +1404,7 @@ const short temptable_4[NUMTEMPS_4][2] PROGMEM =
     {478*4, 46*8},{531*4, 41*8},{584*4, 35*8},{637*4, 30*8},{690*4, 25*8},{743*4, 20*8},{796*4, 14*8},{849*4, 7*8},{902*4, 0*8},
     {955*4, -11*8},{1008*4, -35*8}
 };
-
+// ATC 104GT
 #define NUMTEMPS_8 34
 const short temptable_8[NUMTEMPS_8][2] PROGMEM =
 {
@@ -1325,6 +1446,12 @@ const short temptable_12[NUMTEMPS_12][2] PROGMEM =
     {351*4, 140*8},{386*4, 134*8},{421*4, 128*8},{456*4, 122*8},{491*4, 117*8},{526*4, 112*8},{561*4, 107*8},{596*4, 102*8},{631*4, 97*8},{666*4, 91*8},
     {701*4, 86*8},{736*4, 81*8},{771*4, 76*8},{806*4, 70*8},{841*4, 63*8},{876*4, 56*8},{911*4, 48*8},{946*4, 38*8},{981*4, 23*8},{1005*4, 5*8},{1016*4, 0*8}
 };
+#define NUMTEMPS_13 19
+const short temptable_13[NUMTEMPS_13][2] PROGMEM =
+{
+    {0,0},{908,8},{942,10*8},{982,20*8},{1015,8*30},{1048,8*40},{1080,8*50},{1113,8*60},{1146,8*70},{1178,8*80},{1211,8*90},{1276,8*110},{1318,8*120}
+    ,{1670,8*230},{2455,8*500},{3445,8*900},{3666,8*1000},{3871,8*1100},{4095,8*2000}
+};
 #if NUM_TEMPS_USERTHERMISTOR0 > 0
 const short temptable_5[NUM_TEMPS_USERTHERMISTOR0][2] PROGMEM = USER_THERMISTORTABLE0 ;
 #endif
@@ -1334,7 +1461,7 @@ const short temptable_6[NUM_TEMPS_USERTHERMISTOR1][2] PROGMEM = USER_THERMISTORT
 #if NUM_TEMPS_USERTHERMISTOR2 > 0
 const short temptable_7[NUM_TEMPS_USERTHERMISTOR2][2] PROGMEM = USER_THERMISTORTABLE2 ;
 #endif
-const short * const temptables[12] PROGMEM = {(short int *)&temptable_1[0][0],(short int *)&temptable_2[0][0],(short int *)&temptable_3[0][0],(short int *)&temptable_4[0][0]
+const short * const temptables[13] PROGMEM = {(short int *)&temptable_1[0][0],(short int *)&temptable_2[0][0],(short int *)&temptable_3[0][0],(short int *)&temptable_4[0][0]
 #if NUM_TEMPS_USERTHERMISTOR0 > 0
         ,(short int *)&temptable_5[0][0]
 #else
@@ -1355,9 +1482,10 @@ const short * const temptables[12] PROGMEM = {(short int *)&temptable_1[0][0],(s
         ,(short int *)&temptable_10[0][0]
         ,(short int *)&temptable_11[0][0]
         ,(short int *)&temptable_12[0][0]
+        ,(short int *)&temptable_13[0][0]
                                              };
-const uint8_t temptables_num[12] PROGMEM = {NUMTEMPS_1,NUMTEMPS_2,NUMTEMPS_3,NUMTEMPS_4,NUM_TEMPS_USERTHERMISTOR0,NUM_TEMPS_USERTHERMISTOR1,NUM_TEMPS_USERTHERMISTOR2,NUMTEMPS_8,
+const uint8_t temptables_num[13] PROGMEM = {NUMTEMPS_1,NUMTEMPS_2,NUMTEMPS_3,NUMTEMPS_4,NUM_TEMPS_USERTHERMISTOR0,NUM_TEMPS_USERTHERMISTOR1,NUM_TEMPS_USERTHERMISTOR2,NUMTEMPS_8,
-                                 NUMTEMPS_9,NUMTEMPS_10,NUMTEMPS_11,NUMTEMPS_12
+                                 NUMTEMPS_9,NUMTEMPS_10,NUMTEMPS_11,NUMTEMPS_12,NUMTEMPS_13
                                            };
 
 
@@ -1388,12 +1516,13 @@ void TemperatureController::updateCurrentTemperature()
     case 99:
         currentTemperature = (1023 << (2 - ANALOG_REDUCE_BITS)) - (osAnalogInputValues[sensorPin] >> (ANALOG_REDUCE_BITS)); // Convert to 10 bit result
         break;
+    case 13: // PT100 E3D
     case 50: // User defined PTC table
     case 51:
     case 52:
     case 60: // HEATER_USES_AD8495 (Delivers 5mV/degC)
     case 61: // HEATER_USES_AD8495 (Delivers 5mV/degC) 1.25v offset
-    case 100: // AD595
+    case 100: // AD595 / AD597
         currentTemperature = (osAnalogInputValues[sensorPin] >> (ANALOG_REDUCE_BITS));
         break;
 #endif
@@ -1433,10 +1562,10 @@ void TemperatureController::updateCurrentTemperature()
         type--;
         uint8_t num = pgm_read_byte(&temptables_num[type]) << 1;
         uint8_t i = 2;
-        const short *temptable = (const short *)pgm_read_word(&temptables[type]); //pgm_read_word_near(&temptables[type]);
+        const int16_t *temptable = (const int16_t *)pgm_read_word(&temptables[type]); //pgm_read_word_near(&temptables[type]);
-        short oldraw = pgm_read_word(&temptable[0]);
+        int16_t oldraw = pgm_read_word(&temptable[0]);
-        short oldtemp = pgm_read_word(&temptable[1]);
+        int16_t oldtemp = pgm_read_word(&temptable[1]);
-        short newraw,newtemp;
+        int16_t newraw,newtemp = 0;
         currentTemperature = (1023 << (2 - ANALOG_REDUCE_BITS)) - currentTemperature;
         while(i < num)
         {
@@ -1456,17 +1585,21 @@ void TemperatureController::updateCurrentTemperature()
         currentTemperatureC = TEMP_INT_TO_FLOAT(newtemp);
     }
     break;
+    case 13:
     case 50: // User defined PTC thermistor
     case 51:
     case 52:
     {
+        if(type > 49)
             type -= 46;
+        else
+            type--;
         uint8_t num = pgm_read_byte(&temptables_num[type]) << 1;
         uint8_t i = 2;
-        const short *temptable = (const short *)pgm_read_word(&temptables[type]); //pgm_read_word_near(&temptables[type]);
+        const int16_t *temptable = (const int16_t *)pgm_read_word(&temptables[type]); //pgm_read_word_near(&temptables[type]);
-        short oldraw = pgm_read_word(&temptable[0]);
+        int16_t oldraw = pgm_read_word(&temptable[0]);
-        short oldtemp = pgm_read_word(&temptable[1]);
+        int16_t oldtemp = pgm_read_word(&temptable[1]);
-        short newraw,newtemp;
+        int16_t newraw,newtemp = 0;
         while(i < num)
         {
             newraw = pgm_read_word(&temptable[i++]);
@@ -1497,12 +1630,16 @@ void TemperatureController::updateCurrentTemperature()
         currentTemperatureC = ((float)currentTemperature * 660.0f / (1024 << (2 - ANALOG_REDUCE_BITS))) - 250.0f;
 #endif
         break;
-    case 100: // AD595
+    case 100: // AD595 / AD597   10mV/°C
         //return (int)((long)raw_temp * 500/(1024<<(2-ANALOG_REDUCE_BITS)));
 #if CPU_ARCH == ARCH_AVR
         currentTemperatureC = ((float)currentTemperature * 500.0f / (1024 << (2 - ANALOG_REDUCE_BITS)));
+#else
+#if FEATURE_CONTROLLER == CONTROLLER_LCD_MP_PHARAOH_DUE
+        currentTemperatureC = ((float)currentTemperature * 500.0f / (1024 << (2 - ANALOG_REDUCE_BITS)));
 #else
         currentTemperatureC = ((float)currentTemperature * 330.0f / (1024 << (2 - ANALOG_REDUCE_BITS)));
+#endif
 #endif
         break;
 #ifdef SUPPORT_MAX6675
@@ -1607,11 +1744,15 @@ void TemperatureController::setTargetTemperature(float target)
         targetTemperature = (1023<<(2-ANALOG_REDUCE_BITS))-newraw;
         break;
     }
+    case 13: // PT100 E3D
     case 50: // user defined PTC thermistor
     case 51:
     case 52:
     {
+        if(type > 49)
             type -= 46;
+        else
+            type--;
         uint8_t num = pgm_read_byte(&temptables_num[type]) << 1;
         uint8_t i = 2;
         const short *temptable = (const short *)pgm_read_word(&temptables[type]); //pgm_read_word(&temptables[type]);
@@ -1695,6 +1836,7 @@ void TemperatureController::setTargetTemperature(float target)
 uint8_t autotuneIndex = 255;
 void Extruder::disableAllHeater()
 {
+#if NUM_TEMPERATURE_LOOPS > 0
     for(uint8_t i = 0; i < NUM_TEMPERATURE_LOOPS; i++)
     {
         TemperatureController *c = tempController[i];
@@ -1702,6 +1844,7 @@ void Extruder::disableAllHeater()
         c->targetTemperatureC = 0;
         pwm_pos[c->pwmIndex] = 0;
     }
+#endif
     autotuneIndex = 255;
 }
 
@@ -1863,6 +2006,7 @@ void writeMonitor()
 
 bool reportTempsensorError()
 {
+#if NUM_TEMPERATURE_LOOPS > 0
     if(!Printer::isAnyTempsensorDefect()) return false;
     for(uint8_t i = 0; i < NUM_TEMPERATURE_LOOPS; i++)
     {
@@ -1876,12 +2020,19 @@ bool reportTempsensorError()
     }
     Com::printErrorFLN(Com::tDryModeUntilRestart);
     return true;
+#else
+    return false;
+#endif
 }
 
 #ifdef SUPPORT_MAX6675
+
 int16_t read_max6675(uint8_t ss_pin)
 {
-    int16_t max6675_temp = 0;
+    static millis_t last_max6675_read = 0;
+    static int16_t max6675_temp = 0;
+    if (HAL::timeInMilliseconds() - last_max6675_read > 230)
+    {
         HAL::spiInit(2);
         HAL::digitalWrite(ss_pin, 0);  // enable TT_MAX6675
         HAL::delayMicroseconds(1);    // ensure 100ns delay - a bit extra is fine
@@ -1889,6 +2040,8 @@ int16_t read_max6675(uint8_t ss_pin)
         max6675_temp <<= 8;
         max6675_temp |= HAL::spiReceive(0);
         HAL::digitalWrite(ss_pin, 1);  // disable TT_MAX6675
+        last_max6675_read = HAL::timeInMilliseconds();
+    }
     return max6675_temp & 4 ? 2000 : max6675_temp >> 3; // thermocouple open?
 }
 #endif
@@ -1934,7 +2087,13 @@ void Extruder::retractDistance(float dist)
     int32_t distance = static_cast<int32_t>(dist * stepsPerMM / Printer::extrusionFactor);
     int32_t oldEPos = Printer::currentPositionSteps[E_AXIS];
     float speed = distance > 0 ? EEPROM_FLOAT(RETRACTION_SPEED) : EEPROM_FLOAT(RETRACTION_UNDO_SPEED);
+#if MIXING_EXTRUDER
+            Printer::setAllEMotors(true);
+#endif
     PrintLine::moveRelativeDistanceInSteps(0, 0, 0, -distance, RMath::max(speed, 1.f), false, false);
+#if MIXING_EXTRUDER
+            Printer::setAllEMotors(false);
+#endif
     Printer::currentPositionSteps[E_AXIS] = oldEPos; // restore previous extruder position
     Printer::feedrate = oldFeedrate;
 }
@@ -1943,26 +2102,27 @@ void Extruder::retract(bool isRetract,bool isLong)
 {
     float oldFeedrate = Printer::feedrate;
     float distance = (isLong ? EEPROM_FLOAT( RETRACTION_LONG_LENGTH) : EEPROM_FLOAT(RETRACTION_LENGTH));
-    int32_t zlift = static_cast<int32_t>(EEPROM_FLOAT(RETRACTION_Z_LIFT) * Printer::axisStepsPerMM[Z_AXIS]);
+    float zLiftF = EEPROM_FLOAT(RETRACTION_Z_LIFT);
-    int32_t oldZPos = Printer::currentPositionSteps[Z_AXIS];
+    int32_t zlift = static_cast<int32_t>(zLiftF * Printer::axisStepsPerMM[Z_AXIS]);
-    float oldZPosF = Printer::currentPosition[Z_AXIS];
     if(isRetract && !isRetracted())
     {
         retractDistance(distance);
         setRetracted(true);
-        if(zlift > 0)
+        if(zlift > 0) {
             PrintLine::moveRelativeDistanceInStepsReal(0,0,zlift,0,Printer::maxFeedrate[Z_AXIS], false);
+            Printer::coordinateOffset[Z_AXIS] -= zLiftF;
+        }
     }
     else if(!isRetract && isRetracted())
     {
         distance += (isLong ? EEPROM_FLOAT(RETRACTION_UNDO_EXTRA_LONG_LENGTH) : EEPROM_FLOAT(RETRACTION_UNDO_EXTRA_LENGTH) );
-        if(zlift > 0)
+        if(zlift > 0) {
             PrintLine::moveRelativeDistanceInStepsReal(0,0,-zlift,0,Printer::maxFeedrate[Z_AXIS], false);
+            Printer::coordinateOffset[Z_AXIS] += zLiftF;
+        }
         retractDistance(-distance);
         setRetracted(false);
     }
-    Printer::currentPositionSteps[Z_AXIS] = oldZPos; // z lift should have no visible impact
-    Printer::currentPosition[Z_AXIS] = oldZPosF;
     Printer::feedrate = oldFeedrate;
 }
 #endif
@@ -2165,17 +2325,22 @@ Extruder extruder[NUM_EXTRUDER] =
 #endif // NUM_EXTRUDER
 
 #if HAVE_HEATED_BED
-#define NUM_TEMPERATURE_LOOPS NUM_EXTRUDER+1
+TemperatureController heatedBedController = {PWM_HEATED_BED,HEATED_BED_SENSOR_TYPE,BED_SENSOR_INDEX,0,0,0,0,0,HEATED_BED_HEAT_MANAGER
-TemperatureController heatedBedController = {NUM_EXTRUDER,HEATED_BED_SENSOR_TYPE,BED_SENSOR_INDEX,0,0,0,0,0,HEATED_BED_HEAT_MANAGER
 #if TEMP_PID
         ,0,HEATED_BED_PID_INTEGRAL_DRIVE_MAX,HEATED_BED_PID_INTEGRAL_DRIVE_MIN,HEATED_BED_PID_PGAIN_OR_DEAD_TIME,HEATED_BED_PID_IGAIN,HEATED_BED_PID_DGAIN,HEATED_BED_PID_MAX,0,0,0,{0,0,0,0}
 #endif
-        ,0,0,0,HEATED_BED_DECOUPLE_TEST_PERIOD
+        ,0,0,0,HEATED_BED_DECOUPLE_TEST_PERIOD};
-                                            };
-#else
-#define NUM_TEMPERATURE_LOOPS NUM_EXTRUDER
 #endif
 
+#if FAN_THERMO_PIN > -1
+TemperatureController thermoController = {PWM_FAN_THERMO,FAN_THERMO_THERMISTOR_TYPE,THERMO_ANALOG_INDEX,0,0,0,0,0,0
+	#if TEMP_PID
+	,0,255,0,10,1,1,255,0,0,0,{0,0,0,0}
+	#endif
+,0,0,0,0};
+#endif
+
+#if NUM_TEMPERATURE_LOOPS > 0
 TemperatureController *tempController[NUM_TEMPERATURE_LOOPS] =
 {
 #if NUM_EXTRUDER > 0
@@ -2203,7 +2368,12 @@ TemperatureController *tempController[NUM_TEMPERATURE_LOOPS] =
     ,&heatedBedController
 #endif
 #endif
+#if FAN_THERMO_PIN > -1
+#if NUM_EXTRUDER == 0 && !HAVE_HEATED_BED
+	&thermoController
+#else
+	,&thermoController
+#endif
+#endif // FAN_THERMO_PIN
 };
-
+#endif
-
-

Repetier/Extruder.h

@@ -148,6 +148,7 @@ class Extruder;
 extern Extruder extruder[];
 
 #if EXTRUDER_JAM_CONTROL
+#if JAM_METHOD == 1
 #define _TEST_EXTRUDER_JAM(x,pin) {\
         uint8_t sig = READ(pin);extruder[x].jamStepsSinceLastSignal += extruder[x].jamLastDir;\
         if(extruder[x].jamLastSignal != sig && abs(extruder[x].jamStepsSinceLastSignal - extruder[x].jamLastChangeAt) > JAM_MIN_STEPS) {\
@@ -156,10 +157,23 @@ extern Extruder extruder[];
         } else if(abs(extruder[x].jamStepsSinceLastSignal) > JAM_ERROR_STEPS && !Printer::isDebugJamOrDisabled() && !extruder[x].tempControl.isJammed()) \
             extruder[x].tempControl.setJammed(true);\
     }
+#define RESET_EXTRUDER_JAM(x,dir) extruder[x].jamLastDir = dir ? 1 : -1;
+#elif JAM_METHOD == 2
+#define _TEST_EXTRUDER_JAM(x,pin) {\
+        uint8_t sig = READ(pin);\
+          if(sig){extruder[x].tempControl.setJammed(true);} else if(!Printer::isDebugJamOrDisabled() && !extruder[x].tempControl.isJammed()) {extruder[x].resetJamSteps();}}
+#define RESET_EXTRUDER_JAM(x,dir)
+#elif JAM_METHOD == 3
+#define _TEST_EXTRUDER_JAM(x,pin) {\
+        uint8_t sig = !READ(pin);\
+          if(sig){extruder[x].tempControl.setJammed(true);} else if(!Printer::isDebugJamOrDisabled() && !extruder[x].tempControl.isJammed()) {extruder[x].resetJamSteps();}}
+#define RESET_EXTRUDER_JAM(x,dir)
+#else
+#error Unknown value for JAM_METHOD
+#endif
 #define ___TEST_EXTRUDER_JAM(x,y) _TEST_EXTRUDER_JAM(x,y)
 #define __TEST_EXTRUDER_JAM(x) ___TEST_EXTRUDER_JAM(x,EXT ## x ## _JAM_PIN)
 #define TEST_EXTRUDER_JAM(x) __TEST_EXTRUDER_JAM(x)
-#define RESET_EXTRUDER_JAM(x,dir) extruder[x].jamLastDir = dir ? 1 : -1;
 #else
 #define TEST_EXTRUDER_JAM(x)
 #define RESET_EXTRUDER_JAM(x,dir)
@@ -184,6 +198,7 @@ public:
     static int mixingS; ///< Sum of all weights
     static uint8_t mixingDir; ///< Direction flag
     static uint8_t activeMixingExtruder;
+	static void recomputeMixingExtruderSteps();
 #endif
     uint8_t id;
     int32_t xOffset;
@@ -274,19 +289,27 @@ public:
 };
 
 #if HAVE_HEATED_BED
-#define NUM_TEMPERATURE_LOOPS NUM_EXTRUDER+1
+#define HEATED_BED_INDEX NUM_EXTRUDER
 extern TemperatureController heatedBedController;
 #else
-#define NUM_TEMPERATURE_LOOPS NUM_EXTRUDER
+#define HEATED_BED_INDEX NUM_EXTRUDER-1
 #endif
+#if FAN_THERMO_PIN > -1
+#define THERMO_CONTROLLER_INDEX HEATED_BED_INDEX+1
+extern TemperatureController thermoController;
+#else
+#define THERMO_CONTROLLER_INDEX HEATED_BED_INDEX
+#endif
+#define NUM_TEMPERATURE_LOOPS THERMO_CONTROLLER_INDEX+1
+
 #define TEMP_INT_TO_FLOAT(temp) ((float)(temp)/(float)(1<<CELSIUS_EXTRA_BITS))
 #define TEMP_FLOAT_TO_INT(temp) ((int)((temp)*(1<<CELSIUS_EXTRA_BITS)))
 
 //extern Extruder *Extruder::current;
+#if NUM_TEMPERATURE_LOOPS > 0
 extern TemperatureController *tempController[NUM_TEMPERATURE_LOOPS];
+#endif
 extern uint8_t autotuneIndex;
 
 
 #endif // EXTRUDER_H_INCLUDED
-
-

Repetier/FatStructs.h

@@ -416,5 +416,3 @@ static inline uint8_t DIR_IS_FILE_OR_SUBDIR(const dir_t* dir) {
   return (dir->attributes & DIR_ATT_VOLUME_ID) == 0;
 }
 #endif  // FatStructs_h
-
-

Repetier/HAL.cpp

@@ -6,7 +6,9 @@ uint8 osAnalogInputCounter[ANALOG_INPUTS];
 uint osAnalogInputBuildup[ANALOG_INPUTS];
 uint8 osAnalogInputPos = 0; // Current sampling position
 #endif
-
+#if FEATURE_WATCHDOG
+    bool HAL::wdPinged = false;
+#endif
 //extern "C" void __cxa_pure_virtual() { }
 
 HAL::HAL()
@@ -318,8 +320,8 @@ void HAL::analogStart()
     //ADCSRA |= _BV(ADSC);                  // start ADC-conversion
     while (ADCSRA & _BV(ADSC) ) {} // wait for conversion
     /* ADCW must be read once, otherwise the next result is wrong. */
-    uint dummyADCResult;
+    //uint dummyADCResult;
-    dummyADCResult = ADCW;
+    //dummyADCResult = ADCW;
     // Enable interrupt driven conversion loop
     uint8_t channel = pgm_read_byte(&osAnalogInputChannels[osAnalogInputPos]);
 #if defined(ADCSRB) && defined(MUX5)
@@ -782,8 +784,8 @@ ISR(PWM_TIMER_VECTOR)
 {
     static uint8_t pwm_count_cooler = 0;
     static uint8_t pwm_count_heater = 0;
-    static uint8_t pwm_pos_set[NUM_EXTRUDER + 3];
+    static uint8_t pwm_pos_set[NUM_PWM];
-#if NUM_EXTRUDER > 0
+#if NUM_EXTRUDER > 0 && ((defined(EXT0_HEATER_PIN) && EXT0_HEATER_PIN > -1 && EXT0_EXTRUDER_COOLER_PIN > -1) || (NUM_EXTRUDER > 1 && EXT1_EXTRUDER_COOLER_PIN > -1 && EXT1_EXTRUDER_COOLER_PIN != EXT0_EXTRUDER_COOLER_PIN) || (NUM_EXTRUDER > 2 && EXT2_EXTRUDER_COOLER_PIN > -1 && EXT2_EXTRUDER_COOLER_PIN != EXT2_EXTRUDER_COOLER_PIN) || (NUM_EXTRUDER > 3 && EXT3_EXTRUDER_COOLER_PIN > -1 && EXT3_EXTRUDER_COOLER_PIN != EXT3_EXTRUDER_COOLER_PIN) || (NUM_EXTRUDER > 4 && EXT4_EXTRUDER_COOLER_PIN > -1 && EXT4_EXTRUDER_COOLER_PIN != EXT4_EXTRUDER_COOLER_PIN) || (NUM_EXTRUDER > 5 && EXT5_EXTRUDER_COOLER_PIN > -1 && EXT5_EXTRUDER_COOLER_PIN != EXT5_EXTRUDER_COOLER_PIN))
     static uint8_t pwm_cooler_pos_set[NUM_EXTRUDER];
 #endif
     PWM_OCR += 64;
@@ -842,10 +844,16 @@ ISR(PWM_TIMER_VECTOR)
 #endif
 #endif
 #if FAN_BOARD_PIN > -1 && SHARED_COOLER_BOARD_EXT == 0
-        if((pwm_pos_set[NUM_EXTRUDER + 1] = (pwm_pos[NUM_EXTRUDER + 1] & COOLER_PWM_MASK)) > 0) WRITE(FAN_BOARD_PIN,1);
+        if((pwm_pos_set[PWM_BOARD_FAN] = (pwm_pos[PWM_BOARD_FAN] & COOLER_PWM_MASK)) > 0) WRITE(FAN_BOARD_PIN,1);
 #endif
 #if FAN_PIN > -1 && FEATURE_FAN_CONTROL
-        if((pwm_pos_set[NUM_EXTRUDER + 2] = (pwm_pos[NUM_EXTRUDER + 2] & COOLER_PWM_MASK)) > 0) WRITE(FAN_PIN,1);
+        if((pwm_pos_set[PWM_FAN1] = (pwm_pos[PWM_FAN1] & COOLER_PWM_MASK)) > 0) WRITE(FAN_PIN,1);
+#endif
+#if FAN2_PIN > -1 && FEATURE_FAN2_CONTROL
+		if((pwm_pos_set[PWM_FAN2] = (pwm_pos[PWM_FAN2] & COOLER_PWM_MASK)) > 0) WRITE(FAN2_PIN,1);
+#endif
+#if defined(FAN_THERMO_PIN) && FAN_THERMO_PIN > -1
+		if((pwm_pos_set[PWM_FAN_THERMO] = (pwm_pos[PWM_FAN_THERMO] & COOLER_PWM_MASK)) > 0) WRITE(FAN_THERMO_PIN,1);
 #endif
     }
 #if defined(EXT0_HEATER_PIN) && EXT0_HEATER_PIN > -1
@@ -934,21 +942,38 @@ ISR(PWM_TIMER_VECTOR)
 #endif
 #if FAN_BOARD_PIN > -1  && SHARED_COOLER_BOARD_EXT == 0
 #if PDM_FOR_COOLER
-    pulseDensityModulate(FAN_BOARD_PIN, pwm_pos[NUM_EXTRUDER + 1], pwm_pos_set[NUM_EXTRUDER + 1], false);
+    pulseDensityModulate(FAN_BOARD_PIN, pwm_pos[PWM_BOARD_FAN], pwm_pos_set[PWM_BOARD_FAN], false);
 #else
-    if(pwm_pos_set[NUM_EXTRUDER + 1] == pwm_count_cooler && pwm_pos_set[NUM_EXTRUDER + 1] != COOLER_PWM_MASK) WRITE(FAN_BOARD_PIN,0);
+    if(pwm_pos_set[PWM_BOARD_FAN] == pwm_count_cooler && pwm_pos_set[NUM_EXTRUDER + 1] != COOLER_PWM_MASK) WRITE(FAN_BOARD_PIN,0);
 #endif
 #endif
 #if FAN_PIN > -1 && FEATURE_FAN_CONTROL
     if(fanKickstart == 0)
     {
 #if PDM_FOR_COOLER
-        pulseDensityModulate(FAN_PIN, pwm_pos[NUM_EXTRUDER + 2], pwm_pos_set[NUM_EXTRUDER + 2], false);
+        pulseDensityModulate(FAN_PIN, pwm_pos[PWM_FAN1], pwm_pos_set[PWM_FAN1], false);
 #else
-        if(pwm_pos_set[NUM_EXTRUDER + 2] == pwm_count_cooler && pwm_pos_set[NUM_EXTRUDER + 2] != COOLER_PWM_MASK) WRITE(FAN_PIN,0);
+        if(pwm_pos_set[PWM_FAN1] == pwm_count_cooler && pwm_pos_set[PWM_FAN1] != COOLER_PWM_MASK) WRITE(FAN_PIN,0);
 #endif
     }
 #endif
+#if FAN2_PIN > -1 && FEATURE_FAN2_CONTROL
+if(fan2Kickstart == 0)
+{
+	#if PDM_FOR_COOLER
+	pulseDensityModulate(FAN2_PIN, pwm_pos[PWM_FAN2], pwm_pos_set[PWM_FAN2], false);
+	#else
+	if(pwm_pos_set[PWM_FAN2] == pwm_count_cooler && pwm_pos_set[PWM_FAN2] != COOLER_PWM_MASK) WRITE(FAN2_PIN,0);
+	#endif
+}
+#endif
+#if defined(FAN_THERMO_PIN) && FAN_THERMO_PIN > -1
+	#if PDM_FOR_COOLER
+	pulseDensityModulate(FAN_THERMO_PIN, pwm_pos[PWM_FAN_THERMO], pwm_pos_set[PWM_FAN_THERMO], false);
+	#else
+	if(pwm_pos_set[PWM_FAN_THERMO] == pwm_count_cooler && pwm_pos_set[PWM_FAN_THERMO] != COOLER_PWM_MASK) WRITE(FAN_THERMO_PIN,0);
+	#endif
+#endif
 #if HEATED_BED_HEATER_PIN > -1 && HAVE_HEATED_BED
 #if PDM_FOR_EXTRUDER
     pulseDensityModulate(HEATED_BED_HEATER_PIN, pwm_pos[NUM_EXTRUDER], pwm_pos_set[NUM_EXTRUDER], HEATER_PINS_INVERTED);
@@ -957,12 +982,17 @@ ISR(PWM_TIMER_VECTOR)
 #endif
 #endif
     HAL::allowInterrupts();
-    counterPeriodical++; // Appxoimate a 100ms timer
+    counterPeriodical++; // Approximate a 100ms timer
     if(counterPeriodical >= (int)(F_CPU/40960))
     {
         counterPeriodical = 0;
         executePeriodical = 1;
+#if FEATURE_FAN_CONTROL
 		if (fanKickstart) fanKickstart--;
+#endif
+#if FEATURE_FAN2_CONTROL
+		if (fan2Kickstart) fan2Kickstart--;
+#endif
     }
 // read analog values
 #if ANALOG_INPUTS > 0
@@ -1002,6 +1032,12 @@ ISR(PWM_TIMER_VECTOR)
     UI_FAST; // Short timed user interface action
     pwm_count_cooler += COOLER_PWM_STEP;
     pwm_count_heater += HEATER_PWM_STEP;
+#if FEATURE_WATCHDOG
+  if(HAL::wdPinged) {
+     wdt_reset();
+     HAL::wdPinged = false;
+  }
+#endif
 }
 #if USE_ADVANCE
 
@@ -1160,8 +1196,6 @@ ISR(USART_UDRE_vect)
     {
         // There is more data in the output buffer. Send the next byte
         uint8_t c = tx_buffer.buffer[tx_buffer.tail];
-        tx_buffer.tail = (tx_buffer.tail + 1) & SERIAL_TX_BUFFER_MASK;
-
 #if defined(UDR0)
         UDR0 = c;
 #elif defined(UDR)
@@ -1169,6 +1203,7 @@ ISR(USART_UDRE_vect)
 #else
 #error UDR not defined
 #endif
+        tx_buffer.tail = (tx_buffer.tail + 1) & SERIAL_TX_BUFFER_MASK;
     }
 }
 #endif
@@ -1403,9 +1438,9 @@ RFHardwareSerial::write(uint8_t c)
 
     // If the output buffer is full, there's nothing for it other than to
     // wait for the interrupt handler to empty it a bit
-    while (i == _tx_buffer->tail) ;
+    while (i == _tx_buffer->tail) {}
 #if defined(BLUETOOTH_SERIAL) && BLUETOOTH_SERIAL > 0
-    while (i == txx_buffer_tail) ;
+    while (i == txx_buffer_tail) {}
 #endif
     _tx_buffer->buffer[_tx_buffer->head] = c;
     _tx_buffer->head = i;
@@ -1433,5 +1468,3 @@ RFHardwareSerial RFSerial(&rx_buffer, &tx_buffer, &UBRR0H, &UBRR0L, &UCSR0A, &UC
 
 #endif
 
-
-

Repetier/HAL.h

@@ -70,7 +70,9 @@ All known arduino boards use 64. This value is needed for the extruder timing. *
 #endif
 #include <inttypes.h>
 #include "Print.h"
-
+#ifdef EXTERNALSERIAL
+#define SERIAL_RX_BUFFER_SIZE 128
+#endif
 #if defined(ARDUINO) && ARDUINO >= 100
 #include "Arduino.h"
 #else
@@ -132,7 +134,7 @@ public:
 #define I2C_WRITE   0
 
 #if NONLINEAR_SYSTEM
-// Maximum speed with 100% inerrupt utilization is 27000 hz at 16MHz cpu
+// Maximum speed with 100% interrupt utilization is 27000 hz at 16MHz cpu
 // leave some margin for all the extra transformations. So we keep inside clean timings.
 #define LIMIT_INTERVAL ((F_CPU/30000)+1)
 #else
@@ -175,8 +177,15 @@ typedef uint8_t ufast8_t;
 
 #define SERIAL_BUFFER_SIZE 128
 #define SERIAL_BUFFER_MASK 127
+#undef SERIAL_TX_BUFFER_SIZE
+#undef SERIAL_TX_BUFFER_MASK
+#ifdef BIG_OUTPUT_BUFFER
+#define SERIAL_TX_BUFFER_SIZE 128
+#define SERIAL_TX_BUFFER_MASK 127
+#else
 #define SERIAL_TX_BUFFER_SIZE 64
 #define SERIAL_TX_BUFFER_MASK 63
+#endif
 
 struct ring_buffer
 {
@@ -253,6 +262,9 @@ extern RFHardwareSerial RFSerial;
 class HAL
 {
 public:
+#if FEATURE_WATCHDOG
+    static bool wdPinged;
+#endif
     HAL();
     virtual ~HAL();
     static inline void hwSetup(void)
@@ -601,7 +613,7 @@ public:
         SET_OUTPUT(SDSSORIG);
 #endif
         // set SS high - may be chip select for another SPI device
-#if SET_SPI_SS_HIGH
+#if defined(SET_SPI_SS_HIGH) && SET_SPI_SS_HIGH
         WRITE(SDSS, HIGH);
 #endif  // SET_SPI_SS_HIGH
 #endif
@@ -711,7 +723,7 @@ public:
     inline static void pingWatchdog()
     {
 #if FEATURE_WATCHDOG
-        wdt_reset();
+      wdPinged = true;
 #endif
     };
     inline static float maxExtruderTimerFrequency()
@@ -756,5 +768,3 @@ private:
 #define PWM_OCIE OCIE0B
 //#endif
 #endif // HAL_H
-
-

Repetier/Printer.h

@@ -94,6 +94,7 @@ union wizardVar
 #define PRINTER_FLAG2_DEBUG_JAM             16
 #define PRINTER_FLAG2_JAMCONTROL_DISABLED   32
 #define PRINTER_FLAG2_HOMING                64
+#define PRINTER_FLAG2_ALL_E_MOTORS          128 // Set all e motors flag
 
 // List of possible interrupt events (1-255 allowed)
 #define PRINTER_INTERRUPT_EVENT_JAM_DETECTED 1
@@ -106,7 +107,7 @@ union wizardVar
 // 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
+// Some defines to make clearer reading, as we overload these cartesian memory locations for delta
 #define towerAMaxSteps Printer::xMaxSteps
 #define towerBMaxSteps Printer::yMaxSteps
 #define towerCMaxSteps Printer::zMaxSteps
@@ -126,18 +127,27 @@ public:
     int32_t correct(int32_t x, int32_t y, int32_t z) const;
     void updateDerived();
     void reportStatus();
+	bool isEnabled() {return enabled;}
+	int32_t zMaxSteps() {return zEnd;}	
+	void set(float x,float y,float z);
+	void showMatrix();		
+    void resetCorrection();
 private:
-    INLINE int matrixIndex(fast8_t x, fast8_t y) const;
+    int matrixIndex(fast8_t x, fast8_t y) const;
-    INLINE int32_t getMatrix(int index) const;
+    int32_t getMatrix(int index) const;
-    INLINE void setMatrix(int32_t val, int index);
+    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
+#if DRIVE_SYSTEM == DELTA	
     int32_t step;
     int32_t radiusCorrectionSteps;
+#else
+	int32_t xCorrectionSteps,xOffsetSteps;
+	int32_t yCorrectionSteps,yOffsetSteps;
+#endif	
     int32_t zStart,zEnd;
 #if !DISTORTION_PERMANENT
     int32_t matrix[DISTORTION_CORRECTION_POINTS * DISTORTION_CORRECTION_POINTS];
@@ -167,9 +177,11 @@ private:
 class Endstops {
     static flag8_t lastState;
     static flag8_t lastRead;
+    static flag8_t accumulator;
 #ifdef EXTENDED_ENDSTOPS
     static flag8_t lastState2;
     static flag8_t lastRead2;
+    static flag8_t accumulator2;
 #endif
 public:
     static void update();
@@ -177,6 +189,18 @@ public:
     static INLINE bool anyXYZMax() {
         return (lastState & (ENDSTOP_X_MAX_ID|ENDSTOP_Z_MAX_ID|ENDSTOP_Z_MAX_ID)) != 0;
     }
+    static INLINE void resetAccumulator() {
+        accumulator = 0;
+#ifdef EXTENDED_ENDSTOPS
+        accumulator2 = 0;
+#endif
+    }
+    static INLINE void fillFromAccumulator() {
+        lastState = accumulator;
+#ifdef EXTENDED_ENDSTOPS
+        lastState2 = accumulator2;
+#endif
+    }
     static INLINE bool xMin() {
 #if (X_MIN_PIN > -1) && MIN_HARDWARE_ENDSTOP_X
         return (lastState & ENDSTOP_X_MIN_ID) != 0;
@@ -235,12 +259,25 @@ public:
     }
 };
 
+#ifndef DEFAULT_PRINTER_MODE
+#if NUM_EXTRUDER > 0
+#define DEFAULT_PRINTER_MODE PRINTER_MODE_FFF
+#elif defined(SUPPORT_LASER) && SUPPORT_LASER
+#define DEFAULT_PRINTER_MODE PRINTER_MODE_LASER
+#elif defined(SUPPORT_CNC) && SUPPORT_CNC
+#define DEFAULT_PRINTER_MODE PRINTER_MODE_CNC
+#else
+#error No supported printer mode compiled
+#endif
+#endif
+
 class Printer
 {
+    static uint8_t debugLevel;
 public:
 #if USE_ADVANCE
     static volatile int extruderStepsNeeded; ///< This many extruder steps are still needed, <0 = reverse steps needed.
-    static uint8_t maxExtruderSpeed;            ///< Timer delay for end extruder speed
+    static ufast8_t maxExtruderSpeed;            ///< Timer delay for end extruder speed
     //static uint8_t extruderAccelerateDelay;     ///< delay between 2 speec increases
     static int advanceStepsSet;
 #if ENABLE_QUADRATIC_ADVANCE
@@ -260,11 +297,12 @@ public:
     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 mode;
-    static uint8_t debugLevel;
+    static uint8_t fanSpeed; // Last fan speed set with M106/M107
+    static float zBedOffset;
     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 fast8_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.
@@ -293,6 +331,8 @@ public:
     static int16_t travelMovesPerSecond;
     static int16_t printMovesPerSecond;
     static float radius0;
+#else
+	static int32_t zCorrectionStepsIncluded; 	
 #endif
 #if FEATURE_Z_PROBE || MAX_HARDWARE_ENDSTOP_Z || NONLINEAR_SYSTEM
     static int32_t stepsRemainingAtZHit;
@@ -301,7 +341,7 @@ public:
     static int32_t stepsRemainingAtXHit;
     static int32_t stepsRemainingAtYHit;
 #endif
-#if SOFTWARE_LEVELING
+#ifdef SOFTWARE_LEVELING
     static int32_t levelingP1[3];
     static int32_t levelingP2[3];
     static int32_t levelingP3[3];
@@ -309,7 +349,11 @@ public:
 #if FEATURE_AUTOLEVEL
     static float autolevelTransformation[9]; ///< Transformation matrix
 #endif
-    static int8_t zBabystepsMissing;
+#if FAN_THERMO_PIN > -1
+	static float thermoMinTemp;
+	static float thermoMaxTemp;
+#endif
+    static int16_t 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.
@@ -343,9 +387,6 @@ public:
     static float backlashY;
     static float backlashZ;
     static uint8_t backlashDir;
-#endif
-#ifdef DEBUG_STEPCOUNT
-    static long totalStepsRemaining;
 #endif
     static float memoryX;
     static float memoryY;
@@ -372,7 +413,7 @@ public:
         if(highPriority || interruptEvent == 0)
             interruptEvent = evt;
     }
-
+    static void reportPrinterMode();
     static INLINE void setMenuMode(uint8_t mode,bool on)
     {
         if(on)
@@ -385,7 +426,14 @@ public:
     {
         return (menuMode & mode) == mode;
     }
-
+	static void setDebugLevel(uint8_t newLevel);
+	static void toggleEcho();
+	static void toggleInfo();
+	static void toggleErrors();
+	static void toggleDryRun();
+	static void toggleCommunication();
+	static void toggleNoMoves();
+	static INLINE uint8_t getDebugLevel() {return debugLevel;}
     static INLINE bool debugEcho()
     {
         return ((debugLevel & 1) != 0);
@@ -416,21 +464,23 @@ public:
         return ((debugLevel & 32) != 0);
     }
 
-    static INLINE bool debugFlag(unsigned long flags)
+    static INLINE bool debugFlag(uint8_t flags)
     {
         return (debugLevel & flags);
     }
 
-    static INLINE void debugSet(unsigned long flags)
+    static INLINE void debugSet(uint8_t flags)
     {
-        debugLevel |= flags;
+        setDebugLevel(debugLevel | flags);
     }
 
-    static INLINE void debugReset(unsigned long flags)
+    static INLINE void debugReset(uint8_t flags)
     {
-        debugLevel &= ~flags;
+        setDebugLevel(debugLevel & ~flags);
     }
-
+    /** Sets the pwm for the fan speed. Gets called by motion control ot Commands::setFanSpeed. */
+    static void setFanSpeedDirectly(uint8_t speed);
+    static void setFan2SpeedDirectly(uint8_t speed);
     /** \brief Disable stepper motor for x direction. */
     static INLINE void disableXStepper()
     {
@@ -460,6 +510,9 @@ public:
 #endif
 #if FEATURE_TWO_ZSTEPPER && (Z2_ENABLE_PIN > -1)
         WRITE(Z2_ENABLE_PIN, !Z_ENABLE_ON);
+#endif
+#if FEATURE_THREE_ZSTEPPER && (Z3_ENABLE_PIN > -1)
+        WRITE(Z3_ENABLE_PIN, !Z_ENABLE_ON);
 #endif
     }
 
@@ -492,6 +545,9 @@ public:
 #endif
 #if FEATURE_TWO_ZSTEPPER && (Z2_ENABLE_PIN > -1)
         WRITE(Z2_ENABLE_PIN, Z_ENABLE_ON);
+#endif
+#if FEATURE_THREE_ZSTEPPER && (Z3_ENABLE_PIN > -1)
+        WRITE(Z3_ENABLE_PIN, Z_ENABLE_ON);
 #endif
     }
 
@@ -537,6 +593,9 @@ public:
             WRITE(Z_DIR_PIN, !INVERT_Z_DIR);
 #if FEATURE_TWO_ZSTEPPER
             WRITE(Z2_DIR_PIN, !INVERT_Z_DIR);
+#endif
+#if FEATURE_THREE_ZSTEPPER
+            WRITE(Z3_DIR_PIN, !INVERT_Z_DIR);
 #endif
         }
         else
@@ -544,6 +603,9 @@ public:
             WRITE(Z_DIR_PIN, INVERT_Z_DIR);
 #if FEATURE_TWO_ZSTEPPER
             WRITE(Z2_DIR_PIN, INVERT_Z_DIR);
+#endif
+#if FEATURE_THREE_ZSTEPPER
+            WRITE(Z3_DIR_PIN, INVERT_Z_DIR);
 #endif
         }
     }
@@ -697,6 +759,15 @@ public:
     {
         flag2 = (b ? flag2 | PRINTER_FLAG2_HOMING : flag2 & ~PRINTER_FLAG2_HOMING);
     }
+    static INLINE uint8_t isAllEMotors()
+    {
+        return flag2 & PRINTER_FLAG2_ALL_E_MOTORS;
+    }
+
+    static INLINE void setAllEMotors(uint8_t b)
+    {
+        flag2 = (b ? flag2 | PRINTER_FLAG2_ALL_E_MOTORS : flag2 & ~PRINTER_FLAG2_ALL_E_MOTORS);
+    }
 
     static INLINE uint8_t isDebugJam()
     {
@@ -745,7 +816,7 @@ public:
     {
         flag0 &= ~PRINTER_FLAG0_STEPPER_DISABLED;
 #if FAN_BOARD_PIN > -1
-        pwm_pos[NUM_EXTRUDER + 1] = 255;
+        pwm_pos[PWM_BOARD_FAN] = 255;
 #endif // FAN_BOARD_PIN
     }
     static INLINE bool isAnyTempsensorDefect()
@@ -786,33 +857,33 @@ public:
 #if (GANTRY)
         if(motorX <= -2)
         {
-            WRITE(X_STEP_PIN,HIGH);
+            WRITE(X_STEP_PIN,START_STEP_WITH_HIGH);
 #if FEATURE_TWO_XSTEPPER
-            WRITE(X2_STEP_PIN,HIGH);
+            WRITE(X2_STEP_PIN,START_STEP_WITH_HIGH);
 #endif
             motorX += 2;
         }
         else if(motorX >= 2)
         {
-            WRITE(X_STEP_PIN,HIGH);
+            WRITE(X_STEP_PIN,START_STEP_WITH_HIGH);
 #if FEATURE_TWO_XSTEPPER
-            WRITE(X2_STEP_PIN,HIGH);
+            WRITE(X2_STEP_PIN,START_STEP_WITH_HIGH);
 #endif
             motorX -= 2;
         }
         if(motorYorZ <= -2)
         {
-            WRITE(Y_STEP_PIN,HIGH);
+            WRITE(Y_STEP_PIN,START_STEP_WITH_HIGH);
 #if FEATURE_TWO_YSTEPPER
-            WRITE(Y2_STEP_PIN,HIGH);
+            WRITE(Y2_STEP_PIN,START_STEP_WITH_HIGH);
 #endif
             motorYorZ += 2;
         }
         else if(motorYorZ >= 2)
         {
-            WRITE(Y_STEP_PIN,HIGH);
+            WRITE(Y_STEP_PIN,START_STEP_WITH_HIGH);
 #if FEATURE_TWO_YSTEPPER
-            WRITE(Y2_STEP_PIN,HIGH);
+            WRITE(Y2_STEP_PIN,START_STEP_WITH_HIGH);
 #endif
             motorYorZ -= 2;
         }
@@ -823,53 +894,86 @@ public:
 #if (GANTRY)
         if(motorX <= -2)
         {
-            WRITE(X_STEP_PIN,HIGH);
+            WRITE(X_STEP_PIN,START_STEP_WITH_HIGH);
 #if FEATURE_TWO_XSTEPPER
-            WRITE(X2_STEP_PIN,HIGH);
+            WRITE(X2_STEP_PIN,START_STEP_WITH_HIGH);
 #endif
             motorX += 2;
         }
         else if(motorX >= 2)
         {
-            WRITE(X_STEP_PIN,HIGH);
+            WRITE(X_STEP_PIN,START_STEP_WITH_HIGH);
 #if FEATURE_TWO_XSTEPPER
-            WRITE(X2_STEP_PIN,HIGH);
+            WRITE(X2_STEP_PIN,START_STEP_WITH_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);
+            WRITE(Z_STEP_PIN,START_STEP_WITH_HIGH);
 #if FEATURE_TWO_ZSTEPPER
-            WRITE(Z2_STEP_PIN,HIGH);
+            WRITE(Z2_STEP_PIN,START_STEP_WITH_HIGH);
+#endif
+#if FEATURE_THREE_ZSTEPPER
+            WRITE(Z3_STEP_PIN,START_STEP_WITH_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);
+            WRITE(Z_STEP_PIN,START_STEP_WITH_HIGH);
 #if FEATURE_TWO_ZSTEPPER
-            WRITE(Z2_STEP_PIN,HIGH);
+            WRITE(Z2_STEP_PIN,START_STEP_WITH_HIGH);
+#endif
+#if FEATURE_THREE_ZSTEPPER
+            WRITE(Z3_STEP_PIN,START_STEP_WITH_HIGH);
 #endif
             motorYorZ -= 2;
         }
+#endif
+    }
+    static INLINE void startXStep()
+    {
+        WRITE(X_STEP_PIN,START_STEP_WITH_HIGH);
+#if FEATURE_TWO_XSTEPPER
+        WRITE(X2_STEP_PIN,START_STEP_WITH_HIGH);
+#endif
+    }
+    static INLINE void startYStep()
+    {
+        WRITE(Y_STEP_PIN,START_STEP_WITH_HIGH);
+#if FEATURE_TWO_YSTEPPER
+        WRITE(Y2_STEP_PIN,START_STEP_WITH_HIGH);
+#endif
+    }
+    static INLINE void startZStep()
+    {
+        WRITE(Z_STEP_PIN,START_STEP_WITH_HIGH);
+#if FEATURE_TWO_ZSTEPPER
+        WRITE(Z2_STEP_PIN,START_STEP_WITH_HIGH);
+#endif
+#if FEATURE_THREE_ZSTEPPER
+        WRITE(Z3_STEP_PIN,START_STEP_WITH_HIGH);
 #endif
     }
     static INLINE void endXYZSteps()
     {
-        WRITE(X_STEP_PIN,LOW);
+        WRITE(X_STEP_PIN,!START_STEP_WITH_HIGH);
 #if FEATURE_TWO_XSTEPPER
-        WRITE(X2_STEP_PIN,LOW);
+        WRITE(X2_STEP_PIN,!START_STEP_WITH_HIGH);
 #endif
-        WRITE(Y_STEP_PIN,LOW);
+        WRITE(Y_STEP_PIN,!START_STEP_WITH_HIGH);
 #if FEATURE_TWO_YSTEPPER
-        WRITE(Y2_STEP_PIN,LOW);
+        WRITE(Y2_STEP_PIN,!START_STEP_WITH_HIGH);
 #endif
-        WRITE(Z_STEP_PIN,LOW);
+        WRITE(Z_STEP_PIN,!START_STEP_WITH_HIGH);
 #if FEATURE_TWO_ZSTEPPER
-        WRITE(Z2_STEP_PIN,LOW);
+        WRITE(Z2_STEP_PIN,!START_STEP_WITH_HIGH);
+#endif
+#if FEATURE_THREE_ZSTEPPER
+        WRITE(Z3_STEP_PIN,!START_STEP_WITH_HIGH);
 #endif
     }
     static INLINE speed_t updateStepsPerTimerCall(speed_t vbase)
@@ -956,13 +1060,17 @@ public:
     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 uint8_t moveToReal(float x,float y,float z,float e,float f,bool pathOptimize = true);
     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];
+        return (int)pwm_pos[PWM_FAN1];
+    }
+    static INLINE int getFan2Speed()
+    {
+	    return (int)pwm_pos[PWM_FAN2];
     }
 #if NONLINEAR_SYSTEM
     static INLINE void setDeltaPositions(long xaxis, long yaxis, long zaxis)
@@ -977,8 +1085,11 @@ public:
     static float runZMaxProbe();
 #endif
 #if FEATURE_Z_PROBE
+	static void startProbing(bool runScript);
+	static void finishProbing();
     static float runZProbe(bool first,bool last,uint8_t repeat = Z_PROBE_REPETITIONS,bool runStartScript = true);
     static void waitForZProbeStart();
+    static float bendingCorrectionAt(float x,float y);
 #endif
     // Moved outside FEATURE_Z_PROBE to allow auto-level functional test on
     // system without Z-probe
@@ -1011,6 +1122,9 @@ public:
     static void showConfiguration();
     static void setCaseLight(bool on);
     static void reportCaseLightStatus();
+#if JSON_OUTPUT
+    static void showJSONStatus(int type);
+#endif
 private:
     static void homeXAxis();
     static void homeYAxis();
@@ -1018,5 +1132,3 @@ private:
 };
 
 #endif // PRINTER_H_INCLUDED
-
-

Repetier/Repetier.cbp

@@ -1,875 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
-<CodeBlocks_project_file>
-	<FileVersion major="1" minor="6" />
-	<Project>
-		<Option title="Repetier" />
-		<Option pch_mode="2" />
-		<Option compiler="avrgcc" />
-		<Option virtualFolders="libraries\;" />
-		<Build>
-			<Target title="Simulator - Debug">
-				<Option output="bin/Release/Repetier_sim.exe" prefix_auto="1" extension_auto="0" />
-				<Option object_output="obj/Debug/" />
-				<Option type="1" />
-				<Option compiler="GCC" />
-				<Compiler>
-					<Add option="-g" />
-					<Add option="-DF_CPU=16000000L" />
-					<Add option="-DARDUSIM" />
-					<Add option="-D__AVR_ATmega2560__" />
-					<Add option="-x c++" />
-					<Add directory="$(ARDUINO_DIR)/arduino/cores" />
-					<Add directory="$(ARDUINO_DIR)/arduino/variants/standard" />
-					<Add directory="$(ARDUINO_DIR)/include" />
-				</Compiler>
-				<Environment>
-					<Variable name="ARDUINO_DIR" value="$(APP_PATH)\ardusim" />
-				</Environment>
-			</Target>
-			<Target title="Simulator - Release">
-				<Option output="bin/Release/Repetier_sim.exe" prefix_auto="1" extension_auto="0" />
-				<Option object_output="obj/Release/" />
-				<Option type="1" />
-				<Option compiler="GCC" />
-				<Compiler>
-					<Add option="-Os" />
-					<Add option="-DF_CPU=16000000L" />
-					<Add option="-DARDUSIM" />
-					<Add option="-D__AVR_ATmega2560__" />
-					<Add option="-x c++" />
-					<Add directory="$(ARDUINO_DIR)/arduino/cores" />
-					<Add directory="$(ARDUINO_DIR)/arduino/variants/standard" />
-					<Add directory="$(ARDUINO_DIR)/include" />
-				</Compiler>
-				<Environment>
-					<Variable name="ARDUINO_DIR" value="$(APP_PATH)\ardusim" />
-				</Environment>
-			</Target>
-			<Target title="Arduino Uno">
-				<Option output="bin/Release/Repetier_${BOARD_ID}_${UPLOAD_PORT}.elf" prefix_auto="1" extension_auto="0" />
-				<Option type="1" />
-				<Option compiler="avrgcc" />
-				<Compiler>
-					<Add option="-mmcu=$(MCU)" />
-					<Add option="-DF_CPU=16000000L" />
-					<Add option="-D__AVR_ATmega328P__" />
-					<Add option="-Os" />
-					<Add directory="$(ARDUINO_DIR)/hardware/arduino/cores/arduino" />
-					<Add directory="$(ARDUINO_DIR)/libraries" />
-					<Add directory="$(ARDUINO_DIR)/hardware/arduino/variants/standard" />
-				</Compiler>
-				<Linker>
-					<Add option="-mmcu=$(MCU)" />
-					<Add option="-Wl,-Map=$(TARGET_OUTPUT_FILE).map,--cref" />
-				</Linker>
-				<ExtraCommands>
-					<Add after="avr-objcopy -O ihex -R .eeprom -R .eesafe $(TARGET_OUTPUT_FILE) $(TARGET_OUTPUT_FILE).hex" />
-					<Add after="avr-objcopy --no-change-warnings -j .eeprom --change-section-lma .eeprom=0 -O ihex $(TARGET_OUTPUT_FILE) $(TARGET_OUTPUT_FILE).eep.hex" />
-					<Add after="avr-size --mcu=$(MCU) --format=avr $(TARGET_OUTPUT_FILE)" />
-					<Add after='cmd /c &quot;avr-objdump -h -S $(TARGET_OUTPUT_FILE) &gt; $(TARGET_OUTPUT_FILE).lss&quot;' />
-				</ExtraCommands>
-				<Environment>
-					<Variable name="BOARD" value="Arduino Uno" />
-					<Variable name="BOARD_ID" value="uno" />
-					<Variable name="MCU" value="atmega328p" />
-					<Variable name="UPLOAD_BAUDRATE" value="115200" />
-					<Variable name="UPLOAD_PORT" value="" />
-				</Environment>
-			</Target>
-			<Target title="Arduino Leonardo">
-				<Option output="bin/Release/Repetier_${BOARD_ID}_${UPLOAD_PORT}.elf" prefix_auto="1" extension_auto="0" />
-				<Option type="1" />
-				<Option compiler="avrgcc" />
-				<Compiler>
-					<Add option="-mmcu=$(MCU)" />
-					<Add option="-DF_CPU=16000000L" />
-					<Add option="-D__AVR_ATmega32U4__" />
-					<Add option="-DUSB_VID=0x2341" />
-					<Add option="-DUSB_PID=0x8036" />
-					<Add option="-Os" />
-					<Add directory="$(ARDUINO_DIR)/hardware/arduino/cores/arduino" />
-					<Add directory="$(ARDUINO_DIR)/libraries" />
-					<Add directory="$(ARDUINO_DIR)/hardware/arduino/variants/leonardo" />
-				</Compiler>
-				<Linker>
-					<Add option="-mmcu=$(MCU)" />
-					<Add option="-Wl,-Map=$(TARGET_OUTPUT_FILE).map,--cref" />
-				</Linker>
-				<ExtraCommands>
-					<Add after="avr-objcopy -O ihex -R .eeprom -R .eesafe $(TARGET_OUTPUT_FILE) $(TARGET_OUTPUT_FILE).hex" />
-					<Add after="avr-objcopy --no-change-warnings -j .eeprom --change-section-lma .eeprom=0 -O ihex $(TARGET_OUTPUT_FILE) $(TARGET_OUTPUT_FILE).eep.hex" />
-					<Add after="avr-size --mcu=$(MCU) --format=avr $(TARGET_OUTPUT_FILE)" />
-					<Add after='cmd /c &quot;avr-objdump -h -S $(TARGET_OUTPUT_FILE) &gt; $(TARGET_OUTPUT_FILE).lss&quot;' />
-				</ExtraCommands>
-				<Environment>
-					<Variable name="BOARD" value="Arduino Leonardo" />
-					<Variable name="BOARD_ID" value="leonardo" />
-					<Variable name="MCU" value="atmega32u4" />
-					<Variable name="UPLOAD_BAUDRATE" value="57600" />
-					<Variable name="UPLOAD_PORT" value="" />
-				</Environment>
-			</Target>
-			<Target title="Arduino Esplora">
-				<Option output="bin/Release/Repetier_${BOARD_ID}_${UPLOAD_PORT}.elf" prefix_auto="1" extension_auto="0" />
-				<Option type="1" />
-				<Option compiler="avrgcc" />
-				<Compiler>
-					<Add option="-mmcu=$(MCU)" />
-					<Add option="-DF_CPU=16000000L" />
-					<Add option="-D__AVR_ATmega32U4__" />
-					<Add option="-DUSB_VID=0x2341" />
-					<Add option="-DUSB_PID=0x8037" />
-					<Add option="-Os" />
-					<Add directory="$(ARDUINO_DIR)/hardware/arduino/cores/arduino" />
-					<Add directory="$(ARDUINO_DIR)/libraries" />
-					<Add directory="$(ARDUINO_DIR)/hardware/arduino/variants/leonardo" />
-				</Compiler>
-				<Linker>
-					<Add option="-mmcu=$(MCU)" />
-					<Add option="-Wl,-Map=$(TARGET_OUTPUT_FILE).map,--cref" />
-				</Linker>
-				<ExtraCommands>
-					<Add after="avr-objcopy -O ihex -R .eeprom -R .eesafe $(TARGET_OUTPUT_FILE) $(TARGET_OUTPUT_FILE).hex" />
-					<Add after="avr-objcopy --no-change-warnings -j .eeprom --change-section-lma .eeprom=0 -O ihex $(TARGET_OUTPUT_FILE) $(TARGET_OUTPUT_FILE).eep.hex" />
-					<Add after="avr-size --mcu=$(MCU) --format=avr $(TARGET_OUTPUT_FILE)" />
-					<Add after='cmd /c &quot;avr-objdump -h -S $(TARGET_OUTPUT_FILE) &gt; $(TARGET_OUTPUT_FILE).lss&quot;' />
-				</ExtraCommands>
-				<Environment>
-					<Variable name="BOARD" value="Arduino Esplora" />
-					<Variable name="BOARD_ID" value="esplora" />
-					<Variable name="MCU" value="atmega32u4" />
-					<Variable name="UPLOAD_BAUDRATE" value="57600" />
-					<Variable name="UPLOAD_PORT" value="" />
-				</Environment>
-			</Target>
-			<Target title="Arduino Micro">
-				<Option output="bin/Release/Repetier_${BOARD_ID}_${UPLOAD_PORT}.elf" prefix_auto="1" extension_auto="0" />
-				<Option type="1" />
-				<Option compiler="avrgcc" />
-				<Compiler>
-					<Add option="-mmcu=$(MCU)" />
-					<Add option="-DF_CPU=16000000L" />
-					<Add option="-D__AVR_ATmega32U4__" />
-					<Add option="-DUSB_VID=0x2341" />
-					<Add option="-DUSB_PID=0x803C" />
-					<Add option="-Os" />
-					<Add directory="$(ARDUINO_DIR)/hardware/arduino/cores/arduino" />
-					<Add directory="$(ARDUINO_DIR)/libraries" />
-					<Add directory="$(ARDUINO_DIR)/hardware/arduino/variants/micro" />
-				</Compiler>
-				<Linker>
-					<Add option="-mmcu=$(MCU)" />
-					<Add option="-Wl,-Map=$(TARGET_OUTPUT_FILE).map,--cref" />
-				</Linker>
-				<ExtraCommands>
-					<Add after="avr-objcopy -O ihex -R .eeprom -R .eesafe $(TARGET_OUTPUT_FILE) $(TARGET_OUTPUT_FILE).hex" />
-					<Add after="avr-objcopy --no-change-warnings -j .eeprom --change-section-lma .eeprom=0 -O ihex $(TARGET_OUTPUT_FILE) $(TARGET_OUTPUT_FILE).eep.hex" />
-					<Add after="avr-size --mcu=$(MCU) --format=avr $(TARGET_OUTPUT_FILE)" />
-					<Add after='cmd /c &quot;avr-objdump -h -S $(TARGET_OUTPUT_FILE) &gt; $(TARGET_OUTPUT_FILE).lss&quot;' />
-				</ExtraCommands>
-				<Environment>
-					<Variable name="BOARD" value="Arduino Micro" />
-					<Variable name="BOARD_ID" value="micro" />
-					<Variable name="MCU" value="atmega32u4" />
-					<Variable name="UPLOAD_BAUDRATE" value="57600" />
-					<Variable name="UPLOAD_PORT" value="" />
-				</Environment>
-			</Target>
-			<Target title="Arduino Duemilanove (328)">
-				<Option output="bin/Release/Repetier_${BOARD_ID}_${UPLOAD_PORT}.elf" prefix_auto="1" extension_auto="0" />
-				<Option type="1" />
-				<Option compiler="avrgcc" />
-				<Compiler>
-					<Add option="-mmcu=$(MCU)" />
-					<Add option="-DF_CPU=16000000L" />
-					<Add option="-D__AVR_ATmega328P__" />
-					<Add option="-Os" />
-					<Add directory="$(ARDUINO_DIR)/hardware/arduino/cores/arduino" />
-					<Add directory="$(ARDUINO_DIR)/libraries" />
-					<Add directory="$(ARDUINO_DIR)/hardware/arduino/variants/standard" />
-				</Compiler>
-				<Linker>
-					<Add option="-mmcu=$(MCU)" />
-					<Add option="-Wl,-Map=$(TARGET_OUTPUT_FILE).map,--cref" />
-				</Linker>
-				<ExtraCommands>
-					<Add after="avr-objcopy -O ihex -R .eeprom -R .eesafe $(TARGET_OUTPUT_FILE) $(TARGET_OUTPUT_FILE).hex" />
-					<Add after="avr-objcopy --no-change-warnings -j .eeprom --change-section-lma .eeprom=0 -O ihex $(TARGET_OUTPUT_FILE) $(TARGET_OUTPUT_FILE).eep.hex" />
-					<Add after="avr-size --mcu=$(MCU) --format=avr $(TARGET_OUTPUT_FILE)" />
-					<Add after='cmd /c &quot;avr-objdump -h -S $(TARGET_OUTPUT_FILE) &gt; $(TARGET_OUTPUT_FILE).lss&quot;' />
-				</ExtraCommands>
-				<Environment>
-					<Variable name="BOARD" value="Arduino Duemilanove (328)" />
-					<Variable name="BOARD_ID" value="duemilanove328" />
-					<Variable name="MCU" value="atmega328p" />
-					<Variable name="UPLOAD_BAUDRATE" value="57600" />
-					<Variable name="UPLOAD_PORT" value="" />
-				</Environment>
-			</Target>
-			<Target title="Arduino Duemilanove (168)">
-				<Option output="bin/Release/Repetier_${BOARD_ID}_${UPLOAD_PORT}.elf" prefix_auto="1" extension_auto="0" />
-				<Option type="1" />
-				<Option compiler="avrgcc" />
-				<Compiler>
-					<Add option="-mmcu=$(MCU)" />
-					<Add option="-DF_CPU=16000000L" />
-					<Add option="-D__AVR_ATmega168__" />
-					<Add option="-Os" />
-					<Add directory="$(ARDUINO_DIR)/hardware/arduino/cores/arduino" />
-					<Add directory="$(ARDUINO_DIR)/libraries" />
-					<Add directory="$(ARDUINO_DIR)/hardware/arduino/variants/standard" />
-				</Compiler>
-				<Linker>
-					<Add option="-mmcu=$(MCU)" />
-					<Add option="-Wl,-Map=$(TARGET_OUTPUT_FILE).map,--cref" />
-				</Linker>
-				<ExtraCommands>
-					<Add after="avr-objcopy -O ihex -R .eeprom -R .eesafe $(TARGET_OUTPUT_FILE) $(TARGET_OUTPUT_FILE).hex" />
-					<Add after="avr-objcopy --no-change-warnings -j .eeprom --change-section-lma .eeprom=0 -O ihex $(TARGET_OUTPUT_FILE) $(TARGET_OUTPUT_FILE).eep.hex" />
-					<Add after="avr-size --mcu=$(MCU) --format=avr $(TARGET_OUTPUT_FILE)" />
-					<Add after='cmd /c &quot;avr-objdump -h -S $(TARGET_OUTPUT_FILE) &gt; $(TARGET_OUTPUT_FILE).lss&quot;' />
-				</ExtraCommands>
-				<Environment>
-					<Variable name="BOARD" value="Arduino Duemilanove (168)" />
-					<Variable name="BOARD_ID" value="duemilanove168" />
-					<Variable name="MCU" value="atmega168" />
-					<Variable name="UPLOAD_BAUDRATE" value="19200" />
-					<Variable name="UPLOAD_PORT" value="" />
-				</Environment>
-			</Target>
-			<Target title="Arduino Nano (328)">
-				<Option output="bin/Release/Repetier_${BOARD_ID}_${UPLOAD_PORT}.elf" prefix_auto="1" extension_auto="0" />
-				<Option type="1" />
-				<Option compiler="avrgcc" />
-				<Compiler>
-					<Add option="-mmcu=$(MCU)" />
-					<Add option="-DF_CPU=16000000L" />
-					<Add option="-D__AVR_ATmega328P__" />
-					<Add option="-Os" />
-					<Add directory="$(ARDUINO_DIR)/hardware/arduino/cores/arduino" />
-					<Add directory="$(ARDUINO_DIR)/libraries" />
-					<Add directory="$(ARDUINO_DIR)/hardware/arduino/variants/eightanaloginputs" />
-				</Compiler>
-				<Linker>
-					<Add option="-mmcu=$(MCU)" />
-					<Add option="-Wl,-Map=$(TARGET_OUTPUT_FILE).map,--cref" />
-				</Linker>
-				<ExtraCommands>
-					<Add after="avr-objcopy -O ihex -R .eeprom -R .eesafe $(TARGET_OUTPUT_FILE) $(TARGET_OUTPUT_FILE).hex" />
-					<Add after="avr-objcopy --no-change-warnings -j .eeprom --change-section-lma .eeprom=0 -O ihex $(TARGET_OUTPUT_FILE) $(TARGET_OUTPUT_FILE).eep.hex" />
-					<Add after="avr-size --mcu=$(MCU) --format=avr $(TARGET_OUTPUT_FILE)" />
-					<Add after='cmd /c &quot;avr-objdump -h -S $(TARGET_OUTPUT_FILE) &gt; $(TARGET_OUTPUT_FILE).lss&quot;' />
-				</ExtraCommands>
-				<Environment>
-					<Variable name="BOARD" value="Arduino Nano (328)" />
-					<Variable name="BOARD_ID" value="nano328" />
-					<Variable name="MCU" value="atmega328p" />
-					<Variable name="UPLOAD_BAUDRATE" value="57600" />
-					<Variable name="UPLOAD_PORT" value="" />
-				</Environment>
-			</Target>
-			<Target title="Arduino Nano (168)">
-				<Option output="bin/Release/Repetier_${BOARD_ID}_${UPLOAD_PORT}.elf" prefix_auto="1" extension_auto="0" />
-				<Option type="1" />
-				<Option compiler="avrgcc" />
-				<Compiler>
-					<Add option="-mmcu=$(MCU)" />
-					<Add option="-DF_CPU=16000000L" />
-					<Add option="-D__AVR_ATmega168__" />
-					<Add option="-Os" />
-					<Add directory="$(ARDUINO_DIR)/hardware/arduino/cores/arduino" />
-					<Add directory="$(ARDUINO_DIR)/libraries" />
-					<Add directory="$(ARDUINO_DIR)/hardware/arduino/variants/eightanaloginputs" />
-				</Compiler>
-				<Linker>
-					<Add option="-mmcu=$(MCU)" />
-					<Add option="-Wl,-Map=$(TARGET_OUTPUT_FILE).map,--cref" />
-				</Linker>
-				<ExtraCommands>
-					<Add after="avr-objcopy -O ihex -R .eeprom -R .eesafe $(TARGET_OUTPUT_FILE) $(TARGET_OUTPUT_FILE).hex" />
-					<Add after="avr-objcopy --no-change-warnings -j .eeprom --change-section-lma .eeprom=0 -O ihex $(TARGET_OUTPUT_FILE) $(TARGET_OUTPUT_FILE).eep.hex" />
-					<Add after="avr-size --mcu=$(MCU) --format=avr $(TARGET_OUTPUT_FILE)" />
-					<Add after='cmd /c &quot;avr-objdump -h -S $(TARGET_OUTPUT_FILE) &gt; $(TARGET_OUTPUT_FILE).lss&quot;' />
-				</ExtraCommands>
-				<Environment>
-					<Variable name="BOARD" value="Arduino Nano (168)" />
-					<Variable name="BOARD_ID" value="nano168" />
-					<Variable name="MCU" value="atmega168" />
-					<Variable name="UPLOAD_BAUDRATE" value="19200" />
-					<Variable name="UPLOAD_PORT" value="" />
-				</Environment>
-			</Target>
-			<Target title="Arduino Mini (328)">
-				<Option output="bin/Release/Repetier_${BOARD_ID}_${UPLOAD_PORT}.elf" prefix_auto="1" extension_auto="0" />
-				<Option type="1" />
-				<Option compiler="avrgcc" />
-				<Compiler>
-					<Add option="-mmcu=$(MCU)" />
-					<Add option="-DF_CPU=16000000L" />
-					<Add option="-D__AVR_ATmega328P__" />
-					<Add option="-Os" />
-					<Add directory="$(ARDUINO_DIR)/hardware/arduino/cores/arduino" />
-					<Add directory="$(ARDUINO_DIR)/libraries" />
-					<Add directory="$(ARDUINO_DIR)/hardware/arduino/variants/eightanaloginputs" />
-				</Compiler>
-				<Linker>
-					<Add option="-mmcu=$(MCU)" />
-					<Add option="-Wl,-Map=$(TARGET_OUTPUT_FILE).map,--cref" />
-				</Linker>
-				<ExtraCommands>
-					<Add after="avr-objcopy -O ihex -R .eeprom -R .eesafe $(TARGET_OUTPUT_FILE) $(TARGET_OUTPUT_FILE).hex" />
-					<Add after="avr-objcopy --no-change-warnings -j .eeprom --change-section-lma .eeprom=0 -O ihex $(TARGET_OUTPUT_FILE) $(TARGET_OUTPUT_FILE).eep.hex" />
-					<Add after="avr-size --mcu=$(MCU) --format=avr $(TARGET_OUTPUT_FILE)" />
-					<Add after='cmd /c &quot;avr-objdump -h -S $(TARGET_OUTPUT_FILE) &gt; $(TARGET_OUTPUT_FILE).lss&quot;' />
-				</ExtraCommands>
-				<Environment>
-					<Variable name="BOARD" value="Arduino Mini (328)" />
-					<Variable name="BOARD_ID" value="mini328" />
-					<Variable name="MCU" value="atmega328p" />
-					<Variable name="UPLOAD_BAUDRATE" value="57600" />
-					<Variable name="UPLOAD_PORT" value="" />
-				</Environment>
-			</Target>
-			<Target title="Arduino Mini (168)">
-				<Option output="bin/Release/Repetier_${BOARD_ID}_${UPLOAD_PORT}.elf" prefix_auto="1" extension_auto="0" />
-				<Option type="1" />
-				<Option compiler="avrgcc" />
-				<Compiler>
-					<Add option="-mmcu=$(MCU)" />
-					<Add option="-DF_CPU=16000000L" />
-					<Add option="-D__AVR_ATmega168__" />
-					<Add option="-Os" />
-					<Add directory="$(ARDUINO_DIR)/hardware/arduino/cores/arduino" />
-					<Add directory="$(ARDUINO_DIR)/libraries" />
-					<Add directory="$(ARDUINO_DIR)/hardware/arduino/variants/eightanaloginputs" />
-				</Compiler>
-				<Linker>
-					<Add option="-mmcu=$(MCU)" />
-					<Add option="-Wl,-Map=$(TARGET_OUTPUT_FILE).map,--cref" />
-				</Linker>
-				<ExtraCommands>
-					<Add after="avr-objcopy -O ihex -R .eeprom -R .eesafe $(TARGET_OUTPUT_FILE) $(TARGET_OUTPUT_FILE).hex" />
-					<Add after="avr-objcopy --no-change-warnings -j .eeprom --change-section-lma .eeprom=0 -O ihex $(TARGET_OUTPUT_FILE) $(TARGET_OUTPUT_FILE).eep.hex" />
-					<Add after="avr-size --mcu=$(MCU) --format=avr $(TARGET_OUTPUT_FILE)" />
-					<Add after='cmd /c &quot;avr-objdump -h -S $(TARGET_OUTPUT_FILE) &gt; $(TARGET_OUTPUT_FILE).lss&quot;' />
-				</ExtraCommands>
-				<Environment>
-					<Variable name="BOARD" value="Arduino Mini (168)" />
-					<Variable name="BOARD_ID" value="mini168" />
-					<Variable name="MCU" value="atmega168" />
-					<Variable name="UPLOAD_BAUDRATE" value="19200" />
-					<Variable name="UPLOAD_PORT" value="" />
-				</Environment>
-			</Target>
-			<Target title="Arduino Pro Mini (328)">
-				<Option output="bin/Release/Repetier_${BOARD_ID}_${UPLOAD_PORT}.elf" prefix_auto="1" extension_auto="0" />
-				<Option type="1" />
-				<Option compiler="avrgcc" />
-				<Compiler>
-					<Add option="-mmcu=$(MCU)" />
-					<Add option="-DF_CPU=16000000L" />
-					<Add option="-D__AVR_ATmega328P__" />
-					<Add option="-Os" />
-					<Add directory="$(ARDUINO_DIR)/hardware/arduino/cores/arduino" />
-					<Add directory="$(ARDUINO_DIR)/libraries" />
-					<Add directory="$(ARDUINO_DIR)/hardware/arduino/variants/standard" />
-				</Compiler>
-				<Linker>
-					<Add option="-mmcu=$(MCU)" />
-					<Add option="-Wl,-Map=$(TARGET_OUTPUT_FILE).map,--cref" />
-				</Linker>
-				<ExtraCommands>
-					<Add after="avr-objcopy -O ihex -R .eeprom -R .eesafe $(TARGET_OUTPUT_FILE) $(TARGET_OUTPUT_FILE).hex" />
-					<Add after="avr-objcopy --no-change-warnings -j .eeprom --change-section-lma .eeprom=0 -O ihex $(TARGET_OUTPUT_FILE) $(TARGET_OUTPUT_FILE).eep.hex" />
-					<Add after="avr-size --mcu=$(MCU) --format=avr $(TARGET_OUTPUT_FILE)" />
-					<Add after='cmd /c &quot;avr-objdump -h -S $(TARGET_OUTPUT_FILE) &gt; $(TARGET_OUTPUT_FILE).lss&quot;' />
-				</ExtraCommands>
-				<Environment>
-					<Variable name="BOARD" value="Arduino Pro Mini (328)" />
-					<Variable name="BOARD_ID" value="promini328" />
-					<Variable name="MCU" value="atmega328p" />
-					<Variable name="UPLOAD_BAUDRATE" value="57600" />
-					<Variable name="UPLOAD_PORT" value="" />
-				</Environment>
-			</Target>
-			<Target title="Arduino Pro Mini (168)">
-				<Option output="bin/Release/Repetier_${BOARD_ID}_${UPLOAD_PORT}.elf" prefix_auto="1" extension_auto="0" />
-				<Option type="1" />
-				<Option compiler="avrgcc" />
-				<Compiler>
-					<Add option="-mmcu=$(MCU)" />
-					<Add option="-DF_CPU=16000000L" />
-					<Add option="-D__AVR_ATmega168__" />
-					<Add option="-Os" />
-					<Add directory="$(ARDUINO_DIR)/hardware/arduino/cores/arduino" />
-					<Add directory="$(ARDUINO_DIR)/libraries" />
-					<Add directory="$(ARDUINO_DIR)/hardware/arduino/variants/standard" />
-				</Compiler>
-				<Linker>
-					<Add option="-mmcu=$(MCU)" />
-					<Add option="-Wl,-Map=$(TARGET_OUTPUT_FILE).map,--cref" />
-				</Linker>
-				<ExtraCommands>
-					<Add after="avr-objcopy -O ihex -R .eeprom -R .eesafe $(TARGET_OUTPUT_FILE) $(TARGET_OUTPUT_FILE).hex" />
-					<Add after="avr-objcopy --no-change-warnings -j .eeprom --change-section-lma .eeprom=0 -O ihex $(TARGET_OUTPUT_FILE) $(TARGET_OUTPUT_FILE).eep.hex" />
-					<Add after="avr-size --mcu=$(MCU) --format=avr $(TARGET_OUTPUT_FILE)" />
-					<Add after='cmd /c &quot;avr-objdump -h -S $(TARGET_OUTPUT_FILE) &gt; $(TARGET_OUTPUT_FILE).lss&quot;' />
-				</ExtraCommands>
-				<Environment>
-					<Variable name="BOARD" value="Arduino Pro Mini (168)" />
-					<Variable name="BOARD_ID" value="promini168" />
-					<Variable name="MCU" value="atmega168" />
-					<Variable name="UPLOAD_BAUDRATE" value="19200" />
-					<Variable name="UPLOAD_PORT" value="" />
-				</Environment>
-			</Target>
-			<Target title="Arduino Mega 2560/ADK">
-				<Option output="bin/Release/Repetier_${BOARD_ID}_${UPLOAD_PORT}.elf" prefix_auto="1" extension_auto="0" />
-				<Option type="1" />
-				<Option compiler="avrgcc" />
-				<Compiler>
-					<Add option="-Os" />
-					<Add option="-W" />
-					<Add option="-Wall" />
-					<Add option="-mmcu=$(MCU)" />
-					<Add option="-DF_CPU=16000000L" />
-					<Add option="-D__AVR_ATmega2560__" />
-					<Add directory="$(ARDUINO_DIR)/hardware/arduino/cores/arduino" />
-					<Add directory="$(ARDUINO_DIR)/libraries" />
-					<Add directory="$(ARDUINO_DIR)/hardware/arduino/variants/mega" />
-					<Add directory="$(ARDUINO_DIR)/libraries/U8glib" />
-				</Compiler>
-				<Linker>
-					<Add option="-mmcu=$(MCU)" />
-					<Add option="-Wl,-Map=$(TARGET_OUTPUT_FILE).map,--cref" />
-				</Linker>
-				<ExtraCommands>
-					<Add after="avr-objcopy -O ihex -R .eeprom -R .eesafe $(TARGET_OUTPUT_FILE) $(TARGET_OUTPUT_FILE).hex" />
-					<Add after="avr-objcopy --no-change-warnings -j .eeprom --change-section-lma .eeprom=0 -O ihex $(TARGET_OUTPUT_FILE) $(TARGET_OUTPUT_FILE).eep.hex" />
-					<Add after="avr-size --mcu=$(MCU) --format=avr $(TARGET_OUTPUT_FILE)" />
-					<Add after='cmd /c &quot;avr-objdump -h -S $(TARGET_OUTPUT_FILE) &gt; $(TARGET_OUTPUT_FILE).lss&quot;' />
-				</ExtraCommands>
-				<Environment>
-					<Variable name="BOARD" value="Arduino Mega 2560\ADK" />
-					<Variable name="BOARD_ID" value="mega2560" />
-					<Variable name="MCU" value="atmega2560" />
-					<Variable name="UPLOAD_BAUDRATE" value="57600" />
-					<Variable name="UPLOAD_PORT" value="" />
-				</Environment>
-			</Target>
-			<Target title="Arduino Mega 1280">
-				<Option output="bin/Release/Repetier_${BOARD_ID}_${UPLOAD_PORT}.elf" prefix_auto="1" extension_auto="0" />
-				<Option type="1" />
-				<Option compiler="avrgcc" />
-				<Compiler>
-					<Add option="-mmcu=$(MCU)" />
-					<Add option="-DF_CPU=16000000L" />
-					<Add option="-D__AVR_ATmega1280__" />
-					<Add option="-O2" />
-					<Add directory="$(ARDUINO_DIR)/hardware/arduino/cores/arduino" />
-					<Add directory="$(ARDUINO_DIR)/libraries" />
-					<Add directory="$(ARDUINO_DIR)/hardware/arduino/variants/mega" />
-				</Compiler>
-				<Linker>
-					<Add option="-mmcu=$(MCU)" />
-					<Add option="-Wl,-Map=$(TARGET_OUTPUT_FILE).map,--cref" />
-				</Linker>
-				<ExtraCommands>
-					<Add after="avr-objcopy -O ihex -R .eeprom -R .eesafe $(TARGET_OUTPUT_FILE) $(TARGET_OUTPUT_FILE).hex" />
-					<Add after="avr-objcopy --no-change-warnings -j .eeprom --change-section-lma .eeprom=0 -O ihex $(TARGET_OUTPUT_FILE) $(TARGET_OUTPUT_FILE).eep.hex" />
-					<Add after="avr-size --mcu=$(MCU) --format=avr $(TARGET_OUTPUT_FILE)" />
-					<Add after='cmd /c &quot;avr-objdump -h -S $(TARGET_OUTPUT_FILE) &gt; $(TARGET_OUTPUT_FILE).lss&quot;' />
-				</ExtraCommands>
-				<Environment>
-					<Variable name="BOARD" value="Arduino Mega 1280" />
-					<Variable name="BOARD_ID" value="mega1280" />
-					<Variable name="MCU" value="atmega1280" />
-					<Variable name="UPLOAD_BAUDRATE" value="57600" />
-					<Variable name="UPLOAD_PORT" value="" />
-				</Environment>
-			</Target>
-			<Target title="Arduino Mega 8">
-				<Option output="bin/Release/Repetier_${BOARD_ID}_${UPLOAD_PORT}.elf" prefix_auto="1" extension_auto="0" />
-				<Option type="1" />
-				<Option compiler="avrgcc" />
-				<Compiler>
-					<Add option="-mmcu=$(MCU)" />
-					<Add option="-DF_CPU=16000000L" />
-					<Add option="-D__AVR_ATmega328P__" />
-					<Add option="-Os" />
-					<Add directory="$(ARDUINO_DIR)/hardware/arduino/cores/arduino" />
-					<Add directory="$(ARDUINO_DIR)/libraries" />
-					<Add directory="$(ARDUINO_DIR)/hardware/arduino/variants/standard" />
-				</Compiler>
-				<Linker>
-					<Add option="-mmcu=$(MCU)" />
-					<Add option="-Wl,-Map=$(TARGET_OUTPUT_FILE).map,--cref" />
-				</Linker>
-				<ExtraCommands>
-					<Add after="avr-objcopy -O ihex -R .eeprom -R .eesafe $(TARGET_OUTPUT_FILE) $(TARGET_OUTPUT_FILE).hex" />
-					<Add after="avr-objcopy --no-change-warnings -j .eeprom --change-section-lma .eeprom=0 -O ihex $(TARGET_OUTPUT_FILE) $(TARGET_OUTPUT_FILE).eep.hex" />
-					<Add after="avr-size --mcu=$(MCU) --format=avr $(TARGET_OUTPUT_FILE)" />
-					<Add after='cmd /c &quot;avr-objdump -h -S $(TARGET_OUTPUT_FILE) &gt; $(TARGET_OUTPUT_FILE).lss&quot;' />
-				</ExtraCommands>
-				<Environment>
-					<Variable name="BOARD" value="Arduino Mega 8" />
-					<Variable name="BOARD_ID" value="mega8" />
-					<Variable name="MCU" value="atmega8" />
-					<Variable name="UPLOAD_BAUDRATE" value="19200" />
-					<Variable name="UPLOAD_PORT" value="" />
-				</Environment>
-			</Target>
-			<Target title="Microduino Core+">
-				<Option output="bin/Release/Repetier_${BOARD_ID}_${UPLOAD_PORT}.elf" prefix_auto="1" extension_auto="0" />
-				<Option type="1" />
-				<Option compiler="avrgcc" />
-				<Compiler>
-					<Add option="-mmcu=$(MCU)" />
-					<Add option="-DF_CPU=16000000L" />
-					<Add option="-D__AVR_ATmega328P__" />
-					<Add option="-Os" />
-					<Add directory="$(ARDUINO_DIR)/hardware/arduino/cores/arduino" />
-					<Add directory="$(ARDUINO_DIR)/libraries" />
-					<Add directory="$(ARDUINO_DIR)/hardware/arduino/variants/plus" />
-				</Compiler>
-				<Linker>
-					<Add option="-mmcu=$(MCU)" />
-					<Add option="-Wl,-Map=$(TARGET_OUTPUT_FILE).map,--cref" />
-				</Linker>
-				<ExtraCommands>
-					<Add after="avr-objcopy -O ihex -R .eeprom -R .eesafe $(TARGET_OUTPUT_FILE) $(TARGET_OUTPUT_FILE).hex" />
-					<Add after="avr-objcopy --no-change-warnings -j .eeprom --change-section-lma .eeprom=0 -O ihex $(TARGET_OUTPUT_FILE) $(TARGET_OUTPUT_FILE).eep.hex" />
-					<Add after="avr-size --mcu=$(MCU) --format=avr $(TARGET_OUTPUT_FILE)" />
-					<Add after='cmd /c &quot;avr-objdump -h -S $(TARGET_OUTPUT_FILE) &gt; $(TARGET_OUTPUT_FILE).lss&quot;' />
-				</ExtraCommands>
-				<Environment>
-					<Variable name="BOARD" value="Microduino Core+" />
-					<Variable name="BOARD_ID" value="uduino644p" />
-					<Variable name="MCU" value="atmega644p" />
-					<Variable name="UPLOAD_BAUDRATE" value="115200" />
-					<Variable name="UPLOAD_PORT" value="" />
-				</Environment>
-			</Target>
-		</Build>
-		<Compiler>
-			<Add option="-w" />
-			<Add directory="." />
-		</Compiler>
-		<Unit filename="Commands.cpp">
-			<Option target="Simulator - Debug" />
-			<Option target="Simulator - Release" />
-			<Option target="Arduino Leonardo" />
-			<Option target="Arduino Esplora" />
-			<Option target="Arduino Mega 2560/ADK" />
-			<Option target="Arduino Mega 1280" />
-			<Option target="Arduino Mega 8" />
-		</Unit>
-		<Unit filename="Commands.h" />
-		<Unit filename="Communication.cpp" />
-		<Unit filename="Communication.h" />
-		<Unit filename="Configuration.h">
-			<Option target="Simulator - Debug" />
-			<Option target="Simulator - Release" />
-			<Option target="Arduino Leonardo" />
-			<Option target="Arduino Esplora" />
-			<Option target="Arduino Mega 2560/ADK" />
-			<Option target="Arduino Mega 1280" />
-			<Option target="Arduino Mega 8" />
-		</Unit>
-		<Unit filename="Eeprom.cpp">
-			<Option target="Simulator - Debug" />
-			<Option target="Simulator - Release" />
-			<Option target="Arduino Leonardo" />
-			<Option target="Arduino Esplora" />
-			<Option target="Arduino Mega 2560/ADK" />
-			<Option target="Arduino Mega 1280" />
-			<Option target="Arduino Mega 8" />
-		</Unit>
-		<Unit filename="Eeprom.h">
-			<Option target="Simulator - Debug" />
-			<Option target="Simulator - Release" />
-			<Option target="Arduino Leonardo" />
-			<Option target="Arduino Esplora" />
-			<Option target="Arduino Mega 2560/ADK" />
-			<Option target="Arduino Mega 1280" />
-			<Option target="Arduino Mega 8" />
-		</Unit>
-		<Unit filename="Extruder.cpp">
-			<Option target="Simulator - Debug" />
-			<Option target="Simulator - Release" />
-			<Option target="Arduino Leonardo" />
-			<Option target="Arduino Esplora" />
-			<Option target="Arduino Mega 2560/ADK" />
-			<Option target="Arduino Mega 1280" />
-			<Option target="Arduino Mega 8" />
-		</Unit>
-		<Unit filename="Extruder.h" />
-		<Unit filename="FatStructs.h">
-			<Option target="Simulator - Debug" />
-			<Option target="Simulator - Release" />
-			<Option target="Arduino Leonardo" />
-			<Option target="Arduino Esplora" />
-			<Option target="Arduino Mega 2560/ADK" />
-			<Option target="Arduino Mega 1280" />
-			<Option target="Arduino Mega 8" />
-		</Unit>
-		<Unit filename="HAL.cpp" />
-		<Unit filename="HAL.h" />
-		<Unit filename="Printer.cpp" />
-		<Unit filename="Printer.h" />
-		<Unit filename="Repetier.h">
-			<Option target="Simulator - Debug" />
-			<Option target="Simulator - Release" />
-			<Option target="Arduino Leonardo" />
-			<Option target="Arduino Esplora" />
-			<Option target="Arduino Mega 2560/ADK" />
-			<Option target="Arduino Mega 1280" />
-			<Option target="Arduino Mega 8" />
-		</Unit>
-		<Unit filename="Repetier.ino">
-			<Option compile="1" />
-			<Option link="1" />
-			<Option compiler="avrgcc" use="1" buildCommand="$compiler $options -x c++ $includes -c $file -o $object" />
-			<Option target="Simulator - Debug" />
-			<Option target="Simulator - Release" />
-			<Option target="Arduino Leonardo" />
-			<Option target="Arduino Esplora" />
-			<Option target="Arduino Mega 2560/ADK" />
-			<Option target="Arduino Mega 1280" />
-			<Option target="Arduino Mega 8" />
-		</Unit>
-		<Unit filename="SDCard.cpp">
-			<Option target="Simulator - Debug" />
-			<Option target="Simulator - Release" />
-			<Option target="Arduino Leonardo" />
-			<Option target="Arduino Esplora" />
-			<Option target="Arduino Mega 2560/ADK" />
-			<Option target="Arduino Mega 1280" />
-			<Option target="Arduino Mega 8" />
-		</Unit>
-		<Unit filename="SdFat.cpp">
-			<Option target="Simulator - Debug" />
-			<Option target="Simulator - Release" />
-			<Option target="Arduino Leonardo" />
-			<Option target="Arduino Esplora" />
-			<Option target="Arduino Mega 2560/ADK" />
-			<Option target="Arduino Mega 1280" />
-			<Option target="Arduino Mega 8" />
-		</Unit>
-		<Unit filename="SdFat.h">
-			<Option target="Simulator - Debug" />
-			<Option target="Simulator - Release" />
-			<Option target="Arduino Leonardo" />
-			<Option target="Arduino Esplora" />
-			<Option target="Arduino Mega 2560/ADK" />
-			<Option target="Arduino Mega 1280" />
-			<Option target="Arduino Mega 8" />
-		</Unit>
-		<Unit filename="cores/CDC.cpp" />
-		<Unit filename="cores/IPAddress.cpp">
-			<Option compile="0" />
-			<Option link="0" />
-		</Unit>
-		<Unit filename="cores/Print.cpp" />
-		<Unit filename="cores/Stream.cpp" />
-		<Unit filename="cores/Tone.cpp" />
-		<Unit filename="cores/USBCore.cpp" />
-		<Unit filename="cores/WInterrupts.c">
-			<Option compilerVar="CC" />
-		</Unit>
-		<Unit filename="cores/WMath.cpp" />
-		<Unit filename="cores/WString.cpp" />
-		<Unit filename="cores/main.cpp" />
-		<Unit filename="cores/new.cpp" />
-		<Unit filename="cores/wiring.c">
-			<Option compilerVar="CC" />
-		</Unit>
-		<Unit filename="cores/wiring_analog.c">
-			<Option compilerVar="CC" />
-		</Unit>
-		<Unit filename="cores/wiring_digital.c">
-			<Option compilerVar="CC" />
-		</Unit>
-		<Unit filename="cores/wiring_pulse.c">
-			<Option compilerVar="CC" />
-		</Unit>
-		<Unit filename="cores/wiring_shift.c">
-			<Option compilerVar="CC" />
-		</Unit>
-		<Unit filename="fastio.h">
-			<Option target="Simulator - Debug" />
-			<Option target="Simulator - Release" />
-			<Option target="Arduino Leonardo" />
-			<Option target="Arduino Esplora" />
-			<Option target="Arduino Mega 2560/ADK" />
-			<Option target="Arduino Mega 1280" />
-			<Option target="Arduino Mega 8" />
-		</Unit>
-		<Unit filename="gcode.cpp">
-			<Option target="Simulator - Debug" />
-			<Option target="Simulator - Release" />
-			<Option target="Arduino Leonardo" />
-			<Option target="Arduino Esplora" />
-			<Option target="Arduino Mega 2560/ADK" />
-			<Option target="Arduino Mega 1280" />
-			<Option target="Arduino Mega 8" />
-		</Unit>
-		<Unit filename="gcode.h">
-			<Option target="Simulator - Debug" />
-			<Option target="Simulator - Release" />
-			<Option target="Arduino Leonardo" />
-			<Option target="Arduino Esplora" />
-			<Option target="Arduino Mega 2560/ADK" />
-			<Option target="Arduino Mega 1280" />
-			<Option target="Arduino Mega 8" />
-		</Unit>
-		<Unit filename="libraries/EEPROM.cpp">
-			<Option compile="0" />
-			<Option link="0" />
-		</Unit>
-		<Unit filename="libraries/Ethernet.cpp">
-			<Option compile="0" />
-			<Option link="0" />
-		</Unit>
-		<Unit filename="libraries/Firmata.cpp">
-			<Option compile="0" />
-			<Option link="0" />
-		</Unit>
-		<Unit filename="libraries/LiquidCrystal.cpp">
-			<Option compile="0" />
-			<Option link="0" />
-		</Unit>
-		<Unit filename="libraries/MultiLCD.cpp">
-			<Option compile="0" />
-			<Option link="0" />
-			<Option target="Arduino Uno" />
-			<Option target="Arduino Leonardo" />
-			<Option target="Arduino Esplora" />
-			<Option target="Arduino Micro" />
-			<Option target="Arduino Duemilanove (328)" />
-			<Option target="Arduino Duemilanove (168)" />
-			<Option target="Arduino Nano (328)" />
-			<Option target="Arduino Nano (168)" />
-			<Option target="Arduino Mini (328)" />
-			<Option target="Arduino Mini (168)" />
-			<Option target="Arduino Pro Mini (328)" />
-			<Option target="Arduino Pro Mini (168)" />
-			<Option target="Arduino Mega 2560/ADK" />
-			<Option target="Arduino Mega 1280" />
-			<Option target="Arduino Mega 8" />
-			<Option target="Microduino Core+" />
-		</Unit>
-		<Unit filename="libraries/OBD.cpp">
-			<Option compile="0" />
-			<Option link="0" />
-		</Unit>
-		<Unit filename="libraries/SD.cpp">
-			<Option compile="0" />
-			<Option link="0" />
-		</Unit>
-		<Unit filename="libraries/SPI.cpp">
-			<Option compile="0" />
-			<Option link="0" />
-		</Unit>
-		<Unit filename="libraries/Servo.cpp">
-			<Option compile="0" />
-			<Option link="0" />
-		</Unit>
-		<Unit filename="libraries/Stepper.cpp">
-			<Option compile="0" />
-			<Option link="0" />
-		</Unit>
-		<Unit filename="libraries/TinyGPS.cpp">
-			<Option compile="0" />
-			<Option link="0" />
-		</Unit>
-		<Unit filename="libraries/U8gui.h">
-			<Option virtualFolder="libraries/" />
-			<Option target="&lt;{~None~}&gt;" />
-		</Unit>
-		<Unit filename="libraries/WiFi.cpp">
-			<Option compile="0" />
-			<Option link="0" />
-		</Unit>
-		<Unit filename="libraries/Wire.cpp">
-			<Option compile="0" />
-			<Option link="0" />
-		</Unit>
-		<Unit filename="libraries/twi.c">
-			<Option compilerVar="CC" />
-			<Option compile="0" />
-			<Option link="0" />
-		</Unit>
-		<Unit filename="motion.cpp">
-			<Option target="Simulator - Debug" />
-			<Option target="Simulator - Release" />
-			<Option target="Arduino Leonardo" />
-			<Option target="Arduino Esplora" />
-			<Option target="Arduino Mega 2560/ADK" />
-			<Option target="Arduino Mega 1280" />
-			<Option target="Arduino Mega 8" />
-		</Unit>
-		<Unit filename="motion.h">
-			<Option target="&lt;{~None~}&gt;" />
-		</Unit>
-		<Unit filename="pins.h">
-			<Option target="Simulator - Debug" />
-			<Option target="Simulator - Release" />
-			<Option target="Arduino Leonardo" />
-			<Option target="Arduino Esplora" />
-			<Option target="Arduino Mega 2560/ADK" />
-			<Option target="Arduino Mega 1280" />
-			<Option target="Arduino Mega 8" />
-		</Unit>
-		<Unit filename="u8glib_ex.h" />
-		<Unit filename="ui.cpp">
-			<Option target="Simulator - Debug" />
-			<Option target="Simulator - Release" />
-			<Option target="Arduino Leonardo" />
-			<Option target="Arduino Esplora" />
-			<Option target="Arduino Mega 2560/ADK" />
-			<Option target="Arduino Mega 1280" />
-			<Option target="Arduino Mega 8" />
-		</Unit>
-		<Unit filename="ui.h">
-			<Option target="Simulator - Debug" />
-			<Option target="Simulator - Release" />
-			<Option target="Arduino Leonardo" />
-			<Option target="Arduino Esplora" />
-			<Option target="Arduino Mega 2560/ADK" />
-			<Option target="Arduino Mega 1280" />
-			<Option target="Arduino Mega 8" />
-		</Unit>
-		<Unit filename="uiconfig.h">
-			<Option target="Simulator - Debug" />
-			<Option target="Simulator - Release" />
-			<Option target="Arduino Leonardo" />
-			<Option target="Arduino Esplora" />
-			<Option target="Arduino Mega 2560/ADK" />
-			<Option target="Arduino Mega 1280" />
-			<Option target="Arduino Mega 8" />
-		</Unit>
-		<Unit filename="uilang.h">
-			<Option target="Simulator - Debug" />
-			<Option target="Simulator - Release" />
-			<Option target="Arduino Leonardo" />
-			<Option target="Arduino Esplora" />
-			<Option target="Arduino Mega 2560/ADK" />
-			<Option target="Arduino Mega 1280" />
-			<Option target="Arduino Mega 8" />
-		</Unit>
-		<Unit filename="uimenu.h">
-			<Option target="Simulator - Debug" />
-			<Option target="Simulator - Release" />
-			<Option target="Arduino Leonardo" />
-			<Option target="Arduino Esplora" />
-			<Option target="Arduino Mega 2560/ADK" />
-			<Option target="Arduino Mega 1280" />
-			<Option target="Arduino Mega 8" />
-		</Unit>
-		<Extensions>
-			<code_completion />
-			<debugger />
-		</Extensions>
-	</Project>
-</CodeBlocks_project_file>

Repetier/Repetier.h

@@ -23,15 +23,16 @@
 #define _REPETIER_H
 
 #include <math.h>
-
+#include <stdint.h>
-#define REPETIER_VERSION "0.92.3"
+#define REPETIER_VERSION "0.92.8"
 
 // ##########################################################################################
 // ##                                  Debug configuration                                 ##
 // ##########################################################################################
 // These are run time sqitchable debug flags
 enum debugFlags {DEB_ECHO = 0x1, DEB_INFO = 0x2, DEB_ERROR = 0x4,DEB_DRYRUN = 0x8,
-                 DEB_COMMUNICATION = 0x10, DEB_NOMOVES = 0x20, DEB_DEBUG = 0x40};
+                 DEB_COMMUNICATION = 0x10, DEB_NOMOVES = 0x20, DEB_DEBUG = 0x40
+                };
 
 /** Uncomment, to see detailed data for every move. Only for debugging purposes! */
 //#define DEBUG_QUEUE_MOVE
@@ -62,6 +63,8 @@ usage or for seraching for memory induced errors. Switch it off for production,
 //#define DEBUG_SEGMENT_LENGTH
 // Find the maximum real jerk during a print
 //#define DEBUG_REAL_JERK
+// Debug reason for not mounting a sd card
+//#define DEBUG_SD_ERROR
 // Uncomment the following line to enable debugging. You can better control debugging below the following line
 //#define DEBUG
 
@@ -150,6 +153,8 @@ usage or for seraching for memory induced errors. Switch it off for production,
 #define CONTROLLER_SPARKLCD 19
 #define CONTROLLER_BAM_DICE_DUE 20
 #define CONTROLLER_VIKI2 21
+#define CONTROLLER_LCD_MP_PHARAOH_DUE 22
+#define CONTROLLER_SPARKLCD_ADAPTER 23
 #define CONTROLLER_FELIX_DUE 405
 
 //direction flags
@@ -175,8 +180,26 @@ usage or for seraching for memory induced errors. Switch it off for production,
 // add pid control
 #define TEMP_PID 1
 
+#define PRINTER_MODE_FFF 0
+#define PRINTER_MODE_LASER 1
+#define PRINTER_MODE_CNC 2
+// we can not prevent this as some configs need a parameter and others not
+#pragma GCC diagnostic ignored "-Wunused-parameter"
+#pragma GCC diagnostic ignored "-Wunused-variable"
+
 #include "Configuration.h"
 
+inline void memcopy2(void *dest,void *source) {
+	*((int16_t*)dest) = *((int16_t*)source);
+}
+inline void memcopy4(void *dest,void *source) {
+	*((int32_t*)dest) = *((int32_t*)source);
+}
+
+#ifndef JSON_OUTPUT
+#define JSON_OUTPUT 0
+#endif
+
 #if FEATURE_Z_PROBE && Z_PROBE_PIN < 0
 #error You need to define Z_PROBE_PIN to use z probe!
 #endif
@@ -230,10 +253,12 @@ usage or for seraching for memory induced errors. Switch it off for production,
 #define SPEED_MAX_MILLIS 60
 #define SPEED_MAGNIFICATION 100.0f
 
-#define SOFTWARE_LEVELING (FEATURE_SOFTWARE_LEVELING && (DRIVE_SYSTEM==DELTA))
+#define SOFTWARE_LEVELING (defined(FEATURE_SOFTWARE_LEVELING) && (DRIVE_SYSTEM==DELTA))
 /**  \brief Horizontal distance bridged by the diagonal push rod when the end effector is in the center. It is pretty close to 50% of the push rod length (250 mm).
 */
+#ifndef ROD_RADIUS
 #define ROD_RADIUS (PRINTER_RADIUS-END_EFFECTOR_HORIZONTAL_OFFSET-CARRIAGE_HORIZONTAL_OFFSET)
+#endif
 
 #ifndef UI_SPEEDDEPENDENT_POSITIONING
 #define UI_SPEEDDEPENDENT_POSITIONING true
@@ -276,6 +301,18 @@ usage or for seraching for memory induced errors. Switch it off for production,
 #define SHARED_COOLER 0
 #endif
 
+#ifndef START_STEP_WITH_HIGH
+#define START_STEP_WITH_HIGH 1
+#endif
+
+#if NUM_EXTRUDER > 0 && EXT0_TEMPSENSOR_TYPE == 101
+#define SUPPORT_MAX6675
+#endif
+
+#if NUM_EXTRUDER > 0 && EXT0_TEMPSENSOR_TYPE == 102
+#define SUPPORT_MAX31855
+#endif
+
 // Test for shared coolers between extruders and mainboard
 #if EXT0_EXTRUDER_COOLER_PIN > -1 && EXT0_EXTRUDER_COOLER_PIN == FAN_BOARD_PIN
 #define SHARED_COOLER_BOARD_EXT 1
@@ -293,6 +330,9 @@ usage or for seraching for memory induced errors. Switch it off for production,
 #else
 #define EXTRUDER_JAM_CONTROL 0
 #endif
+#ifndef JAM_METHOD
+#define JAM_METHOD 1
+#endif
 
 #if NUM_EXTRUDER > 0 && EXT0_TEMPSENSOR_TYPE < 101
 #define EXT0_ANALOG_INPUTS 1
@@ -370,12 +410,22 @@ usage or for seraching for memory induced errors. Switch it off for production,
 #define BED_ANALOG_INPUTS 1
 #define BED_SENSOR_INDEX EXT0_ANALOG_INPUTS+EXT1_ANALOG_INPUTS+EXT2_ANALOG_INPUTS+EXT3_ANALOG_INPUTS+EXT4_ANALOG_INPUTS+EXT5_ANALOG_INPUTS
 #define BED_ANALOG_CHANNEL ACCOMMA5 HEATED_BED_SENSOR_PIN
-#undef KOMMA
+#undef BEKOMMA
-#define KOMMA ,
+#define BED_KOMMA ,
 #else
 #define BED_ANALOG_INPUTS 0
 #define BED_SENSOR_INDEX HEATED_BED_SENSOR_PIN
 #define BED_ANALOG_CHANNEL
+#define BED_KOMMA ACCOMMA5
+#endif
+
+#if FAN_THERMO_THERMISTOR_PIN > -1 && FAN_THERMO_PIN > -1
+#define THERMO_ANALOG_INPUTS 1
+#define THERMO_ANALOG_INDEX EXT0_ANALOG_INPUTS+EXT1_ANALOG_INPUTS+EXT2_ANALOG_INPUTS+EXT3_ANALOG_INPUTS+EXT4_ANALOG_INPUTS+EXT5_ANALOG_INPUTS+BED_ANALOG_INPUTS
+#define THERMO_ANALOG_CHANNEL BED_KOMMA FAN_THERMO_THERMISTOR_PIN
+#else
+#define THERMO_ANALOG_INPUTS 0
+#define THERMO_ANALOG_CHANNEL
 #endif
 
 #ifndef DEBUG_FREE_MEMORY
@@ -385,10 +435,10 @@ usage or for seraching for memory induced errors. Switch it off for production,
 #endif
 
 /** \brief number of analog input signals. Normally 1 for each temperature sensor */
-#define ANALOG_INPUTS (EXT0_ANALOG_INPUTS+EXT1_ANALOG_INPUTS+EXT2_ANALOG_INPUTS+EXT3_ANALOG_INPUTS+EXT4_ANALOG_INPUTS+EXT5_ANALOG_INPUTS+BED_ANALOG_INPUTS)
+#define ANALOG_INPUTS (EXT0_ANALOG_INPUTS+EXT1_ANALOG_INPUTS+EXT2_ANALOG_INPUTS+EXT3_ANALOG_INPUTS+EXT4_ANALOG_INPUTS+EXT5_ANALOG_INPUTS+BED_ANALOG_INPUTS+THERMO_ANALOG_INPUTS)
 #if ANALOG_INPUTS > 0
 /** Channels are the MUX-part of ADMUX register */
-#define  ANALOG_INPUT_CHANNELS {EXT0_ANALOG_CHANNEL EXT1_ANALOG_CHANNEL EXT2_ANALOG_CHANNEL EXT3_ANALOG_CHANNEL EXT4_ANALOG_CHANNEL EXT5_ANALOG_CHANNEL BED_ANALOG_CHANNEL}
+#define  ANALOG_INPUT_CHANNELS {EXT0_ANALOG_CHANNEL EXT1_ANALOG_CHANNEL EXT2_ANALOG_CHANNEL EXT3_ANALOG_CHANNEL EXT4_ANALOG_CHANNEL EXT5_ANALOG_CHANNEL BED_ANALOG_CHANNEL THERMO_ANALOG_CHANNEL}
 #endif
 
 #define MENU_MODE_SD_MOUNTED 1
@@ -399,6 +449,22 @@ usage or for seraching for memory induced errors. Switch it off for production,
 #define MENU_MODE_FULL_PID 32
 #define MENU_MODE_DEADTIME 64
 
+#ifndef BENDING_CORRECTION_A
+#define BENDING_CORRECTION_A 0
+#endif
+
+#ifndef BENDING_CORRECTION_B
+#define BENDING_CORRECTION_B 0
+#endif
+
+#ifndef BENDING_CORRECTION_C
+#define BENDING_CORRECTION_C 0
+#endif
+
+#ifndef Z_ACCELERATION_TOP
+#define Z_ACCELERATION_TOP 0
+#endif
+
 #include "HAL.h"
 #include "gcode.h"
 #define MAX_VFAT_ENTRIES (2)
@@ -412,7 +478,7 @@ usage or for seraching for memory induced errors. Switch it off for production,
 
 #if UI_DISPLAY_TYPE != DISPLAY_U8G
 #if (defined(USER_KEY1_PIN) && (USER_KEY1_PIN==UI_DISPLAY_D5_PIN || USER_KEY1_PIN==UI_DISPLAY_D6_PIN || USER_KEY1_PIN==UI_DISPLAY_D7_PIN)) || (defined(USER_KEY2_PIN) && (USER_KEY2_PIN==UI_DISPLAY_D5_PIN || USER_KEY2_PIN==UI_DISPLAY_D6_PIN || USER_KEY2_PIN==UI_DISPLAY_D7_PIN)) || (defined(USER_KEY3_PIN) && (USER_KEY3_PIN==UI_DISPLAY_D5_PIN || USER_KEY3_PIN==UI_DISPLAY_D6_PIN || USER_KEY3_PIN==UI_DISPLAY_D7_PIN)) || (defined(USER_KEY4_PIN) && (USER_KEY4_PIN==UI_DISPLAY_D5_PIN || USER_KEY4_PIN==UI_DISPLAY_D6_PIN || USER_KEY4_PIN==UI_DISPLAY_D7_PIN))
-    #error "You cannot use DISPLAY_D5_PIN, DISPLAY_D6_PIN or DISPLAY_D7_PIN for "User Keys" with character LCD display"
+#error You cannot use DISPLAY_D5_PIN, DISPLAY_D6_PIN or DISPLAY_D7_PIN for "User Keys" with character LCD display
 #endif
 #endif
 
@@ -442,65 +508,271 @@ usage or for seraching for memory induced errors. Switch it off for production,
 #undef min
 #undef max
 
-class RMath {
+class RMath
+{
 public:
-    static inline float min(float a,float b) {
+    static inline float min(float a,float b)
+    {
         if(a < b) return a;
         return b;
     }
-    static inline float max(float a,float b) {
+    static inline float max(float a,float b)
+    {
         if(a < b) return b;
         return a;
     }
-    static inline int32_t min(int32_t a,int32_t b) {
+    static inline int32_t min(int32_t a,int32_t b)
+    {
         if(a < b) return a;
         return b;
     }
-    static inline int32_t min(int32_t a,int32_t b, int32_t c) {
+    static inline int32_t min(int32_t a,int32_t b, int32_t c)
+    {
         if(a < b) return a < c ? a : c;
         return b<c ? b : c;
     }
-    static inline float min(float a,float b, float c) {
+    static inline float min(float a,float b, float c)
+    {
         if(a < b) return a < c ? a : c;
         return b < c ? b : c;
     }
-    static inline int32_t max(int32_t a,int32_t b) {
+    static inline int32_t max(int32_t a,int32_t b)
+    {
         if(a < b) return b;
         return a;
     }
-    static inline int min(int a,int b) {
+    static inline int min(int a,int b)
+    {
         if(a < b) return a;
         return b;
     }
-    static inline uint16_t min(uint16_t a,uint16_t b) {
+    static inline uint16_t min(uint16_t a,uint16_t b)
+    {
         if(a < b) return a;
         return b;
     }
-    static inline int16_t max(int16_t a,int16_t b) {
+    static inline int16_t max(int16_t a,int16_t b)
+    {
         if(a < b) return b;
         return a;
     }
-    static inline uint16_t max(uint16_t a,uint16_t b) {
+    static inline uint16_t max(uint16_t a,uint16_t b)
+    {
         if(a < b) return b;
         return a;
     }
-    static inline unsigned long absLong(long a)          {return a >= 0 ? a : -a;}
+    static inline unsigned long absLong(long a)
-    static inline int32_t sqr(int32_t a) {return a*a;}
+    {
-    static inline uint32_t sqr(uint32_t a) {return a*a;}
+        return a >= 0 ? a : -a;
+    }
+    static inline int32_t sqr(int32_t a)
+    {
+        return a*a;
+    }
+    static inline uint32_t sqr(uint32_t a)
+    {
+        return a*a;
+    }
 #ifdef SUPPORT_64_BIT_MATH
-    static inline int64_t sqr(int64_t a) {return a*a;}
+    static inline int64_t sqr(int64_t a)
-    static inline uint64_t sqr(uint64_t a) {return a*a;}
+    {
+        return a*a;
+    }
+    static inline uint64_t sqr(uint64_t a)
+    {
+        return a*a;
+    }
 #endif
 
-    static inline float sqr(float a) {return a*a;}
+    static inline float sqr(float a)
+    {
+        return a*a;
+    }
 };
 
+class RVector3
+{
+public:
+    float x, y, z;
+    RVector3(float _x = 0,float _y = 0,float _z = 0):x(_x),y(_y),z(_z) {};
+    RVector3(const RVector3 &a):x(a.x),y(a.y),z(a.z) {};
+
+
+/*    const float &operator[](std::size_t idx) const
+    {
+        if(idx == 0) return x;
+        if(idx == 1) return y;
+        return z;
+    };
+
+    float &operator[](std::size_t idx)
+    {
+        switch(idx) {
+        case 0: return x;
+        case 1: return y;
+        case 2: return z;
+        }
+        return 0;
+    };*/
+
+    inline bool operator==(const RVector3 &rhs)
+    {
+        return x==rhs.x && y==rhs.y && z==rhs.z;
+    }
+    inline bool operator!=(const RVector3 &rhs)
+    {
+        return !(*this==rhs);
+    }
+    inline RVector3& operator=(const RVector3 &rhs)
+    {
+        if(this!=&rhs)
+        {
+            x = rhs.x;
+            y = rhs.y;
+            z = rhs.z;
+        }
+        return *this;
+    }
+
+    inline RVector3& operator+=(const RVector3 &rhs)
+    {
+        x += rhs.x;
+        y += rhs.y;
+        z += rhs.z;
+        return *this;
+    }
+
+    inline RVector3& operator-=(const RVector3 &rhs)
+    {
+        x -= rhs.x;
+        y -= rhs.y;
+        z -= rhs.z;
+        return *this;
+    }
+    inline RVector3 operator-() const
+    {
+        return RVector3(-x,-y,-z);
+    }
+
+    inline float length() const
+    {
+        return sqrt(x * x + y * y + z * z);
+    }
+
+    inline float lengthSquared() const
+    {
+        return (x*x+y*y+z*z);
+    }
+
+    inline RVector3 cross(const RVector3 &b) const
+    {
+        return RVector3(y*b.z-z*b.y,z*b.x-x*b.z,x*b.y-y*b.x);
+    }
+    inline float scalar(const RVector3 &b) const
+    {
+        return (x*b.x+y*b.y+z*b.z);
+    }
+    inline RVector3 scale(float factor) const
+    {
+        return RVector3(x*factor,y*factor,z*factor);
+    }
+    inline void scaleIntern(float factor)
+    {
+        x*=factor;
+        y*=factor;
+        z*=factor;
+    }
+    inline void setMinimum(const RVector3 &b)
+    {
+        x = RMath::min(x,b.x);
+        y = RMath::min(y,b.y);
+        z = RMath::min(z,b.z);
+    }
+    inline void setMaximum(const RVector3 &b)
+    {
+        x = RMath::max(x,b.x);
+        y = RMath::max(y,b.y);
+        z = RMath::max(z,b.z);
+    }
+    inline float distance(const RVector3 &b) const
+    {
+        float dx = b.x-x,dy = b.y-y, dz = b.z-z;
+        return (sqrt(dx*dx+dy*dy+dz*dz));
+    }
+    inline float angle(RVector3 &direction)
+    {
+        return static_cast<float>(acos(scalar(direction)/(length()*direction.length())));
+    }
+
+    inline RVector3 normalize() const
+    {
+        float len = length();
+        if(len != 0) len = static_cast<float>(1.0/len);
+        return RVector3(x*len,y*len,z*len);
+    }
+
+    inline RVector3 interpolatePosition(const RVector3 &b, float pos) const
+    {
+        float pos2 = 1.0f - pos;
+        return RVector3(x * pos2 + b.x * pos, y * pos2 + b.y * pos, z * pos2 + b.z * pos);
+    }
+
+    inline RVector3 interpolateDirection(const RVector3 &b,float pos) const
+    {
+        //float pos2 = 1.0f - pos;
+
+        float dot = scalar(b);
+        if (dot > 0.9995 || dot < -0.9995)
+            return interpolatePosition(b,pos); // cases cause trouble, use linear interpolation here
+
+        float theta = acos(dot) * pos; // interpolated position
+        float st = sin(theta);
+        RVector3 t(b);
+        t -= scale(dot);
+        float lengthSq = t.lengthSquared();
+        float dl = st * ((lengthSq < 0.0001f) ? 1.0f : 1.0f / sqrt(lengthSq));
+        t.scaleIntern(dl);
+        t += scale(cos(theta));
+        return t.normalize();
+    }
+};
+	inline RVector3 operator+(RVector3 lhs, const RVector3& rhs) // first arg by value, second by const ref
+	{
+		lhs.x += rhs.x;
+		lhs.y += rhs.y;
+		lhs.z += rhs.z;
+		return lhs;
+	}
+
+	inline RVector3 operator-(RVector3 lhs, const RVector3& rhs) // first arg by value, second by const ref
+	{
+		lhs.x -= rhs.x;
+		lhs.y -= rhs.y;
+		lhs.z -= rhs.z;
+		return lhs;
+	}
+
+    inline RVector3 operator*(const RVector3 &lhs,float rhs) {
+        return lhs.scale(rhs);
+    }
+
+    inline RVector3 operator*(float lhs,const RVector3 &rhs) {
+        return rhs.scale(lhs);
+    }
 extern const uint8 osAnalogInputChannels[] PROGMEM;
 //extern uint8 osAnalogInputCounter[ANALOG_INPUTS];
 //extern uint osAnalogInputBuildup[ANALOG_INPUTS];
 //extern uint8 osAnalogInputPos; // Current sampling position
+#if ANALOG_INPUTS > 0
 extern volatile uint osAnalogInputValues[ANALOG_INPUTS];
-extern uint8_t pwm_pos[NUM_EXTRUDER+3]; // 0-NUM_EXTRUDER = Heater 0-NUM_EXTRUDER of extruder, NUM_EXTRUDER = Heated bed, NUM_EXTRUDER+1 Board fan, NUM_EXTRUDER+2 = Fan
+#endif
+#define PWM_HEATED_BED NUM_EXTRUDER
+#define PWM_BOARD_FAN PWM_HEATED_BED+1
+#define PWM_FAN1 PWM_BOARD_FAN+1
+#define PWM_FAN2 PWM_FAN1+1
+#define PWM_FAN_THERMO PWM_FAN2+1
+#define NUM_PWM PWM_FAN_THERMO+1
+extern uint8_t pwm_pos[NUM_PWM]; // 0-NUM_EXTRUDER = Heater 0-NUM_EXTRUDER of extruder, NUM_EXTRUDER = Heated bed, NUM_EXTRUDER+1 Board fan, NUM_EXTRUDER+2 = Fan
 #if USE_ADVANCE
 #if ENABLE_QUADRATIC_ADVANCE
 extern int maxadv;
@@ -542,10 +814,6 @@ extern void microstepInit();
 #include "Printer.h"
 #include "motion.h"
 extern long baudrate;
-#if OS_ANALOG_INPUTS>0
-// Get last result for pin x
-extern volatile uint osAnalogInputValues[OS_ANALOG_INPUTS];
-#endif
 
 #include "HAL.h"
 
@@ -554,8 +822,12 @@ extern unsigned int counterPeriodical;
 extern volatile uint8_t executePeriodical;
 extern uint8_t counter250ms;
 extern void writeMonitor();
+#if FEATURE_FAN_CONTROL
 extern uint8_t fanKickstart;
-
+#endif
+#if FEATURE_FAN2_CONTROL
+extern uint8_t fan2Kickstart;
+#endif
 
 #if SDSUPPORT
 extern char tempLongFilename[LONG_FILENAME_LENGTH+1];
@@ -564,7 +836,8 @@ extern char fullName[LONG_FILENAME_LENGTH*SD_MAX_FOLDER_DEPTH+SD_MAX_FOLDER_DEPT
 #include "SdFat.h"
 
 enum LsAction {LS_SerialPrint,LS_Count,LS_GetFilename};
-class SDCard {
+class SDCard
+{
 public:
     SdFat fat;
     //Sd2Card card; // ~14 Byte
@@ -572,6 +845,9 @@ public:
     //SdFile root;
     //SdFile dir[SD_MAX_FOLDER_DEPTH+1];
     SdFile file;
+#if JSON_OUTPUT
+    GCodeFileInfo fileInfo;
+#endif
     uint32_t filesize;
     uint32_t sdpos;
     //char fullName[13*SD_MAX_FOLDER_DEPTH+13]; // Fill name
@@ -593,9 +869,19 @@ public:
     void pausePrint(bool intern = false);
     void continuePrint(bool intern = false);
     void stopPrint();
-  inline void setIndex(uint32_t  newpos) { if(!sdactive) return; sdpos = newpos;file.seekSet(sdpos);}
+    inline void setIndex(uint32_t  newpos)
+    {
+        if(!sdactive) return;
+        sdpos = newpos;
+        file.seekSet(sdpos);
+    }
     void printStatus();
     void ls();
+#if JSON_OUTPUT
+    void lsJSON(const char *filename);
+    void JSONFileInfo(const char *filename);
+    static void printEscapeChars(const char *s);
+#endif
     void startWrite(char *filename);
     void deleteFile(char *filename);
     void finishWrite();
@@ -652,5 +938,3 @@ extern int debugWaitLoop;
 #endif
 
 #endif
-
-

Repetier/Repetier.ino

@@ -39,7 +39,7 @@ Implemented Codes
 - G0  -> G1
 - G1  - Coordinated Movement X Y Z E, S1 disables boundary check, S0 enables it
 - G4  - Dwell S<seconds> or P<milliseconds>
-- G10 S<1 = long retract, 0 = short retract = default> retracts filament accoridng to stored setting
+- G10 S<1 = long retract, 0 = short retract = default> retracts filament according to stored setting
 - G11 S<1 = long retract, 0 = short retract = default> = Undo retraction according to stored setting
 - G20 - Units for G0/G1 are inches.
 - G21 - Units for G0/G1 are mm.
@@ -47,19 +47,21 @@ Implemented Codes
 - G29 S<0..2> - Z-Probe at the 3 defined probe points. S = 1 measure avg. zHeight, S = 2 store avg zHeight
 - G30 P<0..3> - Single z-probe at current position P = 1 first measurement, P = 2 Last measurement P = 0 or 3 first and last measurement
 - G31 - Write signal of probe sensor
-- G32 S<0..2> P<0..1> - Autolevel print bed. S = 1 measure zLength, S = 2 Measue and store new zLength
+- G32 S<0..2> P<0..1> - Autolevel print bed. S = 1 measure zLength, S = 2 Measure and store new zLength
 - G90 - Use absolute coordinates
 - G91 - Use relative coordinates
-- G92 - Set current position to cordinates given
+- G92 - Set current position to coordinates given
 - G131 - set extruder offset position to 0 - needed for calibration with G132
 - G132 - calibrate endstop positions. Call this, after calling G131 and after centering the extruder holder.
+- G133 - measure steps until max endstops for deltas. Can be used to detect lost steps within tolerances of endstops.
+- G134 Px Sx Zx - Calibrate nozzle height difference (need z probe in nozzle!) Px = reference extruder, Sx = only measure extrude x against reference, Zx = add to measured z distance for Sx for correction.
 
 RepRap M Codes
 
 - M104 - Set extruder target temp
 - M105 - Read current temp
-- M106 - Fan on
+- M106 S<speed> P<fan> - Fan on speed = 0..255, P = 0 or 1, 0 is default and can be omitted
-- M107 - Fan off
+- M107 P<fan> - Fan off, P = 0 or 1, 0 is default and can be omitted
 - M109 - Wait for extruder current temp to reach target temp.
 - M114 - Display current position
 
@@ -109,6 +111,7 @@ Custom M Codes
 - M209 S<0/1> - Enable/disable autoretraction
 - M220 S<Feedrate multiplier in percent> - Increase/decrease given feedrate
 - M221 S<Extrusion flow multiplier in percent> - Increase/decrease given flow rate
+- M228 P<pin> S<state 0/1> - Wait for pin getting state S. Add X0 to init as input without pullup and X1 for input with pullup.
 - M231 S<OPS_MODE> X<Min_Distance> Y<Retract> Z<Backlash> F<ReatrctMove> - Set OPS parameter
 - M232 - Read and reset max. advance values
 - M233 X<AdvanceK> Y<AdvanceL> - Set temporary advance K-value to X and linear term advanceL to Y
@@ -129,6 +132,11 @@ Custom M Codes
 - M400 - Wait until move buffers empty.
 - M401 - Store x, y and z position.
 - M402 - Go to stored position. If X, Y or Z is specified, only these coordinates are used. F changes feedrate fo rthat move.
+- M450 - Reports printer mode
+- M451 - Set printer mode to FFF
+- M452 - Set printer mode to laser
+- M453 - Set printer mode to CNC
+- M460 X<minTemp> Y<maxTemp> : Set temperature range for thermistor controlled fan
 - M500 Store settings to EEPROM
 - M501 Load settings from EEPROM
 - M502 Reset settings to the one in configuration.h. Does not store values in EEPROM!
@@ -163,5 +171,3 @@ void loop()
 
 
 
-
-

Repetier/Repetier.layout

@@ -1,213 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
-<CodeBlocks_layout_file>
-	<ActiveTarget name="Arduino Mega 2560/ADK" />
-	<File name="fastio.h" open="0" top="0" tabpos="25" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
-		<Cursor>
-			<Cursor1 position="2263" topLine="59" />
-		</Cursor>
-	</File>
-	<File name="gcode.cpp" open="1" top="0" tabpos="8" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
-		<Cursor>
-			<Cursor1 position="21260" topLine="603" />
-		</Cursor>
-		<Folding>
-			<Collapse line="231" />
-			<Collapse line="239" />
-		</Folding>
-	</File>
-	<File name="gcode.h" open="1" top="0" tabpos="16" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
-		<Cursor>
-			<Cursor1 position="1228" topLine="15" />
-		</Cursor>
-	</File>
-	<File name="libraries\EEPROM.cpp" open="0" top="0" tabpos="29" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
-		<Cursor>
-			<Cursor1 position="0" topLine="0" />
-		</Cursor>
-	</File>
-	<File name="libraries\Ethernet.cpp" open="0" top="0" tabpos="28" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
-		<Cursor>
-			<Cursor1 position="0" topLine="0" />
-		</Cursor>
-	</File>
-	<File name="Printer.cpp" open="1" top="0" tabpos="3" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
-		<Cursor>
-			<Cursor1 position="2659" topLine="26" />
-		</Cursor>
-		<Folding>
-			<Collapse line="179" />
-			<Collapse line="1059" />
-		</Folding>
-	</File>
-	<File name="Printer.h" open="1" top="0" tabpos="15" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
-		<Cursor>
-			<Cursor1 position="7168" topLine="126" />
-		</Cursor>
-	</File>
-	<File name="Repetier.h" open="1" top="0" tabpos="5" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
-		<Cursor>
-			<Cursor1 position="2489" topLine="27" />
-		</Cursor>
-	</File>
-	<File name="Repetier.ino" open="1" top="0" tabpos="1" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
-		<Cursor>
-			<Cursor1 position="1912" topLine="37" />
-		</Cursor>
-	</File>
-	<File name="libraries\OBD.cpp" open="0" top="0" tabpos="33" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
-		<Cursor>
-			<Cursor1 position="0" topLine="0" />
-		</Cursor>
-	</File>
-	<File name="SDCard.cpp" open="0" top="0" tabpos="10" split="0" active="1" splitpos="0" zoom_1="-1" zoom_2="0">
-		<Cursor>
-			<Cursor1 position="2466" topLine="71" />
-		</Cursor>
-	</File>
-	<File name="SdFat.cpp" open="0" top="0" tabpos="23" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
-		<Cursor>
-			<Cursor1 position="86777" topLine="3013" />
-		</Cursor>
-	</File>
-	<File name="libraries\SPI.cpp" open="0" top="0" tabpos="37" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
-		<Cursor>
-			<Cursor1 position="20" topLine="0" />
-		</Cursor>
-	</File>
-	<File name="Communication.h" open="1" top="0" tabpos="17" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
-		<Cursor>
-			<Cursor1 position="10270" topLine="346" />
-		</Cursor>
-	</File>
-	<File name="SdFat.h" open="0" top="0" tabpos="24" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
-		<Cursor>
-			<Cursor1 position="29389" topLine="772" />
-		</Cursor>
-	</File>
-	<File name="libraries\Servo.cpp" open="0" top="0" tabpos="34" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
-		<Cursor>
-			<Cursor1 position="0" topLine="0" />
-		</Cursor>
-	</File>
-	<File name="Configuration.h" open="1" top="0" tabpos="18" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
-		<Cursor>
-			<Cursor1 position="7460" topLine="217" />
-		</Cursor>
-	</File>
-	<File name="motion.cpp" open="1" top="1" tabpos="12" split="0" active="1" splitpos="0" zoom_1="-1" zoom_2="0">
-		<Cursor>
-			<Cursor1 position="26758" topLine="645" />
-		</Cursor>
-		<Folding>
-			<Collapse line="891" />
-			<Collapse line="912" />
-			<Collapse line="938" />
-			<Collapse line="1397" />
-		</Folding>
-	</File>
-	<File name="libraries\Stepper.cpp" open="0" top="0" tabpos="36" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
-		<Cursor>
-			<Cursor1 position="0" topLine="0" />
-		</Cursor>
-	</File>
-	<File name="Eeprom.cpp" open="1" top="0" tabpos="19" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
-		<Cursor>
-			<Cursor1 position="26476" topLine="616" />
-		</Cursor>
-	</File>
-	<File name="motion.h" open="1" top="0" tabpos="13" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
-		<Cursor>
-			<Cursor1 position="18497" topLine="629" />
-		</Cursor>
-	</File>
-	<File name="Eeprom.h" open="1" top="0" tabpos="4" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
-		<Cursor>
-			<Cursor1 position="0" topLine="0" />
-		</Cursor>
-	</File>
-	<File name="pins.h" open="1" top="0" tabpos="7" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
-		<Cursor>
-			<Cursor1 position="32601" topLine="1166" />
-		</Cursor>
-	</File>
-	<File name="cores\Print.cpp" open="0" top="0" tabpos="26" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
-		<Cursor>
-			<Cursor1 position="0" topLine="0" />
-		</Cursor>
-	</File>
-	<File name="Extruder.cpp" open="1" top="0" tabpos="11" split="0" active="1" splitpos="838" zoom_1="-1" zoom_2="0">
-		<Cursor>
-			<Cursor1 position="34982" topLine="885" />
-		</Cursor>
-	</File>
-	<File name="u8glib_ex.h" open="0" top="0" tabpos="11" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
-		<Cursor>
-			<Cursor1 position="11774" topLine="315" />
-		</Cursor>
-	</File>
-	<File name="cores\Stream.cpp" open="0" top="0" tabpos="27" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
-		<Cursor>
-			<Cursor1 position="0" topLine="0" />
-		</Cursor>
-	</File>
-	<File name="Extruder.h" open="0" top="0" tabpos="16" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
-		<Cursor>
-			<Cursor1 position="1209" topLine="13" />
-		</Cursor>
-	</File>
-	<File name="ui.cpp" open="1" top="0" tabpos="9" split="0" active="1" splitpos="0" zoom_1="-1" zoom_2="0">
-		<Cursor>
-			<Cursor1 position="89117" topLine="2763" />
-		</Cursor>
-	</File>
-	<File name="FatStructs.h" open="0" top="0" tabpos="24" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
-		<Cursor>
-			<Cursor1 position="952" topLine="0" />
-		</Cursor>
-	</File>
-	<File name="ui.h" open="1" top="0" tabpos="6" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
-		<Cursor>
-			<Cursor1 position="24207" topLine="12" />
-		</Cursor>
-	</File>
-	<File name="HAL.cpp" open="1" top="0" tabpos="20" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
-		<Cursor>
-			<Cursor1 position="12287" topLine="267" />
-		</Cursor>
-	</File>
-	<File name="uiconfig.h" open="0" top="0" tabpos="23" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
-		<Cursor>
-			<Cursor1 position="2235" topLine="48" />
-		</Cursor>
-	</File>
-	<File name="HAL.h" open="1" top="0" tabpos="21" split="0" active="1" splitpos="0" zoom_1="1" zoom_2="0">
-		<Cursor>
-			<Cursor1 position="7282" topLine="212" />
-		</Cursor>
-	</File>
-	<File name="uilang.h" open="0" top="0" tabpos="9" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
-		<Cursor>
-			<Cursor1 position="9398" topLine="202" />
-		</Cursor>
-	</File>
-	<File name="Commands.cpp" open="1" top="0" tabpos="2" split="0" active="1" splitpos="0" zoom_1="-2" zoom_2="0">
-		<Cursor>
-			<Cursor1 position="56856" topLine="1491" />
-		</Cursor>
-	</File>
-	<File name="uimenu.h" open="1" top="0" tabpos="10" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
-		<Cursor>
-			<Cursor1 position="13785" topLine="361" />
-		</Cursor>
-	</File>
-	<File name="Commands.h" open="0" top="0" tabpos="19" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
-		<Cursor>
-			<Cursor1 position="1295" topLine="10" />
-		</Cursor>
-	</File>
-	<File name="Communication.cpp" open="1" top="0" tabpos="14" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
-		<Cursor>
-			<Cursor1 position="19721" topLine="459" />
-		</Cursor>
-	</File>
-</CodeBlocks_layout_file>

Repetier/SDCard.cpp

@@ -41,25 +41,26 @@ void SDCard::automount()
 #if SDCARDDETECT > -1
     if(READ(SDCARDDETECT) != SDCARDDETECTINVERTED)
     {
-        if(sdactive)   // Card removed
+        if(sdactive || sdmode == 100)   // Card removed
         {
             Com::printFLN(PSTR("SD card removed"));
 #if UI_DISPLAY_TYPE != NO_DISPLAY
             uid.executeAction(UI_ACTION_TOP_MENU, true);
 #endif
             unmount();
-            UI_STATUS(UI_TEXT_SD_REMOVED);
+            UI_STATUS_UPD_F(Com::translatedF(UI_TEXT_SD_REMOVED_ID));
         }
     }
     else
     {
-        if(!sdactive)
+        if(!sdactive && sdmode != 100)
         {
-            UI_STATUS(UI_TEXT_SD_INSERTED);
+            UI_STATUS_UPD_F(Com::translatedF(UI_TEXT_SD_INSERTED_ID));
-            Com::printFLN(PSTR("SD card inserted")); // Not translateable or host will not understand signal
+            mount();
-            initsd();
+			if(sdmode != 100) // send message only if we have success
+	            Com::printFLN(PSTR("SD card inserted")); // Not translatable or host will not understand signal
 #if UI_DISPLAY_TYPE != NO_DISPLAY
-            if(sdactive) {
+            if(sdactive && !uid.isWizardActive()) { // Wizards have priority
                 Printer::setAutomount(true);
                 uid.executeAction(UI_ACTION_SD_PRINT + UI_ACTION_TOPMENU, true);
             }
@@ -77,11 +78,13 @@ void SDCard::initsd()
     if(READ(SDCARDDETECT) != SDCARDDETECTINVERTED)
         return;
 #endif
+	HAL::delayMilliseconds(50); // wait for stabilization of contacts, bootup ...
     /*if(dir[0].isOpen())
         dir[0].close();*/
     if(!fat.begin(SDSS, SPI_FULL_SPEED))
     {
         Com::printFLN(Com::tSDInitFail);
+		sdmode = 100; // prevent automount loop!
         return;
     }
     sdactive = true;
@@ -180,22 +183,26 @@ void SDCard::writeCommand(GCode *code)
     uint8_t buf[100];
     uint8_t p = 2;
     file.writeError = false;
-    int params = 128 | (code->params & ~1);
+    uint16_t params = 128 | (code->params & ~1);
-    *(int*)buf = params;
+	memcopy2(buf,&params);
+    //*(int*)buf = params;
     if(code->isV2())   // Read G,M as 16 bit value
     {
-        *(int*)&buf[p] = code->params2;
+		memcopy2(&buf[p],&code->params2);
+        //*(int*)&buf[p] = code->params2;
         p += 2;
         if(code->hasString())
             buf[p++] = strlen(code->text);
         if(code->hasM())
         {
-            *(int*)&buf[p] = code->M;
+			memcopy2(&buf[p],&code->M);
+            //*(int*)&buf[p] = code->M;
             p += 2;
         }
         if(code->hasG())
         {
-            *(int*)&buf[p]= code->G;
+			memcopy2(&buf[p],&code->G);
+            //*(int*)&buf[p]= code->G;
             p += 2;
         }
     }
@@ -212,27 +219,32 @@ void SDCard::writeCommand(GCode *code)
     }
     if(code->hasX())
     {
-        *(float*)&buf[p] = code->X;
+		memcopy4(&buf[p],&code->X);
+        //*(float*)&buf[p] = code->X;
         p += 4;
     }
     if(code->hasY())
     {
-        *(float*)&buf[p] = code->Y;
+		memcopy4(&buf[p],&code->Y);
+        //*(float*)&buf[p] = code->Y;
         p += 4;
     }
     if(code->hasZ())
     {
-        *(float*)&buf[p] = code->Z;
+		memcopy4(&buf[p],&code->Z);
+        //*(float*)&buf[p] = code->Z;
         p += 4;
     }
     if(code->hasE())
     {
-        *(float*)&buf[p] = code->E;
+		memcopy4(&buf[p],&code->E);
+        //*(float*)&buf[p] = code->E;
         p += 4;
     }
     if(code->hasF())
     {
-        *(float*)&buf[p] = code->F;
+		memcopy4(&buf[p],&code->F);
+        //*(float*)&buf[p] = code->F;
         p += 4;
     }
     if(code->hasT())
@@ -241,22 +253,80 @@ void SDCard::writeCommand(GCode *code)
     }
     if(code->hasS())
     {
-        *(long int*)&buf[p] = code->S;
+		memcopy4(&buf[p],&code->S);
+        //*(int32_t*)&buf[p] = code->S;
         p += 4;
     }
     if(code->hasP())
     {
-        *(long int*)&buf[p] = code->P;
+		memcopy4(&buf[p],&code->P);
+        //*(int32_t*)&buf[p] = code->P;
         p += 4;
     }
     if(code->hasI())
     {
-        *(float*)&buf[p] = code->I;
+		memcopy4(&buf[p],&code->I);
+        //*(float*)&buf[p] = code->I;
         p += 4;
     }
     if(code->hasJ())
     {
-        *(float*)&buf[p] = code->J;
+		memcopy4(&buf[p],&code->J);
+        //*(float*)&buf[p] = code->J;
+        p += 4;
+    }
+    if(code->hasR())
+    {
+		memcopy4(&buf[p],&code->R);
+        //*(float*)&buf[p] = code->R;
+        p += 4;
+    }
+    if(code->hasD())
+    {
+		memcopy4(&buf[p],&code->D);
+        //*(float*)&buf[p] = code->D;
+        p += 4;
+    }
+    if(code->hasC())
+    {
+		memcopy4(&buf[p],&code->C);
+        //*(float*)&buf[p] = code->C;
+        p += 4;
+    }
+    if(code->hasH())
+    {
+		memcopy4(&buf[p],&code->H);
+        //*(float*)&buf[p] = code->H;
+        p += 4;
+    }
+    if(code->hasA())
+    {
+		memcopy4(&buf[p],&code->A);
+        //*(float*)&buf[p] = code->A;
+        p += 4;
+    }
+    if(code->hasB())
+    {
+		memcopy4(&buf[p],&code->B);
+        //*(float*)&buf[p] = code->B;
+        p += 4;
+    }
+    if(code->hasK())
+    {
+		memcopy4(&buf[p],&code->K);
+        //*(float*)&buf[p] = code->K;
+        p += 4;
+    }
+    if(code->hasL())
+    {
+		memcopy4(&buf[p],&code->L);
+        //*(float*)&buf[p] = code->L;
+        p += 4;
+    }
+    if(code->hasO())
+    {
+		memcopy4(&buf[p],&code->O);
+        //*(float*)&buf[p] = code->O;
         p += 4;
     }
     if(code->hasString())   // read 16 uint8_t into string
@@ -289,6 +359,11 @@ void SDCard::writeCommand(GCode *code)
     }
     buf[p++] = sum1;
     buf[p++] = sum2;
+	// Debug
+	/*Com::printF(PSTR("Buf: "));
+	for(int i=0;i<p;i++)
+	Com::printF(PSTR(" "),(int)buf[i]);
+	Com::println();*/
     if(params == 128)
     {
         Com::printErrorFLN(Com::tAPIDFinished);
@@ -352,11 +427,97 @@ void SDCard::ls()
     Com::printFLN(Com::tEndFileList);
 }
 
+#if JSON_OUTPUT
+void SDCard::lsJSON(const char *filename)
+{
+    SdBaseFile dir;
+    fat.chdir();
+    if (*filename == 0) {
+        dir.openRoot(fat.vol());
+    } else {
+        if (!dir.open(fat.vwd(), filename, O_READ) || !dir.isDir()) {
+            Com::printF(Com::tJSONErrorStart);
+            Com::printF(Com::tFileOpenFailed);
+            Com::printFLN(Com::tJSONErrorEnd);
+            return;
+        }
+    }
+
+    Com::printF(Com::tJSONDir);
+    SDCard::printEscapeChars(filename);
+    Com::printF(Com::tJSONFiles);
+    dir.lsJSON();
+    Com::printFLN(Com::tJSONArrayEnd);
+}
+
+void SDCard::printEscapeChars(const char *s) {
+    for (unsigned int i = 0; i < strlen(s); ++i) {
+        switch (s[i]) {
+            case '"':
+            case '/':
+            case '\b':
+            case '\f':
+            case '\n':
+            case '\r':
+            case '\t':
+            case '\\':
+				Com::print('\\');
+                break;
+        }
+		Com::print(s[i]);
+    }
+}
+
+void SDCard::JSONFileInfo(const char* filename) {
+    SdBaseFile targetFile;
+    GCodeFileInfo *info,tmpInfo;
+    if (strlen(filename) == 0)  {
+        targetFile = file;
+        info = &fileInfo;
+    } else {
+        if (!targetFile.open(fat.vwd(), filename, O_READ) || targetFile.isDir()) {
+            Com::printF(Com::tJSONErrorStart);
+            Com::printF(Com::tFileOpenFailed);
+            Com::printFLN(Com::tJSONErrorEnd);
+            return;
+        }
+		info = &tmpInfo;
+        info->init(targetFile);
+    }
+    if (!targetFile.isOpen()) {
+        Com::printF(Com::tJSONErrorStart);
+        Com::printF(Com::tNotSDPrinting);
+        Com::printFLN(Com::tJSONErrorEnd);
+        return;
+    }
+
+    // {"err":0,"size":457574,"height":4.00,"layerHeight":0.25,"filament":[6556.3],"generatedBy":"Slic3r 1.1.7 on 2014-11-09 at 17:11:32"}
+    Com::printF(Com::tJSONFileInfoStart);
+    Com::print(info->fileSize);
+    Com::printF(Com::tJSONFileInfoHeight);
+    Com::print(info->objectHeight);
+    Com::printF(Com::tJSONFileInfoLayerHeight);
+    Com::print(info->layerHeight);
+    Com::printF(Com::tJSONFileInfoFilament);
+    Com::print(info->filamentNeeded);
+    Com::printF(Com::tJSONFileInfoGeneratedBy);
+    Com::print(info->generatedBy);
+    Com::print('"');
+    if (strlen(filename) == 0) {
+        Com::printF(Com::tJSONFileInfoName);
+        file.printName();
+	    Com::print('"');
+    }
+	Com::print('}');
+    Com::println();
+};
+
+#endif
+
 bool SDCard::selectFile(const char *filename, bool silent)
 {
     SdBaseFile parent;
     const char *oldP = filename;
-    boolean bFound;
 
     if(!sdactive) return false;
     sdmode = 0;
@@ -376,6 +537,9 @@ bool SDCard::selectFile(const char *filename, bool silent)
             Com::printF(Com::tFileOpened, oldP);
             Com::printFLN(Com::tSpaceSizeColon,file.fileSize());
         }
+#if JSON_OUTPUT
+        fileInfo.init(file);
+#endif
         sdpos = 0;
         filesize = file.fileSize();
         Com::printFLN(Com::tFileSelected);
@@ -414,7 +578,7 @@ void SDCard::startWrite(char *filename)
     }
     else
     {
-        UI_STATUS(UI_TEXT_UPLOADING);
+        UI_STATUS_F(Com::translatedF(UI_TEXT_UPLOADING_ID));
         savetosd = true;
         Com::printFLN(Com::tWritingToFile,filename);
     }
@@ -480,5 +644,3 @@ void SDCard::writeToFile()
 
 #endif
 
-
-

Repetier/SdFat.cpp

@@ -32,11 +32,6 @@ extern int8_t RFstrnicmp(const char* s1, const char* s2, size_t n);
 
 //#define GLENN_DEBUG
 
-//------------------------------------------------------------------------------
-//------------------------------------------------------------------------------
-static void pstrPrint(FSTRINGPARAM(str)) {
-    Com::printF(str);
-}
 //------------------------------------------------------------------------------
 static void pstrPrintln(FSTRINGPARAM(str)) {
   Com::printFLN(str);
@@ -652,11 +647,12 @@ void SdBaseFile::ls(uint8_t flags) {
   ls(flags, 0);
 }
 
-uint8_t SdBaseFile::lsRecursive(SdBaseFile *parent, uint8_t level, char *findFilename, SdBaseFile *pParentFound)
+uint8_t SdBaseFile::lsRecursive(SdBaseFile *parent, uint8_t level, char *findFilename, SdBaseFile *pParentFound, bool isJson)
 {
     dir_t *p = NULL;
-    uint8_t cnt=0;
+    //uint8_t cnt=0;
-    char *oldpathend = pathend;
+    //char *oldpathend = pathend;
+    bool firstFile = true;
 
     parent->rewind();
 
@@ -665,21 +661,29 @@ uint8_t SdBaseFile::lsRecursive(SdBaseFile *parent, uint8_t level, char *findFil
         HAL::pingWatchdog();
         if (! (DIR_IS_FILE(p) || DIR_IS_SUBDIR(p))) continue;
         if (strcmp(tempLongFilename, "..") == 0) continue;
-        if( DIR_IS_SUBDIR(p))
+        if (tempLongFilename[0] == '.') continue; // MAC CRAP
-        {
+        if (DIR_IS_SUBDIR(p)) {
             if (level >= SD_MAX_FOLDER_DEPTH) continue; // can't go deeper
-            if(level<SD_MAX_FOLDER_DEPTH)
+            if (level < SD_MAX_FOLDER_DEPTH && findFilename == NULL) {
-            {
+                if (level && !isJson) {
-                if (findFilename == NULL)
-                  {
-                   if(level)
-                    {
                     Com::print(fullName);
                     Com::printF(Com::tSlash);
                  }
+#if JSON_OUTPUT
+                if (isJson) {
+                    if (!firstFile) Com::print(',');
+				    Com::print('"');Com::print('*');
+                    SDCard::printEscapeChars(tempLongFilename);
+				    Com::print('"');
+                    firstFile = false;
+                } else {
                     Com::print(tempLongFilename);
                     Com::printFLN(Com::tSlash); // End with / to mark it as directory entry, so we can see empty directories.
                 }
+#else
+                Com::print(tempLongFilename);
+                Com::printFLN(Com::tSlash); // End with / to mark it as directory entry, so we can see empty directories.
+#endif
             }
             SdBaseFile next;
             char *tmp;
@@ -689,9 +693,9 @@ uint8_t SdBaseFile::lsRecursive(SdBaseFile *parent, uint8_t level, char *findFil
             strcat(fullName, tempLongFilename);
             uint16_t index = (parent->curPosition()-31) >> 5;
 
-            if(next.open(parent, index, O_READ))
+            if(!isJson && next.open(parent, index, O_READ))
             {
-              if (next.lsRecursive(&next,level+1, findFilename, pParentFound))
+              if (next.lsRecursive(&next,level+1, findFilename, pParentFound,false))
                   return true;
             }
             parent->seekSet(32 * (index + 1));
@@ -721,11 +725,21 @@ uint8_t SdBaseFile::lsRecursive(SdBaseFile *parent, uint8_t level, char *findFil
             }
             else
             {
-                if(level)
+                if(level && !isJson)
                 {
                     Com::print(fullName);
                     Com::printF(Com::tSlash);
                 }
+#if JSON_OUTPUT
+                if (isJson) {
+                    if (!firstFile) Com::printF(Com::tComma);
+				    Com::print('"');
+                    SDCard::printEscapeChars(tempLongFilename);
+				    Com::print('"');
+                    firstFile = false;
+                } else
+#endif
+                {
                     Com::print(tempLongFilename);
 #if SD_EXTENDED_DIR
                     Com::printF(Com::tSpace, (long) p->fileSize);
@@ -734,6 +748,7 @@ uint8_t SdBaseFile::lsRecursive(SdBaseFile *parent, uint8_t level, char *findFil
                 }
             }
         }
+    }
     return false;
 }
 
@@ -755,19 +770,29 @@ uint8_t SdBaseFile::lsRecursive(SdBaseFile *parent, uint8_t level, char *findFil
  */
 void SdBaseFile::ls(uint8_t flags, uint8_t indent) {
     SdBaseFile parent;
-
     rewind();
     *fullName = 0;
     pathend = fullName;
     parent = *this;
-  lsRecursive(&parent, 0, NULL, NULL);
+    lsRecursive(&parent, 0, NULL, NULL, false);
 }
+
+#if JSON_OUTPUT
+void SdBaseFile::lsJSON() {
+    SdBaseFile parent;
+    rewind();
+    *fullName = 0;
+    parent = *this;
+    lsRecursive(&parent, 0, NULL, NULL, true);
+}
+#endif
+
 //------------------------------------------------------------------------------
 // saves 32 bytes on stack for ls recursion
 // return 0 - EOF, 1 - normal file, or 2 - directory
 int8_t SdBaseFile::lsPrintNext(uint8_t flags, uint8_t indent) {
   dir_t dir;
-  uint8_t w = 0;
+  //uint8_t w = 0;
   while (1) {
     if (read(&dir, sizeof(dir)) != sizeof(dir)) return 0;
     if (dir.name[0] == DIR_NAME_FREE) return 0;
@@ -876,8 +901,6 @@ bool SdBaseFile::mkdir(SdBaseFile* parent, const char* path, bool pFlag) {
     {
     return mkdir(&newParent, dname);
     }
-
- fail:
   return false;
 }
 //------------------------------------------------------------------------------
@@ -886,13 +909,13 @@ bool SdBaseFile::mkdir(SdBaseFile* parent, const uint8_t *dname) {
 
   if (!parent->isDir()) {
     DBG_FAIL_MACRO;
-    goto fail;
+    return false;
   }
 
   // create a normal file
   if (!open(parent, dname, O_CREAT | O_EXCL | O_RDWR, true)) {
     DBG_FAIL_MACRO;
-    goto fail;
+    return false;
   }
 
   // make entry for '.'
@@ -908,7 +931,7 @@ bool SdBaseFile::mkdir(SdBaseFile* parent, const uint8_t *dname) {
   for (uint8_t i = 1; i < 11; i++) d.name[i] = ' ';
 
   if (write(&d, sizeof(dir_t)) < 0)
-    goto fail;
+    return false;
   sync();
 
   // make entry for '..'
@@ -921,18 +944,16 @@ bool SdBaseFile::mkdir(SdBaseFile* parent, const uint8_t *dname) {
     d.firstClusterHigh = parent->firstCluster_ >> 16;
   }
   if (write(&d, sizeof(dir_t)) < 0)
-    goto fail;
+    return false;
   sync();
   memset(&d, 0, sizeof(dir_t));
   if (write(&d, sizeof(dir_t)) < 0)
-    goto fail;
+    return false;
   sync();
 //  fileSize_ = 0;
   type_ = FAT_FILE_TYPE_SUBDIR;
   flags_ |= F_FILE_DIR_DIRTY;
   return true;
- fail:
-  return false;
 }
 //------------------------------------------------------------------------------
  /** Open a file in the current working directory.
@@ -1005,10 +1026,10 @@ bool SdBaseFile::mkdir(SdBaseFile* parent, const uint8_t *dname) {
    SdBaseFile *newParent, boolean bMakeDirs) {
   SdBaseFile dir1, dir2;
   SdBaseFile *parent = dirFile;
-  dir_t *pEntry;
+  //dir_t *pEntry;
   SdBaseFile *sub = &dir1;
   char *p;
-  boolean bFound;
+  //boolean bFound;
 
 #ifdef GLENN_DEBUG
     Commands::checkFreeMemory();
@@ -1052,7 +1073,7 @@ bool SdBaseFile::mkdir(SdBaseFile* parent, const uint8_t *dname) {
        Commands::checkFreeMemory();
        Commands::writeLowestFreeRAM();
 #endif
-        bFound = false;
+        //bFound = false;
         if (!sub->open(parent, dname, O_READ, false))
             {
             if (!bMakeDirs)
@@ -1093,7 +1114,6 @@ bool SdBaseFile::open(SdBaseFile* dirFile, const char* path, uint8_t oflag)
     return open(&parent, dname, oflag, false);
     }
 
- fail:
   return false;
 }
 
@@ -1113,11 +1133,11 @@ uint8_t SdBaseFile::lfn_checksum(const unsigned char *pFCBName)
 bool SdBaseFile::open(SdBaseFile* dirFile,const uint8_t *dname, uint8_t oflag, bool bDir) {
   bool emptyFound = false;
   uint8_t index = 0;
-  dir_t tempDir, *p;
+  dir_t tempDir, *p = NULL;
   const char *tempPtr;
   char newName[SHORT_FILENAME_LENGTH+2];
   boolean bShortName = false;
-  int8_t cVFATNeeded = -1, wIndex, cVFATFoundCur;
+  int8_t cVFATNeeded = -1, cVFATFoundCur;
   uint32_t wIndexPos = 0;
   uint8_t cbFilename;
   char *Filename = (char *)dname;
@@ -1570,6 +1590,9 @@ bool SdBaseFile::openParent(SdBaseFile* dir) {
 bool SdBaseFile::openRoot(SdVolume* vol) {
   // error if file is already open
   if (isOpen()) {
+#if defined(DEBUG_SD_ERROR)
+	Com::printErrorFLN(PSTR("Root already open"));
+#endif	  
     DBG_FAIL_MACRO;
     goto fail;
   }
@@ -1587,6 +1610,10 @@ bool SdBaseFile::openRoot(SdVolume* vol) {
     }
   } else {
     // volume is not initialized, invalid, or FAT12 without support
+#if defined(DEBUG_SD_ERROR)
+	Com::printErrorF(PSTR("volume is not initialized, invalid, or FAT12 without support, type:"));
+	Com::print((int)vol->fatType());Com::println();
+#endif
     DBG_FAIL_MACRO;
     goto fail;
   }
@@ -1603,6 +1630,9 @@ bool SdBaseFile::openRoot(SdVolume* vol) {
   return true;
 
  fail:
+#if defined(DEBUG_SD_ERROR)
+   Com::printErrorFLN(PSTR("SD open root dir failed"));
+#endif   
   return false;
 }
 //------------------------------------------------------------------------------
@@ -2055,7 +2085,7 @@ dir_t *SdBaseFile::getLongFilename(dir_t *dir, char *longFilename, int8_t cVFATN
 
 bool SdBaseFile::findSpace(dir_t *dir, int8_t cVFATNeeded, int8_t *pcVFATFound, uint32_t *pwIndexPos)
 {
-  int16_t n;
+  //int16_t n; // unused
   int8_t cVFATFound = 0;
   // if not a directory file or miss-positioned return an error
   if (!isDir()) return -1;
@@ -2081,7 +2111,7 @@ bool SdBaseFile::findSpace(dir_t *dir, int8_t cVFATNeeded, int8_t *pcVFATFound,
            {
           if (DIR_IS_LONG_NAME(dir))
             {
-            vfat_t *VFAT = (vfat_t*)dir;
+            //vfat_t *VFAT = (vfat_t*)dir; // unused
             cVFATFound++;
             }
           else
@@ -3202,7 +3232,7 @@ uint8_t Sd2Card::cardCommand(uint8_t cmd, uint32_t arg) {
 
 #if USE_SD_CRC
   // form message
-  uint8_t d[6] = {cmd | 0X40, pa[3], pa[2], pa[1], pa[0]};
+  uint8_t d[6] = {static_cast<uint8_t>(cmd | static_cast<uint8_t>(0X40)), pa[3], pa[2], pa[1], pa[0]};
 
   // add crc
   d[5] = CRC7(d, 5);
@@ -3415,6 +3445,9 @@ bool Sd2Card::init(uint8_t sckRateID, uint8_t chipSelectPin) {
 
  fail:
   chipSelectHigh();
+#if defined(DEBUG_SD_ERROR)
+  Com::printErrorFLN(PSTR("SD card initalization failed"));
+#endif
   return false;
 }
 //------------------------------------------------------------------------------
@@ -3469,7 +3502,7 @@ bool Sd2Card::readData(uint8_t* dst, size_t count) {
     goto fail;
   }
   // transfer data
-  if (status_ = spiRec(dst, count)) {
+  if ((status_ = spiRec(dst, count))) {
     error(SD_CARD_ERROR_SPI_DMA);
     goto fail;
   }
@@ -4224,7 +4257,7 @@ bool SdVolume::init(Sd2Card* dev, uint8_t part) {
   cacheStatus_ = 0;  // cacheSync() will write block if true
   cacheBlockNumber_ = 0XFFFFFFFF;
   cacheFatOffset_ = 0;
-#if USE_SERARATEFAT_CACHE
+#if defined(USE_SERARATEFAT_CACHE) && USE_SERARATEFAT_CACHE
   cacheFatStatus_ = 0;  // cacheSync() will write block if true
   cacheFatBlockNumber_ = 0XFFFFFFFF;
 #endif  // USE_SERARATEFAT_CACHE
@@ -4232,11 +4265,17 @@ bool SdVolume::init(Sd2Card* dev, uint8_t part) {
   // if part > 0 assume mbr volume with partition table
   if (part) {
     if (part > 4) {
+#if defined(DEBUG_SD_ERROR)
+	Com::printErrorFLN(PSTR("volume init: illegal part"));
+#endif		
       DBG_FAIL_MACRO;
       goto fail;
     }
     pc = cacheFetch(volumeStartBlock, CACHE_FOR_READ);
     if (!pc) {
+#if defined(DEBUG_SD_ERROR)
+		Com::printErrorFLN(PSTR("volume init: cache fetch failed"));
+#endif
       DBG_FAIL_MACRO;
       goto fail;
     }
@@ -4245,6 +4284,9 @@ bool SdVolume::init(Sd2Card* dev, uint8_t part) {
       p->totalSectors < 100 ||
       p->firstSector == 0) {
       // not a valid partition
+#if defined(DEBUG_SD_ERROR)
+		Com::printErrorFLN(PSTR("volume init: invalid partition"));
+#endif
       DBG_FAIL_MACRO;
       goto fail;
     }
@@ -4252,6 +4294,9 @@ bool SdVolume::init(Sd2Card* dev, uint8_t part) {
   }
   pc = cacheFetch(volumeStartBlock, CACHE_FOR_READ);
   if (!pc) {
+#if defined(DEBUG_SD_ERROR)
+Com::printErrorFLN(PSTR("volume init: cache fetch failed"));
+#endif
     DBG_FAIL_MACRO;
     goto fail;
   }
@@ -4261,6 +4306,13 @@ bool SdVolume::init(Sd2Card* dev, uint8_t part) {
     fbs->reservedSectorCount == 0 ||
     fbs->sectorsPerCluster == 0) {
        // not valid FAT volume
+#if defined(DEBUG_SD_ERROR)
+	Com::printErrorFLN(PSTR("volume init: not a valid FAT volume"));
+	Com::printFLN(PSTR("BytesPerSector:"),fbs->bytesPerSector);
+	Com::printFLN(PSTR("fatCount:"),fbs->fatCount);
+	Com::printFLN(PSTR("reservedSectorCount:"),fbs->reservedSectorCount);
+	Com::printFLN(PSTR("sectorsPerCluster:"),fbs->sectorsPerCluster);
+#endif
       DBG_FAIL_MACRO;
       goto fail;
   }
@@ -4303,6 +4355,9 @@ bool SdVolume::init(Sd2Card* dev, uint8_t part) {
   if (clusterCount_ < 4085) {
     fatType_ = 12;
     if (!FAT12_SUPPORT) {
+#if defined(DEBUG_SD_ERROR)
+		Com::printErrorFLN(PSTR("volume init: No FAT 12 support"));
+#endif
       DBG_FAIL_MACRO;
       goto fail;
     }
@@ -4315,6 +4370,9 @@ bool SdVolume::init(Sd2Card* dev, uint8_t part) {
   return true;
 
  fail:
+#if defined(DEBUG_SD_ERROR)
+   Com::printErrorFLN(PSTR("SD volume open failed"));
+#endif
   return false;
 }
 // =============== SdFile.cpp ====================
@@ -4434,5 +4492,3 @@ void SdFatUtil::SerialPrintln_P(FSTRINGPARAM(str)) {
 
 #endif  // SDSUPPORT
 
-
-

Repetier/SdFat.h

@@ -2057,7 +2057,7 @@ class SdBaseFile {
   dir_t* readDirCacheSpecial();
   dir_t *getLongFilename(dir_t *dir, char *longFilename, int8_t cVFATNeeded, uint32_t *pwIndexPos);
   bool findSpace(dir_t *dir, int8_t cVFATNeeded, int8_t *pcVFATFound, uint32_t *pwIndexPos);
-  uint8_t lsRecursive(SdBaseFile *parent, uint8_t level, char *findFilename, SdBaseFile *pParentFound);
+  uint8_t lsRecursive(SdBaseFile *parent, uint8_t level, char *findFilename, SdBaseFile *pParentFound, bool isJson);
 
   bool setDirSize();
 //------------------------------------------------------------------------------
@@ -2208,6 +2208,9 @@ class SdBaseFile {
   static bool remove(SdBaseFile& dirFile, const char* path)  // NOLINT
     __attribute__((error("use remove(&dirFile, path)")));
 #endif  // ALLOW_DEPRECATED_FUNCTIONS
+#if JSON_OUTPUT
+	void lsJSON();
+#endif
 };
 //------------------------------------------------------------------------------
 /**
@@ -2321,5 +2324,3 @@ class SdFat {
   SdBaseFile vwd_;
 };
 #endif  // SdFat_h
-
-

Repetier/cores/CDC.cpp

@@ -1,3 +0,0 @@
-/* Stub for CDC.cpp */
-
-#include <CDC.cpp>

Repetier/cores/HardwareSerial.cpp

@@ -1,3 +0,0 @@
-/* Stub for HardwareSerial.cpp */
-
-#include <HardwareSerial.cpp>

Repetier/cores/IPAddress.cpp

@@ -1,3 +0,0 @@
-/* Stub for IPAddress.cpp */
-
-#include <IPAddress.cpp>

Repetier/cores/Print.cpp

@@ -1 +0,0 @@
-#include <Print.cpp>

Repetier/cores/Stream.cpp

@@ -1 +0,0 @@
-#include <Stream.cpp>

Repetier/cores/Tone.cpp

@@ -1 +0,0 @@
-#include <Tone.cpp>

Repetier/cores/USBCore.cpp

@@ -1,2 +0,0 @@
-#include <HID.cpp>
-#include <USBCore.cpp>

Repetier/cores/WInterrupts.c

@@ -1 +0,0 @@
-#include <WInterrupts.c>

Repetier/cores/WMath.cpp

@@ -1 +0,0 @@
-#include <WMath.cpp>

Repetier/cores/WString.cpp

@@ -1 +0,0 @@
-#include <WString.cpp>

Repetier/cores/main.cpp

@@ -1 +0,0 @@
-#include <main.cpp>

Repetier/cores/new.cpp

@@ -1 +0,0 @@
-#include <new.cpp>

Repetier/cores/wiring.c

@@ -1 +0,0 @@
-#include <wiring.c>

Repetier/cores/wiring_analog.c

@@ -1 +0,0 @@
-#include <wiring_analog.c>

Repetier/cores/wiring_digital.c

@@ -1 +0,0 @@
-#include <wiring_digital.c>

Repetier/cores/wiring_pulse.c

@@ -1 +0,0 @@
-#include <wiring_pulse.c>

Repetier/cores/wiring_shift.c

@@ -1 +0,0 @@
-#include <wiring_shift.c>

Repetier/fastio.h

@@ -3735,5 +3735,3 @@ pins
 
 #endif /* _ARDUINO_H */
 
-
-

Repetier/gcode.cpp

@@ -224,7 +224,7 @@ void GCode::checkAndPushCommand()
     }
     pushCommand();
 #ifdef DEBUG_COM_ERRORS
-    if(M == 667)
+    if(hasM() && M == 667)
         return; // omit ok
 #endif
 #if ACK_WITH_LINENUMBER
@@ -428,7 +428,7 @@ void GCode::readFromSerial()
         }
     }
 #if SDSUPPORT
-    if(sd.sdmode == 0 || commandsReceivingWritePosition != 0)   // not reading or incoming serial command
+    if(sd.sdmode == 0 || sd.sdmode >= 100 || commandsReceivingWritePosition != 0)   // not reading or incoming serial command
         return;
     while( sd.filesize > sd.sdpos && commandsReceivingWritePosition < MAX_CMD_SIZE)    // consume data until no data or buffer full
     {
@@ -549,12 +549,12 @@ bool GCode::parseBinary(uint8_t *buffer,bool fromSerial)
         return false;
     }
     p = buffer;
-    params = *(unsigned int *)p;
+    params = *(uint16_t *)p;
     p += 2;
     uint8_t textlen = 16;
     if(isV2())
     {
-        params2 = *(unsigned int *)p;
+        params2 = *(uint16_t *)p;
         p += 2;
         if(hasString())
             textlen = *p++;
@@ -567,12 +567,12 @@ bool GCode::parseBinary(uint8_t *buffer,bool fromSerial)
     }
     if(isV2())   // Read G,M as 16 bit value
     {
-        if(params & 2)
+        if(hasM())
         {
             M = *(uint16_t *)p;
             p += 2;
         }
-        if(params & 4)
+        if(hasG())
         {
             G = *(uint16_t *)p;
             p += 2;
@@ -580,51 +580,51 @@ bool GCode::parseBinary(uint8_t *buffer,bool fromSerial)
     }
     else
     {
-        if(params & 2)
+        if(hasM())
         {
             M = *p++;
         }
-        if(params & 4)
+        if(hasG())
         {
             G = *p++;
         }
     }
     //if(code->params & 8) {memcpy(&code->X,p,4);p+=4;}
-    if(params & 8)
+    if(hasX())
     {
         X = *(float *)p;
         p += 4;
     }
-    if(params & 16)
+    if(hasY())
     {
         Y = *(float *)p;
         p += 4;
     }
-    if(params & 32)
+    if(hasZ())
     {
         Z = *(float *)p;
         p += 4;
     }
-    if(params & 64)
+    if(hasE())
     {
         E = *(float *)p;
         p += 4;
     }
-    if(params & 256)
+    if(hasF())
     {
         F = *(float *)p;
         p += 4;
     }
-    if(params & 512)
+    if(hasT())
     {
         T = *p++;
     }
-    if(params & 1024)
+    if(hasS())
     {
         S = *(int32_t*)p;
         p += 4;
     }
-    if(params & 2048)
+    if(hasP())
     {
         P = *(int32_t*)p;
         p += 4;
@@ -706,6 +706,7 @@ bool GCode::parseAscii(char *line,bool fromSerial)
     char c;
     while ( (c = *(pos++)) )
     {
+        if(c == '(' || c == '%') break; // alternative comment or program block
         switch(c)
         {
         case 'N':
@@ -731,7 +732,7 @@ bool GCode::parseAscii(char *line,bool fromSerial)
             params |= 2;
             if(M > 255) params |= 4096;
             // handle non standard text arguments that some M codes have
-            if (M == 23 || M == 28 || M == 29 || M == 30 || M == 32 || M == 117)
+            if (M == 20 || M == 23 || M == 28 || M == 29 || M == 30 || M == 32 || M == 36 || M == 117)
             {
                 // after M command we got a filename or text
                 char digit;
@@ -749,7 +750,7 @@ bool GCode::parseAscii(char *line,bool fromSerial)
                 text = pos;
                 while (*pos)
                 {
-                    if((M != 117 && *pos==' ') || *pos=='*') break;
+                    if((M != 117 && M != 20 && *pos==' ') || *pos=='*') break;
                     pos++; // find a space as file name end
                 }
                 *pos = 0; // truncate filename by erasing space with nul, also skips checksum
@@ -846,6 +847,62 @@ bool GCode::parseAscii(char *line,bool fromSerial)
             params |= 4096; // Needs V2 for saving
             break;
         }
+        case 'C':
+        case 'c':
+        {
+	        D = parseFloatValue(pos);
+	        params2 |= 16;
+	        params |= 4096; // Needs V2 for saving
+	        break;
+        }
+        case 'H':
+        case 'h':
+        {
+	        D = parseFloatValue(pos);
+	        params2 |= 32;
+	        params |= 4096; // Needs V2 for saving
+	        break;
+        }
+        case 'A':
+        case 'a':
+        {
+	        D = parseFloatValue(pos);
+	        params2 |= 64;
+	        params |= 4096; // Needs V2 for saving
+	        break;
+        }
+        case 'B':
+        case 'b':
+        {
+	        D = parseFloatValue(pos);
+	        params2 |= 128;
+	        params |= 4096; // Needs V2 for saving
+	        break;
+        }
+        case 'K':
+        case 'k':
+        {
+	        D = parseFloatValue(pos);
+	        params2 |= 256;
+	        params |= 4096; // Needs V2 for saving
+	        break;
+        }
+        case 'L':
+        case 'l':
+        {
+	        D = parseFloatValue(pos);
+	        params2 |= 512;
+	        params |= 4096; // Needs V2 for saving
+	        break;
+        }
+        case 'O':
+        case 'o':
+        {
+	        D = parseFloatValue(pos);
+	        params2 |= 1024;
+	        params |= 4096; // Needs V2 for saving
+	        break;
+        }
         case '*' : //checksum
         {
             uint8_t checksum_given = parseLongValue(pos);
@@ -885,7 +942,7 @@ void GCode::printCommand()
 {
     if(hasN()) {
         Com::print('N');
-        Com::print((long)N);
+        Com::print((int32_t)N);
         Com::print(' ');
     }
     if(hasM())
@@ -953,4 +1010,192 @@ void GCode::printCommand()
     Com::println();
 }
 
+#if JSON_OUTPUT
 
+// --------------------------------------------------------------- //
+// Code that gets gcode information is adapted from RepRapFirmware //
+// Originally licenced under GPL                                   //
+// Authors: reprappro, dc42, dcnewman, others                      //
+// Source: https://github.com/dcnewman/RepRapFirmware              //
+// Copy date: 15 Nov 2015                                          //
+// --------------------------------------------------------------- //
+
+void GCodeFileInfo::init(SdBaseFile &file) {
+	this->fileSize = file.fileSize();
+	this->filamentNeeded = 0.0;
+	this->objectHeight = 0.0;
+	this->layerHeight = 0.0;
+	if (!file.isOpen()) return;
+	bool genByFound = false, layerHeightFound = false, filamentNeedFound = false;
+	#if CPU_ARCH==ARCH_AVR
+	#define GCI_BUF_SIZE 120
+	#else
+	#define GCI_BUF_SIZE 1024
+	#endif
+	// READ 4KB FROM THE BEGINNING
+	char buf[GCI_BUF_SIZE];
+	for (int i = 0; i < 4096; i += GCI_BUF_SIZE-50) {
+		if(!file.seekSet(i)) break;
+		file.read(buf, GCI_BUF_SIZE);
+		if (!genByFound && findGeneratedBy(buf, this->generatedBy)) genByFound = true;
+		if (!layerHeightFound && findLayerHeight(buf, this->layerHeight)) layerHeightFound = true;
+		if (!filamentNeedFound && findFilamentNeed(buf, this->filamentNeeded)) filamentNeedFound = true;
+		if(genByFound && layerHeightFound && filamentNeedFound) goto get_objectHeight;
+	}
+
+	// READ 4KB FROM END
+	for (int i = 0; i < 4096; i += GCI_BUF_SIZE-50) {
+		if(!file.seekEnd(-4096 + i)) break;
+		file.read(buf, GCI_BUF_SIZE);
+		if (!genByFound && findGeneratedBy(buf, this->generatedBy)) genByFound = true;
+		if (!layerHeightFound && findLayerHeight(buf, this->layerHeight)) layerHeightFound = true;
+		if (!filamentNeedFound && findFilamentNeed(buf, this->filamentNeeded)) filamentNeedFound = true;
+		if(genByFound && layerHeightFound && filamentNeedFound) goto get_objectHeight;
+	}
+	
+	get_objectHeight:
+	// MOVE FROM END UP IN 1KB BLOCKS UP TO 30KB
+	for (int i = GCI_BUF_SIZE; i < 30000; i += GCI_BUF_SIZE-50) {
+		if(!file.seekEnd(-i)) break;
+		file.read(buf, GCI_BUF_SIZE);
+		if (findTotalHeight(buf, this->objectHeight)) break;
+	}
+	file.seekSet(0);
+}
+
+bool GCodeFileInfo::findGeneratedBy(char *buf, char *genBy) {
+    // Slic3r & S3D
+    const char* generatedByString = PSTR("generated by ");
+    char* pos = strstr_P(buf, generatedByString);
+    if (pos) {
+        pos += strlen_P(generatedByString);
+        size_t i = 0;
+        while (i < GENBY_SIZE - 1 && *pos >= ' ') {
+            char c = *pos++;
+            if (c == '"' || c == '\\') {
+                // Need to escape the quote-mark for JSON
+                if (i > GENBY_SIZE - 3) break;
+                genBy[i++] = '\\';
+            }
+            genBy[i++] = c;
+        }
+        genBy[i] = 0;
+        return true;
+    }
+
+    // CURA
+    const char* slicedAtString = PSTR(";Sliced at: ");
+    pos = strstr_P(buf, slicedAtString);
+    if (pos) {
+        strcpy_P(genBy, PSTR("Cura"));
+        return true;
+    }
+
+    // UNKNOWN
+    strcpy_P(genBy, PSTR("Unknown"));
+    return false;
+}
+
+bool GCodeFileInfo::findLayerHeight(char *buf, float &layerHeight) {
+    // SLIC3R
+	layerHeight = 0;
+    const char* layerHeightSlic3r = PSTR("; layer_height ");
+    char *pos = strstr_P(buf, layerHeightSlic3r);
+    if (pos) {
+        pos += strlen_P(layerHeightSlic3r);
+        while (*pos == ' ' || *pos == 't' || *pos == '=' || *pos == ':') {
+            ++pos;
+        }
+        layerHeight = strtod(pos, NULL);
+        return true;
+    }
+
+    // CURA
+    const char* layerHeightCura = PSTR("Layer height: ");
+    pos = strstr_P(buf, layerHeightCura);
+    if (pos) {
+        pos += strlen_P(layerHeightCura);
+        while (*pos == ' ' || *pos == 't' || *pos == '=' || *pos == ':') {
+            ++pos;
+        }
+        layerHeight = strtod(pos, NULL);
+        return true;
+    }
+
+    return false;
+}
+
+bool GCodeFileInfo::findFilamentNeed(char *buf, float &filament) {
+    const char* filamentUsedStr = PSTR("filament used");
+    const char* pos = strstr_P(buf, filamentUsedStr);
+	filament = 0;
+    if (pos != NULL) {
+        pos += strlen_P(filamentUsedStr);
+        while (*pos == ' ' || *pos == 't' || *pos == '=' || *pos == ':') {
+            ++pos;    // this allows for " = " from default slic3r comment and ": " from default Cura comment
+        }
+        if (isDigit(*pos)) {
+            char *q;
+            filament += strtod(pos, &q);
+            if (*q == 'm' && *(q + 1) != 'm') {
+                filament *= 1000.0;        // Cura outputs filament used in metres not mm
+            }
+        }
+        return true;
+    }
+    return false;
+}
+
+bool GCodeFileInfo::findTotalHeight(char *buf, float &height) {
+    int len = 1024;
+    bool inComment, inRelativeMode = false;
+    unsigned int zPos;
+    for (int i = len - 5; i > 0; i--) {
+        if (inRelativeMode) {
+            inRelativeMode = !(buf[i] == 'G' && buf[i + 1] == '9' && buf[i + 2] == '1' && buf[i + 3] <= ' ');
+        } else if (buf[i] == 'G') {
+            // Ignore G0/G1 codes if absolute mode was switched back using G90 (typical for Cura files)
+            if (buf[i + 1] == '9' && buf[i + 2] == '0' && buf[i + 3] <= ' ') {
+                inRelativeMode = true;
+            } else if ((buf[i + 1] == '0' || buf[i + 1] == '1') && buf[i + 2] == ' ') {
+                // Look for last "G0/G1 ... Z#HEIGHT#" command as generated by common slicers
+                // Looks like we found a controlled move, however it could be in a comment, especially when using slic3r 1.1.1
+                inComment = false;
+                size_t j = i;
+                while (j != 0) {
+                    --j;
+                    char c = buf[j];
+                    if (c == '\n' || c == '\r') break;
+                    if (c == ';') {
+                        // It is in a comment, so give up on this one
+                        inComment = true;
+                        break;
+                    }
+                }
+                if (inComment) continue;
+
+                // Find 'Z' position and grab that value
+                zPos = 0;
+                for (int j = i + 3; j < len - 2; j++) {
+                    char c = buf[j];
+                    if (c < ' ') {
+                        // Skip all whitespaces...
+                        while (j < len - 2 && c <= ' ') {
+                            c = buf[++j];
+                        }
+                        // ...to make sure ";End" doesn't follow G0 .. Z#HEIGHT#
+                        if (zPos != 0) {
+                            //debugPrintf("Found at offset %u text: %.100s\n", zPos, &buf[zPos + 1]);
+                            height = strtod(&buf[zPos + 1], NULL);
+                            return true;
+                        }
+                        break;
+                    } else if (c == ';') break;
+                    else if (c == 'Z') zPos = j;
+                }
+            }
+        }
+    }
+    return false;
+}
+#endif // JSON_OUTPUT

Repetier/gcode.h

@@ -19,22 +19,23 @@
 #define _GCODE_H
 
 #define MAX_CMD_SIZE 96
+#define ARRAY_SIZE(_x)	(sizeof(_x)/sizeof(_x[0]))
 class SDCard;
 class GCode   // 52 uint8_ts per command needed
 {
-    unsigned int params;
+    uint16_t params;
-    unsigned int params2;
+    uint16_t params2;
 public:
-    unsigned int N; // Line number
+    uint16_t N; // Line number
-    unsigned int M;
+    uint16_t M;
-    unsigned int G;
+    uint16_t G;
     float X;
     float Y;
     float Z;
     float E;
     float F;
-    long S;
+    int32_t S;
-    long P;
+    int32_t P;
     float I;
     float J;
     float R;
@@ -191,6 +192,7 @@ private:
     inline float parseFloatValue(char *s)
     {
         char *endPtr;
+        while(*s == 32) s++; // skip spaces
         float f = (strtod(s, &endPtr));
         if(s == endPtr) f=0.0; // treat empty string "x " as "x0"
         return f;
@@ -198,6 +200,7 @@ private:
     inline long parseLongValue(char *s)
     {
         char *endPtr;
+        while(*s == 32) s++; // skip spaces
         long l = (strtol(s, &endPtr, 10));
         if(s == endPtr) l=0; // treat empty string argument "p " as "p0"
         return l;
@@ -221,8 +224,26 @@ private:
     static uint8_t formatErrors; ///< Number of sequential format errors
 };
 
+#if JSON_OUTPUT
+#include "SdFat.h"
+// Struct to hold Gcode file information 32 bytes
+#define GENBY_SIZE 16
+class GCodeFileInfo {
+public:
+    void init(SdBaseFile &file);
+
+    unsigned long fileSize;
+    float objectHeight;
+    float layerHeight;
+    float filamentNeeded;
+    char generatedBy[GENBY_SIZE];
+
+    bool findGeneratedBy(char *buf, char *genBy);
+    bool findLayerHeight(char *buf, float &layerHeight);
+    bool findFilamentNeed(char *buf, float &filament);
+    bool findTotalHeight(char *buf, float &objectHeight);
+};
+#endif
 
 #endif
 
-
-

Repetier/libraries/EEPROM.cpp

@@ -1 +0,0 @@
-#include <EEPROM.cpp>

Repetier/libraries/Ethernet.cpp

@@ -1,8 +0,0 @@
-#include <w5100.cpp>
-#include <socket.cpp>
-#include <Dns.cpp>
-#include <Dhcp.cpp>
-#include <Ethernet.cpp>
-#include <EthernetClient.cpp>
-#include <EthernetServer.cpp>
-#include <EthernetUdp.cpp>

Repetier/libraries/Firmata.cpp

@@ -1 +0,0 @@
-#include <Firmata.cpp>

Repetier/libraries/LiquidCrystal.cpp

@@ -1 +0,0 @@
-#include <LiquidCrystal.cpp>

Repetier/libraries/OBD.cpp

@@ -1 +0,0 @@
-#include <OBD.cpp>

Repetier/libraries/SD.cpp

@@ -1,5 +0,0 @@
-#include <SD.cpp>
-#include <Sd2Card.cpp>
-#include <SdFile.cpp>
-#include <SdVolume.cpp>
-#include <File.cpp>

Repetier/libraries/SPI.cpp

@@ -1 +0,0 @@
-#include <SPI.cpp>

Repetier/libraries/Servo.cpp

@@ -1 +0,0 @@
-#include <Servo.cpp>

Repetier/libraries/SoftwareSerial.cpp

@@ -1 +0,0 @@
-#include <SoftwareSerial.cpp>

Repetier/libraries/Stepper.cpp

@@ -1 +0,0 @@
-#include <Stepper.cpp>

Repetier/libraries/TinyGPS.cpp

@@ -1 +0,0 @@
-#include <TinyGPS.cpp>

Repetier/libraries/U8gui.cpp

@@ -1 +0,0 @@
-#include <U8glib.cpp>

Repetier/libraries/WiFi.cpp

@@ -1,7 +0,0 @@
-#include <server_drv.cpp>
-#include <socket.cpp>
-#include <spi_drv.cpp>
-#include <wifi_drv.cpp>
-#include <WiFi.cpp>
-#include <WiFiClient.cpp>
-#include <WiFiServer.cpp>

Repetier/libraries/Wire.cpp

@@ -1,2 +0,0 @@
-#include <twi.c>
-#include <Wire.cpp>

Repetier/libraries/twi.c

@@ -1 +0,0 @@
-#include <twi.c>

Repetier/logo.h

@@ -3,6 +3,7 @@
 // http://en.radzio.dxp.pl/bitmap_converter/
 //------------------------------------------------------------------------------
 
+#ifndef CUSTOM_LOGO
 #define LOGO_WIDTH   60
 #define LOGO_HEIGHT  64
 
@@ -39,41 +40,7 @@ const unsigned char logo[] PROGMEM = { //AVR-GCC, WinAVR
 0x00, 0x07, 0xFF, 0xFF, 0xF8, 0x7E, 0x00, 0x00, 0x00, 0x00, 0x07, 0xFF, 0xFF, 0xFC, 0x00, 0x00,
 0x00, 0x00, 0x00, 0x03, 0xFF, 0xF8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0D, 0xF8, 0x00, 0x00,
 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
-/*
-0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0x0F,
-0xFF, 0xFF, 0xF7, 0x83, 0xC1, 0xF0, 0x1E, 0x0F, 0xFF, 0xFF, 0x7C, 0x0F, 0x07, 0xC0, 0x78, 0x0F,
-0xFF, 0xFD, 0xE0, 0x00, 0x00, 0x01, 0xE0, 0x3F, 0xFF, 0xDF, 0x80, 0x00, 0x00, 0x07, 0xC0, 0x7F,
-0xFE, 0x3F, 0xFF, 0xFF, 0xFF, 0xDF, 0x01, 0xFF, 0xF8, 0x00, 0x00, 0x0B, 0xFF, 0xFC, 0x03, 0xFF,
-0xF0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0F, 0xFF, 0xF0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1F, 0xFF,
-0xF0, 0x50, 0x00, 0x00, 0x00, 0x00, 0x3F, 0xFF, 0xF1, 0xFF, 0xFF, 0xFF, 0xD0, 0x00, 0x7F, 0x7F,
-0xF9, 0xFF, 0xFF, 0xFF, 0xFF, 0xE0, 0x7E, 0x7F, 0xF3, 0xFF, 0xFF, 0xFF, 0xFF, 0xF0, 0xFC, 0x7F,
-0xF9, 0xFF, 0xFF, 0xFF, 0xFF, 0xF0, 0xF8, 0x3F, 0xF1, 0xEF, 0xFF, 0xFF, 0xFF, 0xF0, 0xF0, 0x3F,
-0xF9, 0xE0, 0x00, 0x0F, 0xFF, 0xF0, 0xE0, 0x3F, 0xF1, 0xE0, 0x00, 0x00, 0xFF, 0xF8, 0xE0, 0x3F,
-0xF9, 0xE0, 0x00, 0x00, 0x3F, 0xF0, 0xE3, 0x3F, 0xF1, 0xE0, 0x00, 0x00, 0x1F, 0xF8, 0xE3, 0x7F,
-0xF9, 0xE0, 0x00, 0x00, 0x0F, 0xF0, 0xE7, 0x3F, 0xF1, 0xE0, 0x00, 0x00, 0x0F, 0xF8, 0xE7, 0x7F,
-0xF9, 0xE0, 0x08, 0x00, 0x0F, 0xF0, 0xE7, 0x7F, 0xF1, 0xE0, 0x0F, 0xE0, 0x07, 0xF8, 0xE7, 0x7F,
-0xF9, 0xE0, 0x0F, 0xE0, 0x07, 0xF0, 0xE7, 0x7F, 0xF1, 0xE0, 0x0F, 0xF0, 0x07, 0xF8, 0xE6, 0x7F,
-0xF9, 0xE0, 0x0F, 0xF0, 0x07, 0xF0, 0xE0, 0x7F, 0xF9, 0xE0, 0x0F, 0xF0, 0x07, 0xF8, 0xE0, 0xFF,
-0xF9, 0xE0, 0x0F, 0xE0, 0x07, 0xF0, 0xE0, 0xFF, 0xF9, 0xE0, 0x00, 0x00, 0x07, 0xF8, 0xE1, 0xFF,
-0xF9, 0xE0, 0x00, 0x00, 0x0F, 0xF0, 0xE3, 0xFF, 0xF9, 0xE0, 0x00, 0x00, 0x0F, 0xF8, 0xE3, 0xFF,
-0xF9, 0xE0, 0x00, 0x00, 0x1F, 0xF8, 0xE7, 0xFF, 0xF9, 0xE0, 0x00, 0x00, 0x3F, 0xF8, 0xE7, 0xFF,
-0xF9, 0xE0, 0x00, 0x01, 0xFF, 0xF8, 0xE7, 0xFF, 0xF9, 0xE0, 0x0C, 0x01, 0xFF, 0xF8, 0xE7, 0xFF,
-0xF9, 0xE0, 0x0E, 0x00, 0x7F, 0xF8, 0xE7, 0xFF, 0xF9, 0xE0, 0x0F, 0x00, 0x7F, 0xF8, 0xE7, 0xFF,
-0xF9, 0xE0, 0x0F, 0x00, 0x3F, 0xF8, 0xE7, 0xFF, 0xF9, 0xE0, 0x0F, 0x80, 0x1F, 0xF8, 0xE7, 0xFF,
-0xF9, 0xE0, 0x0F, 0x80, 0x1F, 0xF8, 0xE7, 0xFF, 0xF9, 0xE0, 0x0F, 0xC0, 0x0F, 0xF8, 0xE7, 0xFF,
-0xF9, 0xE0, 0x0F, 0xC0, 0x0F, 0xF8, 0xE7, 0xFF, 0xF9, 0xE0, 0x0F, 0xE0, 0x07, 0xF8, 0xEF, 0xFF,
-0xF9, 0xF0, 0x0F, 0xE0, 0x07, 0xF8, 0xEF, 0xFF, 0xF9, 0xE0, 0x0F, 0xF0, 0x03, 0xF8, 0xFF, 0xFF,
-0xF9, 0xF0, 0x0F, 0xF0, 0x03, 0xF8, 0xFF, 0xFF, 0xF9, 0xFE, 0x0F, 0xF8, 0x03, 0xF8, 0xFF, 0xFF,
-0xF9, 0xFF, 0xFF, 0xF8, 0x01, 0xF8, 0xFF, 0xFF, 0xF8, 0xFF, 0xFF, 0xFF, 0x81, 0xF8, 0xFF, 0xFF,
-0xF8, 0xFF, 0xFF, 0xFF, 0xFF, 0xF8, 0xFF, 0xFF, 0xF8, 0x7F, 0xFF, 0xFF, 0xFF, 0xF8, 0xFF, 0xFF,
-0xF8, 0x00, 0xFF, 0xFF, 0xFF, 0xF8, 0xDF, 0xFF, 0xF8, 0x00, 0x00, 0xFF, 0xFF, 0xF8, 0x7F, 0xFF,
-0xFF, 0x40, 0x00, 0x00, 0xFF, 0xF0, 0x3F, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0xC0, 0x7F, 0xFF,
-0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x7F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0x80, 0x00, 0xFF, 0xFF,
-0xFF, 0xFF, 0xFF, 0xFF, 0x7F, 0x40, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFA, 0xAF, 0xFF, 0xFF, 0xFF,
-0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F, 0xFF, 0xFF, 0xFF
-*/
 };
-
+#else
-
+LOGO_BITMAP
-
+#endif

Repetier/motion.cpp

@@ -75,11 +75,11 @@ int maxadv = 0;
 int maxadv2 = 0;
 float maxadvspeed = 0;
 #endif
-uint8_t pwm_pos[NUM_EXTRUDER+3]; // 0-NUM_EXTRUDER = Heater 0-NUM_EXTRUDER of extruder, NUM_EXTRUDER = Heated bed, NUM_EXTRUDER+1 Board fan, NUM_EXTRUDER+2 = Fan
+uint8_t pwm_pos[NUM_PWM]; // 0-NUM_EXTRUDER = Heater 0-NUM_EXTRUDER of extruder, NUM_EXTRUDER = Heated bed, NUM_EXTRUDER+1 Board fan, NUM_EXTRUDER+2 = Fan
 volatile int waitRelax = 0; // Delay filament relax at the end of print, could be a simple timeout
 
 PrintLine PrintLine::lines[PRINTLINE_CACHE_SIZE]; ///< Cache for print moves.
-PrintLine *PrintLine::cur = 0;               ///< Current printing line
+PrintLine *PrintLine::cur = NULL;               ///< Current printing line
 #if CPU_ARCH == ARCH_ARM
 volatile bool PrintLine::nlFlag = false;
 #endif
@@ -90,7 +90,7 @@ ufast8_t PrintLine::linesPos = 0;                 ///< Position for executing li
 /**
 Move printer the given number of steps. Puts the move into the queue. Used by e.g. homing commands.
 */
-void PrintLine::moveRelativeDistanceInSteps(int32_t x, int32_t y, int32_t z, int32_t e, float feedrate, bool waitEnd, bool checkEndstop)
+void PrintLine::moveRelativeDistanceInSteps(int32_t x, int32_t y, int32_t z, int32_t e, float feedrate, bool waitEnd, bool checkEndstop,bool pathOptimize)
 {
 #if NUM_EXTRUDER > 0
     if(Printer::debugDryrun() || (MIN_EXTRUDER_TEMP > 30 && Extruder::current->tempControl.currentTemperatureC < MIN_EXTRUDER_TEMP && !Printer::isColdExtrusionAllowed()))
@@ -103,12 +103,12 @@ void PrintLine::moveRelativeDistanceInSteps(int32_t x, int32_t y, int32_t z, int
     Printer::destinationSteps[E_AXIS] = Printer::currentPositionSteps[E_AXIS] + e;
     Printer::feedrate = feedrate;
 #if NONLINEAR_SYSTEM
-    if (!queueDeltaMove(checkEndstop, false, false))
+    if (!queueDeltaMove(checkEndstop, pathOptimize, false))
     {
         Com::printWarningFLN(PSTR("moveRelativeDistanceInSteps / queueDeltaMove returns error"));
     }
 #else
-    queueCartesianMove(checkEndstop, false);
+    queueCartesianMove(checkEndstop, pathOptimize);
 #endif
     Printer::feedrate = savedFeedrate;
     Printer::updateCurrentPosition(false);
@@ -117,7 +117,7 @@ void PrintLine::moveRelativeDistanceInSteps(int32_t x, int32_t y, int32_t z, int
     previousMillisCmd = HAL::timeInMilliseconds();
 }
 
-void PrintLine::moveRelativeDistanceInStepsReal(int32_t x, int32_t y, int32_t z, int32_t e, float feedrate, bool waitEnd)
+void PrintLine::moveRelativeDistanceInStepsReal(int32_t x, int32_t y, int32_t z, int32_t e, float feedrate, bool waitEnd,bool pathOptimize)
 {
     Printer::lastCmdPos[X_AXIS] += x * Printer::invAxisStepsPerMM[X_AXIS];
     Printer::lastCmdPos[Y_AXIS] += y * Printer::invAxisStepsPerMM[Y_AXIS];
@@ -131,7 +131,7 @@ void PrintLine::moveRelativeDistanceInStepsReal(int32_t x, int32_t y, int32_t z,
         e = 0; // should not be allowed for current temperature
 #endif
     Printer::moveToReal(Printer::lastCmdPos[X_AXIS], Printer::lastCmdPos[Y_AXIS], Printer::lastCmdPos[Z_AXIS],
-                        (Printer::currentPositionSteps[E_AXIS] + e) * Printer::invAxisStepsPerMM[E_AXIS],feedrate);
+                        (Printer::currentPositionSteps[E_AXIS] + e) * Printer::invAxisStepsPerMM[E_AXIS],feedrate,pathOptimize);
     Printer::updateCurrentPosition();
     if(waitEnd)
         Commands::waitUntilEndOfAllMoves();
@@ -139,6 +139,130 @@ void PrintLine::moveRelativeDistanceInStepsReal(int32_t x, int32_t y, int32_t z,
 }
 
 #if !NONLINEAR_SYSTEM
+#if DISTORTION_CORRECTION
+	/* Special version which adds distortion correction to z. Gets called from queueCartesianMove if needed. */
+	void PrintLine::queueCartesianSegmentTo(uint8_t check_endstops, uint8_t pathOptimize) {
+	
+	// Correct the bumps	
+	Printer::zCorrectionStepsIncluded = Printer::distortion.correct(Printer::destinationSteps[X_AXIS],Printer::destinationSteps[Y_AXIS],Printer::destinationSteps[Z_AXIS]);	
+	Printer::destinationSteps[Z_AXIS] += Printer::zCorrectionStepsIncluded;
+#if DEBUG_DISTORTION	
+	Com::printF(PSTR("zCorr:"),Printer::zCorrectionStepsIncluded*Printer::invAxisStepsPerMM[Z_AXIS],3);
+	Com::printF(PSTR(" atX:"),Printer::destinationSteps[0]*Printer::invAxisStepsPerMM[X_AXIS]);	
+	Com::printFLN(PSTR(" atY:"),Printer::destinationSteps[1]*Printer::invAxisStepsPerMM[Y_AXIS]);
+#endif	
+    PrintLine::waitForXFreeLines(1);
+    uint8_t newPath = PrintLine::insertWaitMovesIfNeeded(pathOptimize, 0);
+    PrintLine *p = PrintLine::getNextWriteLine();
+
+    float axis_diff[E_AXIS_ARRAY]; // Axis movement in mm
+    p->flags = (check_endstops ? FLAG_CHECK_ENDSTOPS : 0);
+    #if MIXING_EXTRUDER
+    if(Printer::isAllEMotors()) {
+	    p->flags |= FLAG_ALL_E_MOTORS;
+    }
+    #endif
+    p->joinFlags = 0;
+    if(!pathOptimize) p->setEndSpeedFixed(true);
+    p->dir = 0;
+    Printer::constrainDestinationCoords();
+    //Find direction
+    Printer::zCorrectionStepsIncluded = 0;
+    for(uint8_t axis = 0; axis < 4; axis++)
+    {
+	    p->delta[axis] = Printer::destinationSteps[axis] - Printer::currentPositionSteps[axis];
+	    p->secondSpeed = Printer::fanSpeed;
+	    if(axis == E_AXIS)
+	    {
+		    if(Printer::mode == PRINTER_MODE_FFF)
+		    {
+			    Printer::extrudeMultiplyError += (static_cast<float>(p->delta[E_AXIS]) * Printer::extrusionFactor);
+			    p->delta[E_AXIS] = static_cast<int32_t>(Printer::extrudeMultiplyError);
+			    Printer::extrudeMultiplyError -= p->delta[E_AXIS];
+			    Printer::filamentPrinted += p->delta[E_AXIS] * Printer::invAxisStepsPerMM[axis];
+		    }
+		    #if defined(SUPPORT_LASER) && SUPPORT_LASER
+		    else if(Printer::mode == PRINTER_MODE_LASER)
+		    {
+			    p->secondSpeed = ((p->delta[X_AXIS] != 0 || p->delta[Y_AXIS] != 0) && (LaserDriver::laserOn || p->delta[E_AXIS] != 0) ? LaserDriver::intensity : 0);
+			    p->delta[E_AXIS] = 0;
+		    }
+		    #endif
+	    }
+	    if(p->delta[axis] >= 0)
+	    p->setPositiveDirectionForAxis(axis);
+	    else
+	    p->delta[axis] = -p->delta[axis];
+	    axis_diff[axis] = p->delta[axis] * Printer::invAxisStepsPerMM[axis];
+	    if(p->delta[axis]) p->setMoveOfAxis(axis);
+	    Printer::currentPositionSteps[axis] = Printer::destinationSteps[axis];
+    }
+    if(p->isNoMove())
+    {
+	    if(newPath)   // need to delete dummy elements, otherwise commands can get locked.
+	    PrintLine::resetPathPlanner();
+	    return; // No steps included
+    }
+    float xydist2;
+    #if ENABLE_BACKLASH_COMPENSATION
+    if((p->isXYZMove()) && ((p->dir & XYZ_DIRPOS)^(Printer::backlashDir & XYZ_DIRPOS)) & (Printer::backlashDir >> 3))   // We need to compensate backlash, add a move
+    {
+	    PrintLine::waitForXFreeLines(2);
+	    uint8_t wpos2 = PrintLine::linesWritePos + 1;
+	    if(wpos2 >= PRINTLINE_CACHE_SIZE) wpos2 = 0;
+	    PrintLine *p2 = &PrintLine::lines[wpos2];
+	    memcpy(p2,p,sizeof(PrintLine)); // Move current data to p2
+	    uint8_t changed = (p->dir & XYZ_DIRPOS)^(Printer::backlashDir & XYZ_DIRPOS);
+	    float back_diff[4]; // Axis movement in mm
+	    back_diff[E_AXIS] = 0;
+	    back_diff[X_AXIS] = (changed & 1 ? (p->isXPositiveMove() ? Printer::backlashX : -Printer::backlashX) : 0);
+	    back_diff[Y_AXIS] = (changed & 2 ? (p->isYPositiveMove() ? Printer::backlashY : -Printer::backlashY) : 0);
+	    back_diff[Z_AXIS] = (changed & 4 ? (p->isZPositiveMove() ? Printer::backlashZ : -Printer::backlashZ) : 0);
+	    p->dir &= XYZ_DIRPOS; // x,y and z are already correct
+	    for(uint8_t i = 0; i < 4; i++)
+	    {
+		    float f = back_diff[i]*Printer::axisStepsPerMM[i];
+		    p->delta[i] = abs((long)f);
+		    if(p->delta[i]) p->dir |= XSTEP << i;
+	    }
+	    //Define variables that are needed for the Bresenham algorithm. Please note that  Z is not currently included in the Bresenham algorithm.
+	    if(p->delta[Y_AXIS] > p->delta[X_AXIS] && p->delta[Y_AXIS] > p->delta[Z_AXIS]) p->primaryAxis = Y_AXIS;
+	    else if (p->delta[X_AXIS] > p->delta[Z_AXIS] ) p->primaryAxis = X_AXIS;
+	    else p->primaryAxis = Z_AXIS;
+	    p->stepsRemaining = p->delta[p->primaryAxis];
+	    //Feedrate calc based on XYZ travel distance
+	    xydist2 = back_diff[X_AXIS] * back_diff[X_AXIS] + back_diff[Y_AXIS] * back_diff[Y_AXIS];
+	    if(p->isZMove())
+	    p->distance = sqrt(xydist2 + back_diff[Z_AXIS] * back_diff[Z_AXIS]);
+	    else
+	    p->distance = sqrt(xydist2);
+	    // 56 seems to be xstep|ystep|e_posdir which just seems odd
+	    Printer::backlashDir = (Printer::backlashDir & 56) | (p2->dir & XYZ_DIRPOS);
+	    p->calculateMove(back_diff,pathOptimize);
+	    p = p2; // use saved instance for the real move
+    }
+    #endif
+
+    //Define variables that are needed for the Bresenham algorithm. Please note that  Z is not currently included in the Bresenham algorithm.
+    if(p->delta[Y_AXIS] > p->delta[X_AXIS] && p->delta[Y_AXIS] > p->delta[Z_AXIS] && p->delta[Y_AXIS] > p->delta[E_AXIS]) p->primaryAxis = Y_AXIS;
+    else if (p->delta[X_AXIS] > p->delta[Z_AXIS] && p->delta[X_AXIS] > p->delta[E_AXIS]) p->primaryAxis = X_AXIS;
+    else if (p->delta[Z_AXIS] > p->delta[E_AXIS]) p->primaryAxis = Z_AXIS;
+    else p->primaryAxis = E_AXIS;
+    p->stepsRemaining = p->delta[p->primaryAxis];
+    if(p->isXYZMove())
+    {
+	    xydist2 = axis_diff[X_AXIS] * axis_diff[X_AXIS] + axis_diff[Y_AXIS] * axis_diff[Y_AXIS];
+	    if(p->isZMove())
+	    p->distance = RMath::max((float)sqrt(xydist2 + axis_diff[Z_AXIS] * axis_diff[Z_AXIS]),fabs(axis_diff[E_AXIS]));
+	    else
+	    p->distance = RMath::max((float)sqrt(xydist2),fabs(axis_diff[E_AXIS]));
+    }
+    else
+    p->distance = fabs(axis_diff[E_AXIS]);
+    p->calculateMove(axis_diff,pathOptimize);
+		
+	}
+#endif
 /**
   Put a move to the current destination coordinates into the movement cache.
   If the cache is full, the method will wait, until a place gets free. During
@@ -148,28 +272,75 @@ void PrintLine::moveRelativeDistanceInStepsReal(int32_t x, int32_t y, int32_t z,
 void PrintLine::queueCartesianMove(uint8_t check_endstops, uint8_t pathOptimize)
 {
     Printer::unsetAllSteppersDisabled();
+#if DISTORTION_CORRECTION
+	if(Printer::distortion.isEnabled() && Printer::destinationSteps[Z_AXIS] < Printer::distortion.zMaxSteps() && Printer::isZProbingActive() == false && !Printer::isHoming()) {
+		// we are inside correction height so we split all moves in lines of max. 10 mm and add them
+		// including a z correction
+		int32_t deltas[E_AXIS_ARRAY],start[E_AXIS_ARRAY];
+		for(fast8_t i = 0;i < E_AXIS_ARRAY;i++) {
+			deltas[i] = Printer::destinationSteps[i] - Printer::currentPositionSteps[i];
+			start[i] = Printer::currentPositionSteps[i];
+		}
+		float dx = Printer::invAxisStepsPerMM[X_AXIS] * deltas[X_AXIS];
+		float dy = Printer::invAxisStepsPerMM[Y_AXIS] * deltas[Y_AXIS];
+		float len = dx * dx + dy * dy;
+		if(len < 100) { // no splitting required
+			queueCartesianSegmentTo(check_endstops, pathOptimize);
+			return;
+		}
+		// we need to split longer lines to follow bed curvature
+		len = sqrt(len);
+		int segments = (static_cast<int>(len) + 9) / 10;		
+#if DEBUG_DISTORTION
+		Com::printF(PSTR("Split line len:"),len);Com::printFLN(PSTR(" segments:"),segments);
+#endif		
+		for(int i = 1; i <= segments; i++) {
+			for(fast8_t j = 0; j < E_AXIS_ARRAY; j++) {
+				Printer::destinationSteps[j] = start[j] + (i * deltas[j]) / segments;
+			}
+			queueCartesianSegmentTo(check_endstops, pathOptimize);
+		}
+		return;
+	}	
+#endif
     waitForXFreeLines(1);
     uint8_t newPath = insertWaitMovesIfNeeded(pathOptimize, 0);
     PrintLine *p = getNextWriteLine();
 
     float axis_diff[E_AXIS_ARRAY]; // Axis movement in mm
-    if(check_endstops) p->flags = FLAG_CHECK_ENDSTOPS;
+    p->flags = (check_endstops ? FLAG_CHECK_ENDSTOPS : 0);
-    else p->flags = 0;
+#if MIXING_EXTRUDER
+    if(Printer::isAllEMotors()) {
+        p->flags |= FLAG_ALL_E_MOTORS;
+    }
+#endif
     p->joinFlags = 0;
     if(!pathOptimize) p->setEndSpeedFixed(true);
     p->dir = 0;
     Printer::constrainDestinationCoords();
     //Find direction
+	Printer::zCorrectionStepsIncluded = 0;
     for(uint8_t axis = 0; axis < 4; axis++)
     {
         p->delta[axis] = Printer::destinationSteps[axis] - Printer::currentPositionSteps[axis];
+        p->secondSpeed = Printer::fanSpeed;
         if(axis == E_AXIS)
+        {
+            if(Printer::mode == PRINTER_MODE_FFF)
             {
                 Printer::extrudeMultiplyError += (static_cast<float>(p->delta[E_AXIS]) * Printer::extrusionFactor);
                 p->delta[E_AXIS] = static_cast<int32_t>(Printer::extrudeMultiplyError);
                 Printer::extrudeMultiplyError -= p->delta[E_AXIS];
                 Printer::filamentPrinted += p->delta[E_AXIS] * Printer::invAxisStepsPerMM[axis];
             }
+#if defined(SUPPORT_LASER) && SUPPORT_LASER
+            else if(Printer::mode == PRINTER_MODE_LASER)
+            {
+                p->secondSpeed = ((p->delta[X_AXIS] != 0 || p->delta[Y_AXIS] != 0) && (LaserDriver::laserOn || p->delta[E_AXIS] != 0) ? LaserDriver::intensity : 0);
+                p->delta[E_AXIS] = 0;
+            }
+#endif
+        }
         if(p->delta[axis] >= 0)
             p->setPositiveDirectionForAxis(axis);
         else
@@ -252,17 +423,18 @@ void PrintLine::calculateMove(float axis_diff[], uint8_t pathOptimize)
     long axisInterval[E_AXIS_ARRAY];
 #endif
     float timeForMove = (float)(F_CPU)*distance / (isXOrYMove() ? RMath::max(Printer::minimumSpeed, Printer::feedrate) : Printer::feedrate); // time is in ticks
-    bool critical = Printer::isZProbingActive();
+    //bool critical = Printer::isZProbingActive();
     if(linesCount < MOVE_CACHE_LOW && timeForMove < LOW_TICKS_PER_MOVE)   // Limit speed to keep cache full.
     {
-        //OUT_P_I("L:",lines_count);
+        //Com::printF(PSTR("L:"),(int)linesCount);
+		//Com::printF(PSTR(" Old "),timeForMove);
         timeForMove += (3 * (LOW_TICKS_PER_MOVE - timeForMove)) / (linesCount + 1); // Increase time if queue gets empty. Add more time if queue gets smaller.
-        //OUT_P_F_LN("Slow ",time_for_move);
+        //Com::printFLN(PSTR("Slow "),timeForMove);
-        critical = true;
+        //critical = true;
     }
     timeInTicks = timeForMove;
     UI_MEDIUM; // do check encoder
-    // Compute the solwest allowed interval (ticks/step), so maximum feedrate is not violated
+    // Compute the slowest allowed interval (ticks/step), so maximum feedrate is not violated
     long limitInterval = timeForMove / stepsRemaining; // until not violated by other constraints it is your target speed
     if(isXMove())
     {
@@ -345,14 +517,32 @@ void PrintLine::calculateMove(float axis_diff[], uint8_t pathOptimize)
     // slowest time to accelerate from v0 to limitInterval determines used acceleration
     // t = (v_end-v_start)/a
     float slowest_axis_plateau_time_repro = 1e15; // repro to reduce division Unit: 1/s
-    unsigned long *accel = (isEPositiveMove() ?  Printer::maxPrintAccelerationStepsPerSquareSecond : Printer::maxTravelAccelerationStepsPerSquareSecond);
+    uint32_t *accel = (isEPositiveMove() ?  Printer::maxPrintAccelerationStepsPerSquareSecond : Printer::maxTravelAccelerationStepsPerSquareSecond);
-
+#if defined(INTERPOLATE_ACCELERATION_WITH_Z) && INTERPOLATE_ACCELERATION_WITH_Z != 0
+    uint32_t newAccel[4];
+    float accelFac = 100.0 + (EEPROM::accelarationFactorTop() - 100.0) * Printer::currentPosition[Z_AXIS] / Printer::zLength;
+#if INTERPOLATE_ACCELERATION_WITH_Z == 1 || INTERPOLATE_ACCELERATION_WITH_Z == 3
+    newAccel[X_AXIS] = static_cast<int32_t>(accel[X_AXIS] * accelFac) / 100;
+    newAccel[Y_AXIS] = static_cast<int32_t>(accel[Y_AXIS] * accelFac) / 100;
+#else
+    newAccel[X_AXIS] = accel[X_AXIS];
+    newAccel[Y_AXIS] = accel[Y_AXIS];
+#endif
+#if INTERPOLATE_ACCELERATION_WITH_Z == 2 || INTERPOLATE_ACCELERATION_WITH_Z == 3
+    newAccel[Z_AXIS] = static_cast<int32_t>(accel[Z_AXIS] * accelFac) / 100;
+#else
+    newAccel[Z_AXIS] = accel[Z_AXIS];
+#endif
+    newAccel[E_AXIS] = accel[E_AXIS];
+    accel = newAccel;
+#endif
     for(uint8_t i = 0; i < 4 ; i++)
     {
         if(isMoveOfAxis(i))
             // v = a * t => t = v/a = F_CPU/(c*a) => 1/t = c*a/F_CPU
             slowest_axis_plateau_time_repro = RMath::min(slowest_axis_plateau_time_repro, (float)axisInterval[i] * (float)accel[i]); //  steps/s^2 * step/tick  Ticks/s^2
     }
+
     // Errors for delta move are initialized in timer (except extruder)
 #if !NONLINEAR_SYSTEM
     error[X_AXIS] = error[Y_AXIS] = error[Z_AXIS] = delta[primaryAxis] >> 1;
@@ -482,7 +672,7 @@ void PrintLine::updateTrapezoids()
     // now first points to last segment before the end speed is fixed
     // so start speed is also fixed.
 
-    if(first == linesWritePos)   // Nothing to plan, only new element presend
+    if(first == linesWritePos)   // Nothing to plan, only new element present
     {
         act->block(); // Prevent steppe rinterrupt from using this
         noInts.unprotect();
@@ -521,7 +711,9 @@ void PrintLine::updateTrapezoids()
         act->updateStepsParameter();
         firstLine->unblock();
         return;
-    } else {
+    }
+    else
+    {
         computeMaxJunctionSpeed(previous, act); // Set maximum junction speed if we have a real move before
     }
     // Increase speed if possible neglecting current speed
@@ -554,20 +746,20 @@ Jerk = (1-cos(alpha))*min(v1,v2)
 This sets jerk to 0 on zero angle change.
 
         Old               New
-0<EFBFBD><EFBFBD>:       0               0
+0°:       0               0
-30<EFBFBD><EFBFBD>:     51,8             13.4
+30°:     51,8             13.4
-45<EFBFBD><EFBFBD>:     76.53            29.3
+45°:     76.53            29.3
-90<EFBFBD><EFBFBD>:    141               100
+90°:    141               100
-180<EFBFBD><EFBFBD>:   200               200
+180°:   200               200
 
 
 von 100 auf 200
         Old               New(min)   New(max)
-0<EFBFBD><EFBFBD>:     100               0          0
+0°:     100               0          0
-30<EFBFBD><EFBFBD>:    123,9             13.4       26.8
+30°:    123,9             13.4       26.8
-45<EFBFBD><EFBFBD>:    147.3             29.3       58.6
+45°:    147.3             29.3       58.6
-90<EFBFBD><EFBFBD>:    223               100        200
+90°:    223               100        200
-180<EFBFBD><EFBFBD>:   300               200        400
+180°:   300               200        400
 
 */
 inline void PrintLine::computeMaxJunctionSpeed(PrintLine *previous, PrintLine *current)
@@ -833,10 +1025,13 @@ inline float PrintLine::safeSpeed()
     if(isZMove())
     {
         float mz = Printer::maxZJerk * 0.5;
-        if(isXOrYMove()) {
+        if(isXOrYMove())
+        {
             if(fabs(speedZ) > mz)
                 safe = RMath::min(safe,mz * fullSpeed / fabs(speedZ));
-        } else {
+        }
+        else
+        {
             safe = mz;
         }
     }
@@ -866,6 +1061,7 @@ uint8_t PrintLine::insertWaitMovesIfNeeded(uint8_t pathOptimize, uint8_t waitExt
 {
     if(linesCount == 0 && waitRelax == 0 && pathOptimize)   // First line after some time - warm up needed
     {
+		//return 0;
 #if NONLINEAR_SYSTEM
         uint8_t w = 3;
 #else
@@ -879,12 +1075,13 @@ uint8_t PrintLine::insertWaitMovesIfNeeded(uint8_t pathOptimize, uint8_t waitExt
             p->dir = 0;
             p->setWaitForXLinesFilled(w + waitExtraLines);
 #if NONLINEAR_SYSTEM
-            p->setWaitTicks(50000);
+            p->setWaitTicks(300000);
 #else
-            p->setWaitTicks(25000);
+            p->setWaitTicks(100000);
 #endif // NONLINEAR_SYSTEM
             pushLine();
         }
+		//Com::printFLN(PSTR("InsertWait"));
         return 1;
     }
     return 0;
@@ -1020,7 +1217,7 @@ uint8_t transformCartesianStepsToDeltaSteps(int32_t cartesianPosSteps[], int32_t
                                            + zSteps);
         else
             return 0;
-        if (deltaPosSteps[A_TOWER]< Printer::deltaFloorSafetyMarginSteps) return 0;
+        if (deltaPosSteps[A_TOWER] < Printer::deltaFloorSafetyMarginSteps && !Printer::isZProbingActive()) return 0;
 
         temp = Printer::deltaBPosYSteps - cartesianPosSteps[Y_AXIS];
         opt = Printer::deltaDiagonalStepsSquaredB.f - temp * temp;
@@ -1030,7 +1227,7 @@ uint8_t transformCartesianStepsToDeltaSteps(int32_t cartesianPosSteps[], int32_t
                                            + zSteps);
         else
             return 0;
-        if (deltaPosSteps[B_TOWER]< Printer::deltaFloorSafetyMarginSteps) return 0;
+        if (deltaPosSteps[B_TOWER] < Printer::deltaFloorSafetyMarginSteps && !Printer::isZProbingActive()) return 0;
 
         temp = Printer::deltaCPosYSteps - cartesianPosSteps[Y_AXIS];
         opt = Printer::deltaDiagonalStepsSquaredC.f - temp * temp;
@@ -1040,7 +1237,7 @@ uint8_t transformCartesianStepsToDeltaSteps(int32_t cartesianPosSteps[], int32_t
                                            + zSteps);
         else
             return 0;
-        if (deltaPosSteps[C_TOWER]< Printer::deltaFloorSafetyMarginSteps) return 0;
+        if (deltaPosSteps[C_TOWER] < Printer::deltaFloorSafetyMarginSteps && !Printer::isZProbingActive()) return 0;
 
         return 1;
 #endif
@@ -1213,6 +1410,7 @@ void DeltaSegment::checkEndstops(PrintLine *cur,bool checkall)
 {
     if(Printer::isZProbingActive())
     {
+		Endstops::update();
 #if FEATURE_Z_PROBE
         if(isZNegativeMove() && Endstops::zProbe())
         {
@@ -1241,6 +1439,8 @@ void DeltaSegment::checkEndstops(PrintLine *cur,bool checkall)
     }
     if(checkall)
     {
+		if(!Printer::isZProbingActive())
+			Endstops::update(); // do not test twice
         if(isXPositiveMove() && Endstops::xMax())
         {
 #if DRIVE_SYSTEM == DELTA
@@ -1469,6 +1669,11 @@ inline void PrintLine::queueEMove(int32_t extrudeDiff,uint8_t check_endstops,uin
     float axisDiff[5]; // Axis movement in mm
     if(check_endstops) p->flags = FLAG_CHECK_ENDSTOPS;
     else p->flags = 0;
+#if MIXING_EXTRUDER
+    if(Printer::isAllEMotors()) {
+        p->flags |= FLAG_ALL_E_MOTORS;
+    }
+#endif
     p->joinFlags = 0;
     if(!pathOptimize) p->setEndSpeedFixed(true);
     //Find direction
@@ -1510,10 +1715,13 @@ uint8_t PrintLine::queueDeltaMove(uint8_t check_endstops,uint8_t pathOptimize, u
     //if (softEndstop && Printer::destinationSteps[Z_AXIS] < 0) Printer::destinationSteps[Z_AXIS] = 0; // now constrained at entry level including cylinder test
     int32_t difference[E_AXIS_ARRAY];
     float axis_diff[VIRTUAL_AXIS_ARRAY]; // Axis movement in mm. Virtual axis in 4;
+    uint8_t secondSpeed = Printer::fanSpeed;
     for(fast8_t axis = 0; axis < E_AXIS_ARRAY; axis++)
     {
         difference[axis] = Printer::destinationSteps[axis] - Printer::currentPositionSteps[axis];
         if(axis == E_AXIS)
+        {
+            if(Printer::mode == PRINTER_MODE_FFF)
             {
                 Printer::extrudeMultiplyError += (static_cast<float>(difference[E_AXIS]) * Printer::extrusionFactor);
                 difference[E_AXIS] = static_cast<int32_t>(Printer::extrudeMultiplyError);
@@ -1522,6 +1730,14 @@ uint8_t PrintLine::queueDeltaMove(uint8_t check_endstops,uint8_t pathOptimize, u
                 Printer::filamentPrinted += axis_diff[E_AXIS];
                 axis_diff[E_AXIS] = fabs(axis_diff[E_AXIS]);
             }
+#if defined(SUPPORT_LASER) && SUPPORT_LASER
+            else if(Printer::mode == PRINTER_MODE_LASER)
+            {
+                secondSpeed = ((axis_diff[X_AXIS] != 0 || axis_diff[Y_AXIS] != 0) && (LaserDriver::laserOn || axis_diff[E_AXIS] != 0) ? LaserDriver::intensity : 0);
+                axis_diff[E_AXIS] = 0;
+            }
+#endif
+        }
         else
             axis_diff[axis] = fabs(difference[axis] * Printer::invAxisStepsPerMM[axis]);
     }
@@ -1598,7 +1814,7 @@ uint8_t PrintLine::queueDeltaMove(uint8_t check_endstops,uint8_t pathOptimize, u
     waitForXFreeLines(1);
 
     // Insert dummy moves if necessary
-    // Nead to leave at least one slot open for the first split move
+    // Need to leave at least one slot open for the first split move
     insertWaitMovesIfNeeded(pathOptimize, RMath::min(PRINTLINE_CACHE_SIZE - 4, numLines));
     uint32_t oldEDestination = Printer::destinationSteps[E_AXIS]; // flow and volumetric extrusion changed virtual target
     Printer::currentPositionSteps[E_AXIS] = 0;
@@ -1632,6 +1848,7 @@ uint8_t PrintLine::queueDeltaMove(uint8_t check_endstops,uint8_t pathOptimize, u
         }
 
         p->joinFlags = 0;
+        p->secondSpeed = secondSpeed;
         p->moveID = lastMoveID;
 
         // Only set fixed on last segment
@@ -1639,6 +1856,11 @@ uint8_t PrintLine::queueDeltaMove(uint8_t check_endstops,uint8_t pathOptimize, u
             p->setEndSpeedFixed(true);
 
         p->flags = (check_endstops ? FLAG_CHECK_ENDSTOPS : 0);
+#if MIXING_EXTRUDER
+        if(Printer::isAllEMotors()) {
+            p->flags |= FLAG_ALL_E_MOTORS;
+        }
+#endif
         p->numDeltaSegments = segmentsPerLine;
 
         uint16_t maxDeltaStep = p->calculateDeltaSubSegments(softEndstop);
@@ -1703,7 +1925,7 @@ void PrintLine::arc(float *position, float *target, float *offset, float radius,
     //   plan_set_acceleration_manager_enabled(false); // disable acceleration management for the duration of the arc
     float center_axis0 = position[X_AXIS] + offset[X_AXIS];
     float center_axis1 = position[Y_AXIS] + offset[Y_AXIS];
-    float linear_travel = 0; //target[axis_linear] - position[axis_linear];
+    //float linear_travel = 0; //target[axis_linear] - position[axis_linear];
     float extruder_travel = (Printer::destinationSteps[E_AXIS] - Printer::currentPositionSteps[E_AXIS]) * Printer::invAxisStepsPerMM[E_AXIS];
     float r_axis0 = -offset[0];  // Radius vector from center to current location
     float r_axis1 = -offset[1];
@@ -1716,7 +1938,7 @@ void PrintLine::arc(float *position, float *target, float *offset, float radius,
     */
     // CCW angle between position and target from circle center. Only one atan2() trig computation required.
     float angular_travel = atan2(r_axis0 * rt_axis1 - r_axis1 * rt_axis0, r_axis0 * rt_axis0 + r_axis1 * rt_axis1);
-    if (angular_travel < 0)
+    if ((!isclockwise && angular_travel <= 0.00001) || (isclockwise && angular_travel < -0.000001))
     {
         angular_travel += 2.0f * M_PI;
     }
@@ -1875,7 +2097,7 @@ int32_t PrintLine::bresenhamStep() // Version for delta printer
             //HAL::forbidInterrupts();
             //deltaSegmentCount -= cur->numDeltaSegments; // should always be zero
             removeCurrentLineForbidInterrupt();
-            if(linesCount == 0) UI_STATUS(UI_TEXT_IDLE);
+            if(linesCount == 0) UI_STATUS_F(Com::translatedF(UI_TEXT_IDLE_ID));
             return 1000;
         }
 #endif
@@ -1901,7 +2123,7 @@ int32_t PrintLine::bresenhamStep() // Version for delta printer
         if(Printer::isZProbingActive() && Printer::stepsRemainingAtZHit >= 0)
         {
             removeCurrentLineForbidInterrupt();
-            if(linesCount == 0) UI_STATUS(UI_TEXT_IDLE);
+            if(linesCount == 0) UI_STATUS_F(Com::translatedF(UI_TEXT_IDLE_ID));
             return 1000;
         }
 #endif
@@ -1958,6 +2180,15 @@ int32_t PrintLine::bresenhamStep() // Version for delta printer
         Printer::advanceExecuted = cur->advanceStart;
 #endif
         cur->updateAdvanceSteps(cur->vStart, 0, false);
+#endif
+        if(Printer::mode == PRINTER_MODE_FFF) {
+            Printer::setFanSpeedDirectly(cur->secondSpeed);
+        }
+#if defined(SUPPORT_LASER) && SUPPORT_LASER
+        else if(Printer::mode == PRINTER_MODE_LASER)
+        {
+            LaserDriver::changeIntensity(cur->secondSpeed);
+        }
 #endif
         return Printer::interval; // Wait an other 50% from last step to make the 100% full
     } // End cur=0
@@ -1965,7 +2196,6 @@ int32_t PrintLine::bresenhamStep() // Version for delta printer
 
     if(curd != NULL)
     {
-        Endstops::update();
         curd->checkEndstops(cur,(cur->isCheckEndstops()));
     }
     int maxLoops = (Printer::stepsPerTimerCall <= cur->stepsRemaining ? Printer::stepsPerTimerCall : cur->stepsRemaining);
@@ -2035,6 +2265,15 @@ int32_t PrintLine::bresenhamStep() // Version for delta printer
             {
                 if (cur->numDeltaSegments)
                 {
+                    if(FEATURE_BABYSTEPPING && Printer::zBabystepsMissing/* && curd
+                            && (curd->dir & XYZ_STEP) == XYZ_STEP*/)
+                    {
+                        // execute a extra babystep
+                        //Printer::insertStepperHighDelay();
+                        //Printer::endXYZSteps();
+                        //HAL::delayMicroseconds(STEPPER_HIGH_DELAY + DOUBLE_STEP_DELAY + 1);
+                        Printer::zBabystep();
+                    }
                     // Get the next delta segment
                     curd = &cur->segments[--cur->numDeltaSegments];
 
@@ -2053,48 +2292,6 @@ int32_t PrintLine::bresenhamStep() // Version for delta printer
                     HAL::delayMicroseconds(DIRECTION_DELAY);
 #endif
 
-                    if(FEATURE_BABYSTEPPING && Printer::zBabystepsMissing && curd
-                            && (curd->dir & XYZ_STEP) == XYZ_STEP)
-                    {
-                        // execute a extra babystep
-                        Printer::insertStepperHighDelay();
-                        Printer::endXYZSteps();
-                        HAL::delayMicroseconds(STEPPER_HIGH_DELAY + DOUBLE_STEP_DELAY + 1);
-
-                        if(Printer::zBabystepsMissing > 0)
-                        {
-                            if(curd->dir & X_DIRPOS)
-                                cur->startXStep();
-                            else
-                                cur->error[X_AXIS] += curd_errupd;
-                            if(curd->dir & Y_DIRPOS)
-                                cur->startYStep();
-                            else
-                                cur->error[Y_AXIS] += curd_errupd;
-                            if(curd->dir & Z_DIRPOS)
-                                cur->startZStep();
-                            else
-                                cur->error[Z_AXIS] += curd_errupd;
-                            Printer::zBabystepsMissing--;
-                        }
-                        else
-                        {
-                            if(curd->dir & X_DIRPOS)
-                                cur->error[X_AXIS] += curd_errupd;
-                            else
-                                cur->startXStep();
-                            if(curd->dir & Y_DIRPOS)
-                                cur->error[Y_AXIS] += curd_errupd;
-                            else
-                                cur->startYStep();
-                            if(curd->dir & Z_DIRPOS)
-                                cur->error[Z_AXIS] += curd_errupd;
-                            else
-                                cur->startZStep();
-                            Printer::zBabystepsMissing++;
-                        }
-                        HAL::delayMicroseconds(1);
-                    }
                 }
                 else
                     curd = 0;// Release the last segment
@@ -2196,7 +2393,18 @@ int32_t PrintLine::bresenhamStep() // Version for delta printer
         //deltaSegmentCount -= cur->numDeltaSegments; // should always be zero
         removeCurrentLineForbidInterrupt();
         Printer::disableAllowedStepper();
-        if(linesCount == 0) UI_STATUS(UI_TEXT_IDLE);
+        if(linesCount == 0) {
+            UI_STATUS_F(Com::translatedF(UI_TEXT_IDLE_ID));
+            if(Printer::mode == PRINTER_MODE_FFF) {
+                Printer::setFanSpeedDirectly(Printer::fanSpeed);
+            }
+#if defined(SUPPORT_LASER) && SUPPORT_LASER
+            else if(Printer::mode == PRINTER_MODE_LASER) // Last move disables laser for safety!
+            {
+                LaserDriver::changeIntensity(0);
+            }
+#endif
+        }
         Printer::interval >>= 1; // 50% of time to next call to do cur=0
         DEBUG_MEMORY;
     } // Do even
@@ -2342,16 +2550,26 @@ int32_t PrintLine::bresenhamStep() // version for cartesian printer
         Printer::advanceExecuted = cur->advanceStart;
 #endif
         cur->updateAdvanceSteps(cur->vStart, 0, false);
+#endif
+        if(Printer::mode == PRINTER_MODE_FFF) {
+            Printer::setFanSpeedDirectly(cur->secondSpeed);
+        }
+#if defined(SUPPORT_LASER) && SUPPORT_LASER
+        else if(Printer::mode == PRINTER_MODE_LASER)
+        {
+            LaserDriver::changeIntensity(cur->secondSpeed);
+        }
 #endif
         return Printer::interval; // Wait an other 50% from last step to make the 100% full
     } // End cur=0
-    Endstops::update();
     cur->checkEndstops();
-    fast8_t max_loops = RMath::min((int32_t)Printer::stepsPerTimerCall,cur->stepsRemaining);
+	fast8_t max_loops = Printer::stepsPerTimerCall;
+	if(cur->stepsRemaining < max_loops)
+		max_loops = cur->stepsRemaining;
     for(fast8_t loop = 0; loop < max_loops; loop++)
     {
 #if STEPPER_HIGH_DELAY + DOUBLE_STEP_DELAY > 0
-        if(loop > 0)
+        if(loop)
             HAL::delayMicroseconds(STEPPER_HIGH_DELAY + DOUBLE_STEP_DELAY);
 #endif
         if((cur->error[E_AXIS] -= cur->delta[E_AXIS]) < 0)
@@ -2369,19 +2587,25 @@ int32_t PrintLine::bresenhamStep() // version for cartesian printer
                 Extruder::step();
             cur->error[E_AXIS] += cur_errupd;
         }
+#if CPU_ARCH == ARCH_AVR		
         if(cur->isXMove())
+#endif
             if((cur->error[X_AXIS] -= cur->delta[X_AXIS]) < 0)
             {
                 cur->startXStep();
                 cur->error[X_AXIS] += cur_errupd;
             }
+#if CPU_ARCH == ARCH_AVR
         if(cur->isYMove())
+#endif
             if((cur->error[Y_AXIS] -= cur->delta[Y_AXIS]) < 0)
             {
                 cur->startYStep();
                 cur->error[Y_AXIS] += cur_errupd;
             }
+#if CPU_ARCH == ARCH_AVR
         if(cur->isZMove())
+#endif
             if((cur->error[Z_AXIS] -= cur->delta[Z_AXIS]) < 0)
             {
                 cur->startZStep();
@@ -2401,6 +2625,7 @@ int32_t PrintLine::bresenhamStep() // version for cartesian printer
 #if USE_ADVANCE
         if(!Printer::isAdvanceActivated()) // Use interrupt for movement
 #endif
+		cur->stepsRemaining--;
         Extruder::unstep();
         Printer::endXYZSteps();
     } // for loop
@@ -2464,7 +2689,6 @@ int32_t PrintLine::bresenhamStep() // version for cartesian printer
     Printer::stepsPerTimerCall = 1;
     Printer::interval = cur->fullInterval; // without RAMPS always use full speed
 #endif // RAMP_ACCELERATION    
-    cur->stepsRemaining -= max_loops;
     long interval = Printer::interval;
     if(cur->stepsRemaining <= 0 || cur->isNoMove())   // line finished
     {
@@ -2477,16 +2701,27 @@ int32_t PrintLine::bresenhamStep() // version for cartesian printer
 #endif
         removeCurrentLineForbidInterrupt();
         Printer::disableAllowedStepper();
-        if(linesCount == 0) UI_STATUS(UI_TEXT_IDLE);
+        if(linesCount == 0)
+        {
+            UI_STATUS_F(Com::translatedF(UI_TEXT_IDLE_ID));
+            if(Printer::mode == PRINTER_MODE_FFF) {
+                Printer::setFanSpeedDirectly(Printer::fanSpeed);
+            }
+#if defined(SUPPORT_LASER) && SUPPORT_LASER
+            else if(Printer::mode == PRINTER_MODE_LASER) // Last move disables laser for safety!
+            {
+                LaserDriver::changeIntensity(0);
+            }
+#endif
+        }
         interval = Printer::interval = interval >> 1; // 50% of time to next call to do cur=0
         DEBUG_MEMORY;
     } // Do even
     if(FEATURE_BABYSTEPPING && Printer::zBabystepsMissing)
     {
+		HAL::forbidInterrupts();
         Printer::zBabystep();
     }
     return interval;
 }
 #endif
-
-

Repetier/motion.h

@@ -28,10 +28,10 @@
 #define FLAG_WARMUP 1
 #define FLAG_NOMINAL 2
 #define FLAG_DECELERATING 4
-#define FLAG_ACCELERATION_ENABLED 8
+#define FLAG_ACCELERATION_ENABLED 8 // unused
 #define FLAG_CHECK_ENDSTOPS 16
-#define FLAG_SKIP_ACCELERATING 32
+#define FLAG_ALL_E_MOTORS 32 // For mixed extruder move all motors instead of selected motor
-#define FLAG_SKIP_DEACCELERATING 64
+#define FLAG_SKIP_DEACCELERATING 64 // unused
 #define FLAG_BLOCKED 128
 
 /** Are the step parameter computed */
@@ -174,10 +174,11 @@ public:
     static ufast8_t linesWritePos; // Position where we write the next cached line move
     ufast8_t joinFlags;
     volatile ufast8_t flags;
+    uint8_t secondSpeed; // for laser intensity or fan control
 private:
     fast8_t primaryAxis;
-    int32_t timeInTicks;
     ufast8_t dir;                       ///< Direction of movement. 1 = X+, 2 = Y+, 4= Z+, values can be combined.
+    int32_t timeInTicks;
     int32_t delta[E_AXIS_ARRAY];                  ///< Steps we want to move.
     int32_t error[E_AXIS_ARRAY];                  ///< Error calculation for Bresenham algorithm
     float speedX;                   ///< Speed in x direction at fullInterval in mm/s
@@ -282,6 +283,9 @@ public:
     {
         return flags & FLAG_BLOCKED;
     }
+    inline bool isAllEMotors() {
+        return flags & FLAG_ALL_E_MOTORS;
+    }
     inline bool isCheckEndstops()
     {
         return flags & FLAG_CHECK_ENDSTOPS;
@@ -298,6 +302,7 @@ public:
     {
         if(isCheckEndstops())
         {
+			Endstops::update();
             if(isXNegativeMove() && Endstops::xMin())
                 setXMoveFinished();
             else if(isXPositiveMove() && Endstops::xMax())
@@ -327,11 +332,14 @@ public:
                 }
         }
 #if FEATURE_Z_PROBE
-        else if(Printer::isZProbingActive() && isZNegativeMove() && Endstops::zProbe())
+        else if(Printer::isZProbingActive() && isZNegativeMove()) {
+			Endstops::update();
+			if(Endstops::zProbe())
 			{
 				setZMoveFinished();
 				Printer::stepsRemainingAtZHit = stepsRemaining;
 			}
+        }
 #endif
     }
 
@@ -488,7 +496,7 @@ public:
 #endif
 #endif
     }
-    inline bool moveDecelerating()
+    INLINE bool moveDecelerating()
     {
         if(stepsRemaining <= decelSteps)
         {
@@ -501,17 +509,14 @@ public:
         }
         else return false;
     }
-    inline bool moveAccelerating()
+    INLINE bool moveAccelerating()
     {
         return Printer::stepNumber <= accelSteps;
     }
-    inline void startXStep()
+    INLINE void startXStep()
     {
 #if !(GANTRY)
-        WRITE(X_STEP_PIN,HIGH);
+        Printer::startXStep();
-#if FEATURE_TWO_XSTEPPER
-        WRITE(X2_STEP_PIN,HIGH);
-#endif
 #else
 #if DRIVE_SYSTEM == XY_GANTRY || DRIVE_SYSTEM == XZ_GANTRY
         if(isXPositiveMove())
@@ -541,15 +546,11 @@ public:
 #ifdef DEBUG_STEPCOUNT
         totalStepsRemaining--;
 #endif
-
     }
-    inline void startYStep()
+    INLINE void startYStep()
     {
 #if !(GANTRY) || DRIVE_SYSTEM == ZX_GANTRY || DRIVE_SYSTEM == XZ_GANTRY
-        WRITE(Y_STEP_PIN,HIGH);
+        Printer::startYStep();
-#if FEATURE_TWO_YSTEPPER
-        WRITE(Y2_STEP_PIN,HIGH);
-#endif
 #else
 #if DRIVE_SYSTEM == XY_GANTRY
         if(isYPositiveMove())
@@ -579,17 +580,15 @@ public:
 #ifdef DEBUG_STEPCOUNT
         totalStepsRemaining--;
 #endif
+
     }
-    inline void startZStep()
+    INLINE void startZStep()
     {
 #if !(GANTRY) || DRIVE_SYSTEM == YX_GANTRY || DRIVE_SYSTEM == XY_GANTRY
-        WRITE(Z_STEP_PIN,HIGH);
+        Printer::startZStep();
-#if FEATURE_TWO_ZSTEPPER
-        WRITE(Z2_STEP_PIN,HIGH);
-#endif
 #else
 #if DRIVE_SYSTEM == XZ_GANTRY
-        if(isYPositiveMove())
+        if(isZPositiveMove())
         {
             Printer::motorX++;
             Printer::motorYorZ--;
@@ -601,7 +600,7 @@ public:
         }
 #endif
 #if DRIVE_SYSTEM == ZX_GANTRY
-        if(isYPositiveMove())
+        if(isZPositiveMove())
         {
             Printer::motorX++;
             Printer::motorYorZ++;
@@ -612,26 +611,29 @@ public:
             Printer::motorYorZ--;
         }
 #endif
+#endif
+#ifdef DEBUG_STEPCOUNT
+        totalStepsRemaining--;
 #endif
     }
     void updateStepsParameter();
-    inline float safeSpeed();
+    float safeSpeed();
     void calculateMove(float axis_diff[],uint8_t pathOptimize);
     void logLine();
-    inline long getWaitTicks()
+    INLINE long getWaitTicks()
     {
         return timeInTicks;
     }
-    inline void setWaitTicks(long wait)
+    INLINE void setWaitTicks(long wait)
     {
         timeInTicks = wait;
     }
 
-    static inline bool hasLines()
+    static INLINE bool hasLines()
     {
         return linesCount;
     }
-    static inline void setCurrentLine()
+    static INLINE void setCurrentLine()
     {
         cur = &lines[linesPos];
 #if CPU_ARCH==ARCH_ARM
@@ -639,7 +641,7 @@ public:
 #endif
     }
     // Only called from within interrupts
-    static inline void removeCurrentLineForbidInterrupt()
+    static INLINE void removeCurrentLineForbidInterrupt()
     {
         linesPos++;
         if(linesPos >= PRINTLINE_CACHE_SIZE) linesPos = 0;
@@ -652,7 +654,7 @@ public:
         if(!linesCount)
             Printer::setMenuMode(MENU_MODE_PRINTING, false);
     }
-    static inline void pushLine()
+    static INLINE void pushLine()
     {
         linesWritePos++;
         if(linesWritePos >= PRINTLINE_CACHE_SIZE) linesWritePos = 0;
@@ -676,17 +678,22 @@ public:
     static inline void backwardPlanner(ufast8_t p,ufast8_t last);
     static void updateTrapezoids();
     static uint8_t insertWaitMovesIfNeeded(uint8_t pathOptimize, uint8_t waitExtraLines);
+#if NONLINEAR_SYSTEM == 0
     static void queueCartesianMove(uint8_t check_endstops,uint8_t pathOptimize);
-    static void moveRelativeDistanceInSteps(int32_t x,int32_t y,int32_t z,int32_t e,float feedrate,bool waitEnd,bool check_endstop);
+#if DISTORTION_CORRECTION
-    static void moveRelativeDistanceInStepsReal(int32_t x,int32_t y,int32_t z,int32_t e,float feedrate,bool waitEnd);
+	static void queueCartesianSegmentTo(uint8_t check_endstops, uint8_t pathOptimize);
+#endif
+#endif	
+    static void moveRelativeDistanceInSteps(int32_t x,int32_t y,int32_t z,int32_t e,float feedrate,bool waitEnd,bool check_endstop,bool pathOptimize = true);
+    static void moveRelativeDistanceInStepsReal(int32_t x,int32_t y,int32_t z,int32_t e,float feedrate,bool waitEnd,bool pathOptimize = true);
 #if ARC_SUPPORT
     static void arc(float *position, float *target, float *offset, float radius, uint8_t isclockwise);
 #endif
-    static inline void previousPlannerIndex(ufast8_t &p)
+    static INLINE void previousPlannerIndex(ufast8_t &p)
     {
         p = (p ? p - 1 : PRINTLINE_CACHE_SIZE - 1);
     }
-    static inline void nextPlannerIndex(ufast8_t& p)
+    static INLINE void nextPlannerIndex(ufast8_t& p)
     {
         p = (p == PRINTLINE_CACHE_SIZE - 1 ? 0 : p + 1);
     }
@@ -706,5 +713,3 @@ public:
 
 
 #endif // MOTION_H_INCLUDED
-
-

Repetier/u8glib_ex.h

@@ -116,6 +116,11 @@ ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 */
 
+// these warnings appear and are no problem.
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wunused-variable"
+#pragma GCC diagnostic ignored "-Wunused-parameter"
+
 // ============= u8g.h ====================
 
 /*
@@ -156,6 +161,7 @@ ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef _U8G_H
 #define _U8G_H
 
+
 /* uncomment the following line to support displays larger than 240x240 */
 //#define U8G_16BIT 1
 
@@ -854,6 +860,7 @@ defined(__18CXX) || defined(__PIC32MX)
 #define U8G_SPI_CLK_CYCLE_50NS 1
 #define U8G_SPI_CLK_CYCLE_300NS 2
 #define U8G_SPI_CLK_CYCLE_400NS 3
+#define U8G_SPI_CLK_CYCLE_500NS 4
 #define U8G_SPI_CLK_CYCLE_NONE 255
 
 uint8_t u8g_InitCom(u8g_t *u8g, u8g_dev_t *dev, uint8_t clk_cycle_time);
@@ -6832,8 +6839,8 @@ static void u8g_com_arduino_init_shift_out(uint8_t dataPin, uint8_t clockPin)
 static void u8g_com_arduino_do_shift_out_msb_first(uint8_t val) U8G_NOINLINE;
 static void u8g_com_arduino_do_shift_out_msb_first(uint8_t val)
 {
-  uint8_t cnt = 8;
 /*
+  uint8_t cnt = 8;
   uint8_t bitData = u8g_bitData;
   uint8_t bitNotData = u8g_bitNotData;
   uint8_t bitClock = u8g_bitClock;
@@ -6864,7 +6871,7 @@ static void u8g_com_arduino_do_shift_out_msb_first(uint8_t val)
   U8G_ATOMIC_START();
   #ifdef UI_SPI_MOSI
 
-  for( cnt=0; cnt<8; cnt++ )
+  for(uint8_t cnt=0; cnt<8; cnt++ )
   {
     WRITE(UI_SPI_SCK, LOW);
     WRITE(UI_SPI_MOSI, val&0x80);
@@ -6982,8 +6989,6 @@ static void u8g_com_arduino_do_shift_out_msb_first(uint8_t val)
 
 static void u8g_com_arduino_st7920_write_byte_seq(uint8_t rs, uint8_t *ptr, uint8_t len)
 {
-  uint8_t i;
-
   if ( rs == 0 )
   {
     /* command */
@@ -7010,8 +7015,6 @@ static void u8g_com_arduino_st7920_write_byte_seq(uint8_t rs, uint8_t *ptr, uint
 
 static void u8g_com_arduino_st7920_write_byte(uint8_t rs, uint8_t val)
 {
-  uint8_t i;
-
   if ( rs == 0 )
   {
     /* command */
@@ -9774,7 +9777,11 @@ uint8_t u8g_dev_st7565_nhd_c12864_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, vo
   switch(msg)
   {
     case U8G_DEV_MSG_INIT:
+#if defined(__SAM3X8E__)	
       u8g_InitCom(u8g, dev, U8G_SPI_CLK_CYCLE_400NS);
+#else
+      u8g_InitCom(u8g, dev, U8G_SPI_CLK_CYCLE_400NS);
+#endif
       u8g_WriteEscSeqP(u8g, dev, u8g_dev_st7565_nhd_c12864_init_seq);
       break;
     case U8G_DEV_MSG_STOP:
@@ -10211,6 +10218,10 @@ uint8_t u8g_com_arduino_hw_spi_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void
       {
 	SPI0->SPI_CSR[0] = SPI_CSR_SCBR(34) | 1;
       }
+      else if ( arg_val <= U8G_SPI_CLK_CYCLE_500NS )
+      {
+	      SPI0->SPI_CSR[0] = SPI_CSR_SCBR(42) | 1;
+      }
       else
       {
 	SPI0->SPI_CSR[0] = SPI_CSR_SCBR(84) | 1;
@@ -10699,5 +10710,4 @@ uint8_t u8g_dev_rot270_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg)
 }
 
 
-
+#pragma GCC diagnostic push
-

Repetier/uiconfig.h

@@ -378,7 +378,7 @@ void uiInitKeys() {
 //  UI_KEYS_INIT_MATRIX(32,47,45,43,41,39,37,35);
 #endif
 }
-void uiCheckKeys(int &action) {
+void uiCheckKeys(uint16_t &action) {
 #if UI_HAS_KEYS!=0
 
  //UI_KEYS_CLICKENCODER_LOW_REV(33,31); // click encoder on pins 47 and 45. Phase is connected with gnd for signals.
@@ -402,7 +402,7 @@ inline void uiCheckSlowEncoder() {
     HAL::i2cWrite(0x12); // GIOA
     HAL::i2cStop();
     HAL::i2cStartWait(UI_DISPLAY_I2C_ADDRESS+I2C_READ);
-    unsigned int keymask = HAL::i2cReadAck();
+    uint16_t keymask = HAL::i2cReadAck();
     keymask = keymask + (HAL::i2cReadNak()<<8);
 #endif
   HAL::i2cStop();
@@ -410,7 +410,7 @@ inline void uiCheckSlowEncoder() {
   UI_KEYS_I2C_CLICKENCODER_LOW_REV(_BV(2),_BV(0)); // click encoder on pins 0 and 2. Phase is connected with gnd for signals.
 #endif
 }
-void uiCheckSlowKeys(int &action) {
+void uiCheckSlowKeys(uint16_t &action) {
 #if defined(UI_HAS_I2C_KEYS) && UI_HAS_KEYS!=0
 #if UI_DISPLAY_I2C_CHIPTYPE==0
     HAL::i2cStartWait(UI_I2C_KEY_ADDRESS+I2C_READ);
@@ -421,7 +421,7 @@ void uiCheckSlowKeys(int &action) {
     HAL::i2cWrite(0x12); // GPIOA
     HAL::i2cStop();
     HAL::i2cStartWait(UI_DISPLAY_I2C_ADDRESS+I2C_READ);
-    unsigned int keymask = HAL::i2cReadAck();
+    uint16_t keymask = HAL::i2cReadAck();
     keymask = keymask + (HAL::i2cReadNak()<<8);
 #endif
     HAL::i2cStop();
@@ -451,5 +451,3 @@ void uiCheckSlowKeys(int &action) {
 
 
 
-
-