Various

Fixed M917
Improved handling of G31 temperature compensation parameters
Added conditional expressions

13 files changed, 300 insertions, 202 deletions

diff --git a/src/Duet3_V06/Pins_Duet3_V06.h b/src/Duet3_V06/Pins_Duet3_V06.h
index 415a0f0b..8061341e 100644
--- a/src/Duet3_V06/Pins_Duet3_V06.h
+++ b/src/Duet3_V06/Pins_Duet3_V06.h
@@ -119,6 +119,8 @@ constexpr Pin TMC51xxMosiPin = PortBPin(4);
 constexpr Pin TMC51xxMisoPin = PortAPin(21);
 constexpr Pin TMC51xxSclkPin = PortAPin(23);
 
+constexpr uint32_t DefaultStandstillCurrentPercent = 71;
+
 // Thermistor/PT1000 inputs
 constexpr Pin TEMP_SENSE_PINS[NumThermistorInputs] = { PortCPin(15), PortCPin(29), PortCPin(30), PortCPin(31) };	// Thermistor/PT1000 pins
 constexpr Pin VssaSensePin = PortCPin(13);
diff --git a/src/DuetM/Pins_DuetM.h b/src/DuetM/Pins_DuetM.h
index 2eb5b8f9..473e07d8 100644
--- a/src/DuetM/Pins_DuetM.h
+++ b/src/DuetM/Pins_DuetM.h
@@ -125,6 +125,7 @@ constexpr uint8_t TMC22xx_UART_PINS = APINS_UART0;
 // In testing I found that 500kbaud was not reliable, so now using 200kbaud.
 constexpr uint32_t DriversBaudRate = 200000;
 constexpr uint32_t TransferTimeout = 10;				// any transfer should complete within 10 ticks @ 1ms/tick
+constexpr uint32_t DefaultStandstillCurrentPercent = 75;
 
 constexpr Pin TMC22xxMuxPins[3] = { PortCPin(14), PortCPin(16), PortCPin(17) };	// Pins that control the UART multiplexer, LSB first
 
diff --git a/src/DuetNG/Pins_DuetNG.h b/src/DuetNG/Pins_DuetNG.h
index 27dcd184..1191ce45 100644
--- a/src/DuetNG/Pins_DuetNG.h
+++ b/src/DuetNG/Pins_DuetNG.h
@@ -136,6 +136,8 @@ constexpr Pin TMC2660MosiPin = PortAPin(22);
 constexpr Pin TMC2660MisoPin = PortAPin(21);
 constexpr Pin TMC2660SclkPin = PortAPin(23);
 
+constexpr uint32_t DefaultStandstillCurrentPercent = 100;					// it's not adjustable on Duet 2
+
 constexpr Pin DueX_SG = PortEPin(0);				// DueX stallguard detect pin = PE0 (was E2_STOP)
 constexpr Pin DueX_INT = PortAPin(17);				// DueX interrupt pin = PA17 (was E6_STOP)
 
diff --git a/src/Endstops/ZProbe.cpp b/src/Endstops/ZProbe.cpp
index 7f223c30..63b22930 100644
--- a/src/Endstops/ZProbe.cpp
+++ b/src/Endstops/ZProbe.cpp
@@ -173,17 +173,8 @@ GCodeResult ZProbe::HandleG31(GCodeBuffer& gb, const StringRef& reply)
 {
 	GCodeResult err = GCodeResult::ok;
 	bool seen = false;
-	const char* axisLetters = reprap.GetGCodes().GetAxisLetters();
-
-	gb.TryGetFValue(axisLetters[X_AXIS], xOffset, seen);
-	gb.TryGetFValue(axisLetters[Y_AXIS], yOffset, seen);
-	gb.TryGetFValue(axisLetters[Z_AXIS], triggerHeight, seen);
-	if (gb.Seen('P'))
-	{
-		seen = true;
-		adcValue = gb.GetIValue();
-	}
 
+	// Do the temperature coefficient first because it may return notFinished
 	if (gb.Seen('H'))
 	{
 		seen = true;
@@ -193,16 +184,51 @@ GCodeResult ZProbe::HandleG31(GCodeBuffer& gb, const StringRef& reply)
 	if (gb.Seen('C'))
 	{
 		seen = true;
+		temperatureCoefficient = gb.GetFValue();
+		calibTemperature = DefaultZProbeTemperature;
+
 		TemperatureError terr;
-		float currentTemperature = reprap.GetHeat().GetSensorTemperature(sensor, terr);
-		if (terr != TemperatureError::success)
+		const float currentTemperature = reprap.GetHeat().GetSensorTemperature(sensor, terr);
+		if (terr == TemperatureError::unknownSensor)
 		{
-			reply.copy("Cannot set a temperature coefficient without a valid heater number");
+			reply.copy("Cannot set a temperature coefficient without a valid sensor number");
+			temperatureCoefficient = 0.0;
 			err = GCodeResult::error;
-			currentTemperature = DefaultZProbeTemperature;
 		}
-		temperatureCoefficient = gb.GetFValue();
-		calibTemperature = (gb.Seen('S')) ? gb.GetFValue() : currentTemperature;
+		else if (gb.Seen('S'))
+		{
+			calibTemperature = gb.GetFValue();
+		}
+		else if (terr == TemperatureError::success)
+		{
+			calibTemperature = currentTemperature;
+		}
+		else if (!gb.IsTimerRunning())				// the sensor may have only just been configured, so give it 500ms to produce a reading
+		{
+			gb.StartTimer();
+			return GCodeResult::notFinished;
+		}
+		else if (millis() - gb.WhenTimerStarted() < 500)
+		{
+			return GCodeResult::notFinished;
+		}
+		else
+		{
+			gb.StopTimer();
+			reply.printf("Sensor %d did not provide a valid temperature reading", sensor);
+			err = GCodeResult::warning;
+		}
+	}
+
+	const char* axisLetters = reprap.GetGCodes().GetAxisLetters();
+
+	gb.TryGetFValue(axisLetters[X_AXIS], xOffset, seen);
+	gb.TryGetFValue(axisLetters[Y_AXIS], yOffset, seen);
+	gb.TryGetFValue(axisLetters[Z_AXIS], triggerHeight, seen);
+	if (gb.Seen('P'))
+	{
+		seen = true;
+		adcValue = gb.GetIValue();
 	}
 
 	if (seen)
diff --git a/src/GCodes/GCodeBuffer/StringParser.cpp b/src/GCodes/GCodeBuffer/StringParser.cpp
index 5867f265..0587ca92 100644
--- a/src/GCodes/GCodeBuffer/StringParser.cpp
+++ b/src/GCodes/GCodeBuffer/StringParser.cpp
@@ -528,13 +528,13 @@ void StringParser::ProcessAbortCommand()
 // Evaluate the condition that should follow 'if' or 'while'
 bool StringParser::EvaluateCondition()
 {
-	ExpressionValue val = ParseExpression(0);
+	ExpressionValue val = ParseExpression(0, true);
 	SkipWhiteSpace();
 	if (gb.buffer[readPointer] != 0)
 	{
 		throw ConstructParseException("unexpected characters following condition");
 	}
-	ConvertToBool(val);
+	ConvertToBool(val, true);
 	return val.bVal;
 }
 
@@ -1360,7 +1360,7 @@ float StringParser::ReadFloatValue()
 	if (gb.buffer[readPointer] == '{')
 	{
 		++readPointer;
-		const ExpressionValue val = ParseBracketedExpression('}');
+		const ExpressionValue val = ParseBracketedExpression('}', true);
 		switch (val.type)
 		{
 		case TYPE_OF(float):
@@ -1388,7 +1388,7 @@ uint32_t StringParser::ReadUIValue()
 	if (gb.buffer[readPointer] == '{')
 	{
 		++readPointer;
-		const ExpressionValue val = ParseBracketedExpression('}');
+		const ExpressionValue val = ParseBracketedExpression('}', true);
 		switch (val.type)
 		{
 		case TYPE_OF(uint32_t):
@@ -1446,7 +1446,7 @@ int32_t StringParser::ReadIValue()
 	if (gb.buffer[readPointer] == '{')
 	{
 		++readPointer;
-		const ExpressionValue val = ParseBracketedExpression('}');
+		const ExpressionValue val = ParseBracketedExpression('}', true);
 		switch (val.type)
 		{
 		case TYPE_OF(int32_t):
@@ -1493,7 +1493,7 @@ DriverId StringParser::ReadDriverIdValue()
 void StringParser::GetStringExpression(const StringRef& str)
 {
 	++readPointer;									// skip the '{'
-	const ExpressionValue val = ParseBracketedExpression('}');
+	const ExpressionValue val = ParseBracketedExpression('}', true);
 	switch (val.type)
 	{
 	case TYPE_OF(const char*):
@@ -1534,9 +1534,9 @@ void StringParser::GetStringExpression(const StringRef& str)
 }
 
 // Evaluate a bracketed expression
-ExpressionValue StringParser::ParseBracketedExpression(char closingBracket)
+ExpressionValue StringParser::ParseBracketedExpression(char closingBracket, bool evaluate)
 {
-	auto rslt = ParseExpression(0);
+	auto rslt = ParseExpression(0, evaluate);
 	if (gb.buffer[readPointer] == closingBracket)
 	{
 		++readPointer;
@@ -1547,11 +1547,11 @@ ExpressionValue StringParser::ParseBracketedExpression(char closingBracket)
 }
 
 // Evaluate an expression, stopping before any binary operators with priority 'priority' or lower
-ExpressionValue StringParser::ParseExpression(uint8_t priority)
+ExpressionValue StringParser::ParseExpression(uint8_t priority, bool evaluate)
 {
 	// Lists of binary operators and their priorities
-	static constexpr const char *operators = "&|=<>+-*/";					// for multi-character operators <= and >= this is the first character
-	static constexpr uint8_t priorities[] = { 1, 1, 2, 2, 2, 3, 3, 4, 4 };
+	static constexpr const char *operators = "?&|=<>+-*/";					// for multi-character operators <= and >= this is the first character
+	static constexpr uint8_t priorities[] = { 1, 2, 2, 3, 3, 3, 4, 4, 5, 5 };
 	constexpr uint8_t UnaryPriority = 5;									// must be higher than any binary operator priority
 	static_assert(ARRAY_SIZE(priorities) == strlen(operators));
 
@@ -1566,7 +1566,7 @@ ExpressionValue StringParser::ParseExpression(uint8_t priority)
 
 	case '-':
 		++readPointer;
-		val = ParseExpression(UnaryPriority);
+		val = ParseExpression(UnaryPriority, evaluate);
 		switch (val.type)
 		{
 		case TYPE_OF(int32_t):
@@ -1584,7 +1584,7 @@ ExpressionValue StringParser::ParseExpression(uint8_t priority)
 
 	case '+':
 		++readPointer;
-		val = ParseExpression(UnaryPriority);
+		val = ParseExpression(UnaryPriority, true);
 		switch (val.type)
 		{
 		case TYPE_OF(uint32_t):
@@ -1604,18 +1604,18 @@ ExpressionValue StringParser::ParseExpression(uint8_t priority)
 
 	case '{':
 		++readPointer;
-		val = ParseBracketedExpression('}');
+		val = ParseBracketedExpression('}', evaluate);
 		break;
 
 	case '(':
 		++readPointer;
-		val = ParseBracketedExpression(')');
+		val = ParseBracketedExpression(')', evaluate);
 		break;
 
 	case '!':
 		++readPointer;
-		val = ParseExpression(UnaryPriority);
-		ConvertToBool(val);
+		val = ParseExpression(UnaryPriority, evaluate);
+		ConvertToBool(val, evaluate);
 		val.bVal = !val.bVal;
 		break;
 
@@ -1626,7 +1626,7 @@ ExpressionValue StringParser::ParseExpression(uint8_t priority)
 		}
 		else if (isalpha(c))				// looks like a variable name
 		{
-			val = ParseIdentifierExpression();
+			val = ParseIdentifierExpression(evaluate);
 		}
 		else
 		{
@@ -1670,181 +1670,224 @@ ExpressionValue StringParser::ParseExpression(uint8_t priority)
 
 		SkipWhiteSpace();
 
-		ExpressionValue val2 = ParseExpression(opPrio);		// get the next operand
-		switch(opChar)
+		// Handle operators that do not always evaluate their second operand
+		switch (opChar)
 		{
-		case '+':
-			BalanceNumericTypes(val, val2);
-			if (val.type == TYPE_OF(float))
-			{
-				val.fVal += val2.fVal;
-			}
-			else
-			{
-				val.iVal += val2.iVal;
-			}
-			break;
-
-		case '-':
-			BalanceNumericTypes(val, val2);
-			if (val.type == TYPE_OF(float))
-			{
-				val.fVal -= val2.fVal;
-			}
-			else
+		case '&':
+			ConvertToBool(val, evaluate);
 			{
-				val.iVal -= val2.iVal;
+				ExpressionValue val2 = ParseExpression(opPrio, evaluate && val.bVal);		// get the next operand
+				if (val.bVal)
+				{
+					ConvertToBool(val2, evaluate);
+					val.bVal = val.bVal && val2.bVal;
+				}
 			}
 			break;
 
-		case '*':
-			BalanceNumericTypes(val, val2);
-			if (val.type == TYPE_OF(float))
-			{
-				val.fVal *= val2.fVal;
-			}
-			else
+		case '|':
+			ConvertToBool(val, evaluate);
 			{
-				val.iVal *= val2.iVal;
+				ExpressionValue val2 = ParseExpression(opPrio, evaluate && !val.bVal);		// get the next operand
+				if (!val.bVal)
+				{
+					ConvertToBool(val2, evaluate);
+					val.bVal = val.bVal || val2.bVal;
+				}
 			}
 			break;
 
-		case '/':
-			ConvertToFloat(val);
-			ConvertToFloat(val2);
-			val.fVal /= val2.fVal;
-			break;
-
-		case '>':
-			BalanceTypes(val, val2);
-			switch (val.type)
+		case '?':
+			ConvertToBool(val, evaluate);
 			{
-			case TYPE_OF(int32_t):
-				val.bVal = (val.iVal > val2.iVal);
-				break;
-
-			case TYPE_OF(float_t):
-				val.bVal = (val.fVal > val2.fVal);
-				break;
-
-			case TYPE_OF(bool):
-				val.bVal = (val.bVal && !val2.bVal);
-				break;
-
-			default:
-				throw ConstructParseException("expected numeric or Boolean operands to comparison operator");
-			}
-			val.type = TYPE_OF(bool);
-			if (invert)
-			{
-				val.bVal = !val.bVal;
+				ExpressionValue val2 = ParseExpression(opPrio, evaluate && val.bVal);		// get the second operand
+				if (gb.buffer[readPointer] != ':')
+				{
+					throw ConstructParseException("expected ':'");
+				}
+				++readPointer;
+				ExpressionValue val3 = ParseExpression(opPrio - 1, evaluate && !val.bVal);	// get the third operand, which may be a further conditional expression
+				return (val.bVal) ? val2 : val3;
 			}
-			break;
-
-		case '<':
-			BalanceTypes(val, val2);
-			switch (val.type)
-			{
-			case TYPE_OF(int32_t):
-				val.bVal = (val.iVal < val2.iVal);
-				break;
 
-			case TYPE_OF(float_t):
-				val.bVal = (val.fVal < val2.fVal);
-				break;
-
-			case TYPE_OF(bool):
-				val.bVal = (!val.bVal && val2.bVal);
-				break;
-
-			default:
-				throw ConstructParseException("expected numeric or Boolean operands to comparison operator");
-			}
-			val.type = TYPE_OF(bool);
-			if (invert)
+		default:
+			// Handle binary operators that always evaluate both operands
 			{
-				val.bVal = !val.bVal;
-			}
-			break;
+				ExpressionValue val2 = ParseExpression(opPrio, evaluate);	// get the next operand
+				switch(opChar)
+				{
+				case '+':
+					BalanceNumericTypes(val, val2, evaluate);
+					if (val.type == TYPE_OF(float))
+					{
+						val.fVal += val2.fVal;
+					}
+					else
+					{
+						val.iVal += val2.iVal;
+					}
+					break;
 
-		case '=':
-			BalanceTypes(val, val2);
-			switch (val.type)
-			{
-			case TYPE_OF(int32_t):
-				val.bVal = (val.iVal == val2.iVal);
-				break;
+				case '-':
+					BalanceNumericTypes(val, val2, evaluate);
+					if (val.type == TYPE_OF(float))
+					{
+						val.fVal -= val2.fVal;
+					}
+					else
+					{
+						val.iVal -= val2.iVal;
+					}
+					break;
 
-			case TYPE_OF(uint32_t):
-				val.bVal = (val.uVal == val2.uVal);
-				break;
+				case '*':
+					BalanceNumericTypes(val, val2, evaluate);
+					if (val.type == TYPE_OF(float))
+					{
+						val.fVal *= val2.fVal;
+					}
+					else
+					{
+						val.iVal *= val2.iVal;
+					}
+					break;
 
-			case TYPE_OF(float_t):
-				val.fVal = (val.fVal == val2.fVal);
-				break;
+				case '/':
+					ConvertToFloat(val, evaluate);
+					ConvertToFloat(val2, evaluate);
+					val.fVal /= val2.fVal;
+					break;
 
-			case TYPE_OF(bool):
-				val.bVal = (val.bVal == val2.bVal);
-				break;
+				case '>':
+					BalanceTypes(val, val2, evaluate);
+					switch (val.type)
+					{
+					case TYPE_OF(int32_t):
+						val.bVal = (val.iVal > val2.iVal);
+						break;
+
+					case TYPE_OF(float_t):
+						val.bVal = (val.fVal > val2.fVal);
+						break;
+
+					case TYPE_OF(bool):
+						val.bVal = (val.bVal && !val2.bVal);
+						break;
+
+					default:
+						throw ConstructParseException("expected numeric or Boolean operands to comparison operator");
+					}
+					val.type = TYPE_OF(bool);
+					if (invert)
+					{
+						val.bVal = !val.bVal;
+					}
+					break;
 
-			case TYPE_OF(const char*):
-				val.bVal = (strcmp(val.sVal, val2.sVal) == 0);
-				break;
+				case '<':
+					BalanceTypes(val, val2, evaluate);
+					switch (val.type)
+					{
+					case TYPE_OF(int32_t):
+						val.bVal = (val.iVal < val2.iVal);
+						break;
+
+					case TYPE_OF(float_t):
+						val.bVal = (val.fVal < val2.fVal);
+						break;
+
+					case TYPE_OF(bool):
+						val.bVal = (!val.bVal && val2.bVal);
+						break;
+
+					default:
+						throw ConstructParseException("expected numeric or Boolean operands to comparison operator");
+					}
+					val.type = TYPE_OF(bool);
+					if (invert)
+					{
+						val.bVal = !val.bVal;
+					}
+					break;
 
-			default:
-				throw ConstructParseException("unexpected operand type to equality operator");
+				case '=':
+					BalanceTypes(val, val2, evaluate);
+					switch (val.type)
+					{
+					case TYPE_OF(int32_t):
+						val.bVal = (val.iVal == val2.iVal);
+						break;
+
+					case TYPE_OF(uint32_t):
+						val.bVal = (val.uVal == val2.uVal);
+						break;
+
+					case TYPE_OF(float_t):
+						val.fVal = (val.fVal == val2.fVal);
+						break;
+
+					case TYPE_OF(bool):
+						val.bVal = (val.bVal == val2.bVal);
+						break;
+
+					case TYPE_OF(const char*):
+						val.bVal = (strcmp(val.sVal, val2.sVal) == 0);
+						break;
+
+					default:
+						throw ConstructParseException("unexpected operand type to equality operator");
+					}
+					val.type = TYPE_OF(bool);
+					break;
+				}
 			}
-			val.type = TYPE_OF(bool);
-			break;
-
-		case '&':
-			ConvertToBool(val);
-			ConvertToBool(val2);
-			val.bVal = val.bVal && val2.bVal;
-			break;
-
-		case '|':
-			ConvertToBool(val);
-			ConvertToBool(val2);
-			val.bVal = val.bVal || val2.bVal;
-			break;
 		}
 	} while (true);
 }
 
-void StringParser::BalanceNumericTypes(ExpressionValue& val1, ExpressionValue& val2)
+void StringParser::BalanceNumericTypes(ExpressionValue& val1, ExpressionValue& val2, bool evaluate)
 {
 	if (val1.type == TYPE_OF(float))
 	{
-		ConvertToFloat(val2);
+		ConvertToFloat(val2, evaluate);
 	}
 	else if (val2.type == TYPE_OF(float))
 	{
-		ConvertToFloat(val1);
+		ConvertToFloat(val1, evaluate);
 	}
 	else if (val1.type != TYPE_OF(int32_t) || val2.type != TYPE_OF(int32_t))
 	{
-		throw ConstructParseException("expected numeric operands");
+		if (evaluate)
+		{
+			throw ConstructParseException("expected numeric operands");
+		}
+		val1.SetInt(0);
+		val2.SetInt(0);
 	}
 }
 
-void StringParser::BalanceTypes(ExpressionValue& val1, ExpressionValue& val2)
+void StringParser::BalanceTypes(ExpressionValue& val1, ExpressionValue& val2, bool evaluate)
 {
 	if (val1.type == TYPE_OF(float))
 	{
-		ConvertToFloat(val2);
+		ConvertToFloat(val2, evaluate);
 	}
 	else if (val2.type == TYPE_OF(float))
 	{
-		ConvertToFloat(val1);
+		ConvertToFloat(val1, evaluate);
 	}
 	else if (val1.type != val2.type)
 	{
-		throw ConstructParseException("cannot convert operands to same type");
+		if (evaluate)
+		{
+			throw ConstructParseException("cannot convert operands to same type");
+		}
+		val1.SetInt(0);
+		val2.SetInt(0);
 	}
 }
 
-void StringParser::EnsureNumeric(ExpressionValue& val)
+void StringParser::EnsureNumeric(ExpressionValue& val, bool evaluate)
 {
 	switch (val.type)
 	{
@@ -1858,11 +1901,15 @@ void StringParser::EnsureNumeric(ExpressionValue& val)
 		break;
 
 	default:
-		throw ConstructParseException("expected numeric operand");
+		if (evaluate)
+		{
+			throw ConstructParseException("expected numeric operand");
+		}
+		val.SetInt(0);
 	}
 }
 
-void StringParser::ConvertToFloat(ExpressionValue& val)
+void StringParser::ConvertToFloat(ExpressionValue& val, bool evaluate)
 {
 	switch (val.type)
 	{
@@ -1875,15 +1922,23 @@ void StringParser::ConvertToFloat(ExpressionValue& val)
 		break;
 
 	default:
-		throw ConstructParseException("expected numeric operand");
+		if (evaluate)
+		{
+			throw ConstructParseException("expected numeric operand");
+		}
+		val.SetFloat(0.0);
 	}
 }
 
-void StringParser::ConvertToBool(ExpressionValue& val)
+void StringParser::ConvertToBool(ExpressionValue& val, bool evaluate)
 {
 	if (val.type != TYPE_OF(bool))
 	{
-		throw ConstructParseException("expected Boolean operand");
+		if (evaluate)
+		{
+			throw ConstructParseException("expected Boolean operand");
+		}
+		val.SetBool(false);
 	}
 }
 
@@ -2014,7 +2069,7 @@ void StringParser::ParseIdentifier(const StringRef& id)
 }
 
 // Parse an identifier expression
-ExpressionValue StringParser::ParseIdentifierExpression()
+ExpressionValue StringParser::ParseIdentifierExpression(bool evaluate)
 {
 	String<MaxVariableNameLength> varName;
 	ParseIdentifier(varName.GetRef());
@@ -2050,7 +2105,7 @@ ExpressionValue StringParser::ParseIdentifierExpression()
 	if (gb.buffer[readPointer] == '(')
 	{
 		// It's a function call
-		ExpressionValue rslt = ParseExpression(0);
+		ExpressionValue rslt = ParseExpression(0, evaluate);
 		if (varName.Equals("abs"))
 		{
 			switch (rslt.type)
@@ -2064,42 +2119,46 @@ ExpressionValue StringParser::ParseIdentifierExpression()
 				break;
 
 			default:
-				throw ConstructParseException("expected numeric operand");
+				if (evaluate)
+				{
+					throw ConstructParseException("expected numeric operand");
+				}
+				rslt.SetInt(0);
 			}
 		}
 		else if (varName.Equals("sin"))
 		{
-			ConvertToFloat(rslt);
+			ConvertToFloat(rslt, evaluate);
 			rslt.fVal = sinf(rslt.fVal);
 		}
 		else if (varName.Equals("cos"))
 		{
-			ConvertToFloat(rslt);
+			ConvertToFloat(rslt, evaluate);
 			rslt.fVal = cosf(rslt.fVal);
 		}
 		else if (varName.Equals("tan"))
 		{
-			ConvertToFloat(rslt);
+			ConvertToFloat(rslt, evaluate);
 			rslt.fVal = tanf(rslt.fVal);
 		}
 		else if (varName.Equals("asin"))
 		{
-			ConvertToFloat(rslt);
+			ConvertToFloat(rslt, evaluate);
 			rslt.fVal = asinf(rslt.fVal);
 		}
 		else if (varName.Equals("acos"))
 		{
-			ConvertToFloat(rslt);
+			ConvertToFloat(rslt, evaluate);
 			rslt.fVal = acosf(rslt.fVal);
 		}
 		else if (varName.Equals("atan"))
 		{
-			ConvertToFloat(rslt);
+			ConvertToFloat(rslt, evaluate);
 			rslt.fVal = atanf(rslt.fVal);
 		}
 		else if (varName.Equals("atan2"))
 		{
-			ConvertToFloat(rslt);
+			ConvertToFloat(rslt, evaluate);
 			SkipWhiteSpace();
 			if (gb.buffer[readPointer] != ',')
 			{
@@ -2107,18 +2166,18 @@ ExpressionValue StringParser::ParseIdentifierExpression()
 			}
 			++readPointer;
 			SkipWhiteSpace();
-			ExpressionValue nextOperand = ParseExpression(0);
-			ConvertToFloat(nextOperand);
+			ExpressionValue nextOperand = ParseExpression(0, evaluate);
+			ConvertToFloat(nextOperand, evaluate);
 			rslt.fVal = atan2f(rslt.fVal, nextOperand.fVal);
 		}
 		else if (varName.Equals("sqrt"))
 		{
-			ConvertToFloat(rslt);
+			ConvertToFloat(rslt, evaluate);
 			rslt.fVal = sqrtf(rslt.fVal);
 		}
 		else if (varName.Equals("isnan"))
 		{
-			ConvertToFloat(rslt);
+			ConvertToFloat(rslt, evaluate);
 			rslt.type = TYPE_OF(bool);
 			rslt.bVal = (isnan(rslt.fVal) != 0);
 		}
@@ -2133,8 +2192,8 @@ ExpressionValue StringParser::ParseIdentifierExpression()
 				}
 				++readPointer;
 				SkipWhiteSpace();
-				ExpressionValue nextOperand = ParseExpression(0);
-				BalanceNumericTypes(rslt, nextOperand);
+				ExpressionValue nextOperand = ParseExpression(0, evaluate);
+				BalanceNumericTypes(rslt, nextOperand, evaluate);
 				if (rslt.type == TYPE_OF(float))
 				{
 					rslt.fVal = max<float>(rslt.fVal, nextOperand.fVal);
@@ -2156,8 +2215,8 @@ ExpressionValue StringParser::ParseIdentifierExpression()
 				}
 				++readPointer;
 				SkipWhiteSpace();
-				ExpressionValue nextOperand = ParseExpression(0);
-				BalanceNumericTypes(rslt, nextOperand);
+				ExpressionValue nextOperand = ParseExpression(0, evaluate);
+				BalanceNumericTypes(rslt, nextOperand, evaluate);
 				if (rslt.type == TYPE_OF(float))
 				{
 					rslt.fVal = min<float>(rslt.fVal, nextOperand.fVal);
diff --git a/src/GCodes/GCodeBuffer/StringParser.h b/src/GCodes/GCodeBuffer/StringParser.h
index 8dfadf30..5cb11a5d 100644
--- a/src/GCodes/GCodeBuffer/StringParser.h
+++ b/src/GCodes/GCodeBuffer/StringParser.h
@@ -112,22 +112,22 @@ private:
 
 	bool EvaluateCondition() THROWS_PARSE_ERROR;
 
-	ExpressionValue ParseBracketedExpression(char closingBracket) THROWS_PARSE_ERROR
+	ExpressionValue ParseBracketedExpression(char closingBracket, bool evaluate) THROWS_PARSE_ERROR
 		pre (readPointer >= 0; gb.buffer[readPointer] == '{');
-	ExpressionValue ParseExpression(uint8_t priority) THROWS_PARSE_ERROR
+	ExpressionValue ParseExpression(uint8_t priority, bool evaluate) THROWS_PARSE_ERROR
 		pre (readPointer >= 0);
 	ExpressionValue ParseNumber() THROWS_PARSE_ERROR
 		pre(readPointer >= 0; isdigit(gb.buffer[readPointer]));
-	ExpressionValue ParseIdentifierExpression() THROWS_PARSE_ERROR
+	ExpressionValue ParseIdentifierExpression(bool evaluate) THROWS_PARSE_ERROR
 		pre(readPointer >= 0; isalpha(gb.buffer[readPointer]));
 	void ParseIdentifier(const StringRef& id) THROWS_PARSE_ERROR
 		pre(readPointer >= 0);
 
-	void BalanceNumericTypes(ExpressionValue& val1, ExpressionValue& val2) THROWS_PARSE_ERROR;
-	void BalanceTypes(ExpressionValue& val1, ExpressionValue& val2) THROWS_PARSE_ERROR;
-	void ConvertToFloat(ExpressionValue& val) THROWS_PARSE_ERROR;
-	void ConvertToBool(ExpressionValue& val) THROWS_PARSE_ERROR;
-	void EnsureNumeric(ExpressionValue& val) THROWS_PARSE_ERROR;
+	void BalanceNumericTypes(ExpressionValue& val1, ExpressionValue& val2, bool evaluate) THROWS_PARSE_ERROR;
+	void BalanceTypes(ExpressionValue& val1, ExpressionValue& val2, bool evaluate) THROWS_PARSE_ERROR;
+	void ConvertToFloat(ExpressionValue& val, bool evaluate) THROWS_PARSE_ERROR;
+	void ConvertToBool(ExpressionValue& val, bool evaluate) THROWS_PARSE_ERROR;
+	void EnsureNumeric(ExpressionValue& val, bool evaluate) THROWS_PARSE_ERROR;
 
 	void SkipWhiteSpace() noexcept;
 
diff --git a/src/Movement/StepperDrivers/TMC22xx.cpp b/src/Movement/StepperDrivers/TMC22xx.cpp
index 3af1c715..ad711502 100644
--- a/src/Movement/StepperDrivers/TMC22xx.cpp
+++ b/src/Movement/StepperDrivers/TMC22xx.cpp
@@ -524,7 +524,7 @@ pre(!driversPowered)
 	enabled = false;
 	registersToUpdate = 0;
 	motorCurrent = 0;
-	standstillCurrentFraction = (256 * 3)/4;							// default to 75%
+	standstillCurrentFraction = (uint8_t)min<uint32_t>((DefaultStandstillCurrentPercent * 256)/100, 255);
 	UpdateRegister(WriteGConf, DefaultGConfReg);
 	UpdateRegister(WriteSlaveConf, DefaultSlaveConfReg);
 	configuredChopConfReg = DefaultChopConfReg;
diff --git a/src/Movement/StepperDrivers/TMC51xx.cpp b/src/Movement/StepperDrivers/TMC51xx.cpp
index c60b8c08..d05bc7a6 100644
--- a/src/Movement/StepperDrivers/TMC51xx.cpp
+++ b/src/Movement/StepperDrivers/TMC51xx.cpp
@@ -408,7 +408,7 @@ pre(!driversPowered)
 	enabled = false;
 	registersToUpdate = newRegistersToUpdate = 0;
 	motorCurrent = 0;
-	standstillCurrentFraction = 181; 									// default to 1/sqrt(2)
+	standstillCurrentFraction = (uint8_t)min<uint32_t>((DefaultStandstillCurrentPercent * 256)/100, 255);
 
 	// Set default values for all registers and flag them to be updated
 	UpdateRegister(WriteGConf, DefaultGConfReg);
diff --git a/src/ObjectModel/ObjectModel.h b/src/ObjectModel/ObjectModel.h
index 56f147d1..c053a594 100644
--- a/src/ObjectModel/ObjectModel.h
+++ b/src/ObjectModel/ObjectModel.h
@@ -67,6 +67,10 @@ struct ExpressionValue
 	constexpr ExpressionValue(float f) noexcept : type(TYPE_OF(float)), fVal(f) { }
 	constexpr ExpressionValue(int32_t i) noexcept : type(TYPE_OF(int32_t)), iVal(i) { }
 	ExpressionValue() noexcept : type(NoType) { }
+
+	void SetBool(bool b) noexcept { type = TYPE_OF(bool); bVal = b; }
+	void SetInt(int32_t i) noexcept { type = TYPE_OF(int32_t); iVal = i; }
+	void SetFloat(float f) noexcept { type = TYPE_OF(float); fVal = f; }
 };
 
 class ObjectModel
diff --git a/src/Pccb/Pins_Pccb.h b/src/Pccb/Pins_Pccb.h
index bec3043d..5aa596be 100644
--- a/src/Pccb/Pins_Pccb.h
+++ b/src/Pccb/Pins_Pccb.h
@@ -155,6 +155,8 @@ constexpr Pin TMC2660MisoPin = PortAPin(12);
 constexpr Pin TMC2660SclkPin = PortAPin(14);
 constexpr Pin GlobalTmc2660EnablePin = PortCPin(16); // The pin that drives ENN of all drivers on the DueX5
 
+constexpr uint32_t DefaultStandstillCurrentPercent = 100;					// it's not adjustable on TMC2660
+
 #elif defined(PCCB_08)
 
 constexpr Pin ENABLE_PINS[NumDirectDrivers] =		{ NoPin,		NoPin,		  PortBPin(14), PortCPin(25), PortCPin( 5), PortCPin(19), PortAPin( 0), PortCPin(28) };
@@ -179,6 +181,8 @@ constexpr uint32_t TransferTimeout = 10;			// any transfer should complete withi
 #define UART_TMC_DRV0_Handler	UART0_Handler
 #define UART_TMC_DRV1_Handler	UART1_Handler
 
+constexpr uint32_t DefaultStandstillCurrentPercent = 75;
+
 #endif
 
 #if defined(PCCB_08) || defined(PCCB_08_X5)
diff --git a/src/Platform.cpp b/src/Platform.cpp
index b8d162de..69c51099 100644
--- a/src/Platform.cpp
+++ b/src/Platform.cpp
@@ -468,7 +468,7 @@ void Platform::Init() noexcept
 		driveDriverBits[drive] = 0;
 		motorCurrents[drive] = 0.0;
 		motorCurrentFraction[drive] = 1.0;
-		standstillCurrentFraction[drive] = 0.75;
+		standstillCurrentPercent[drive] = DefaultStandstillCurrentPercent;
 		microstepping[drive] = 16 | 0x8000;						// x16 with interpolation
 	}
 
@@ -2366,7 +2366,7 @@ bool Platform::SetMotorCurrent(size_t axisOrExtruder, float currentOrPercent, in
 
 #if HAS_SMART_DRIVERS
 	case 917:
-		standstillCurrentFraction[axisOrExtruder] = constrain<float>(0.01 * currentOrPercent, 0.0, 1.0);
+		standstillCurrentPercent[axisOrExtruder] = constrain<float>(currentOrPercent, 0.0, 100.0);
 		break;
 #endif
 
@@ -2383,7 +2383,7 @@ bool Platform::SetMotorCurrent(size_t axisOrExtruder, float currentOrPercent, in
 								if (code == 917)
 								{
 # if HAS_SMART_DRIVERS
-									SmartDrivers::SetStandstillCurrentPercent(driver, standstillCurrentFraction[axisOrExtruder]);
+									SmartDrivers::SetStandstillCurrentPercent(driver, standstillCurrentPercent[axisOrExtruder]);
 # endif
 								}
 								else
@@ -2395,7 +2395,7 @@ bool Platform::SetMotorCurrent(size_t axisOrExtruder, float currentOrPercent, in
 							{
 								if (code == 917)
 								{
-									canDriversToUpdate.AddEntry(driver, (uint16_t)(standstillCurrentFraction[axisOrExtruder] * 100));
+									canDriversToUpdate.AddEntry(driver, (uint16_t)(standstillCurrentPercent[axisOrExtruder]));
 								}
 								else
 								{
@@ -2418,7 +2418,7 @@ bool Platform::SetMotorCurrent(size_t axisOrExtruder, float currentOrPercent, in
 								if (code == 917)
 								{
 # if HAS_SMART_DRIVERS
-									SmartDrivers::SetStandstillCurrentPercent(driver, standstillCurrentFraction[axisOrExtruder]);
+									SmartDrivers::SetStandstillCurrentPercent(driver, standstillCurrentPercent[axisOrExtruder]);
 # endif
 								}
 								else
@@ -2517,7 +2517,7 @@ float Platform::GetMotorCurrent(size_t drive, int code) const noexcept
 
 #if HAS_SMART_DRIVERS
 	case 917:
-		return standstillCurrentFraction[drive];
+		return standstillCurrentPercent[drive];
 #endif
 	default:
 		return 0.0;
diff --git a/src/Platform.h b/src/Platform.h
index 66dba48c..53f0120f 100644
--- a/src/Platform.h
+++ b/src/Platform.h
@@ -598,7 +598,7 @@ private:
 
 	float motorCurrents[MaxAxesPlusExtruders];				// the normal motor current for each stepper driver
 	float motorCurrentFraction[MaxAxesPlusExtruders];		// the percentages of normal motor current that each driver is set to
-	float standstillCurrentFraction[MaxAxesPlusExtruders];	// the percentages of normal motor current that each driver uses when in standstill
+	float standstillCurrentPercent[MaxAxesPlusExtruders];	// the percentages of normal motor current that each driver uses when in standstill
 	uint16_t microstepping[MaxAxesPlusExtruders];			// the microstepping used for each axis or extruder, top bit is set if interpolation enabled
 
 	volatile DriverStatus driverState[MaxAxesPlusExtruders];
diff --git a/src/Version.h b/src/Version.h
index 2c4d4489..a5143696 100644
--- a/src/Version.h
+++ b/src/Version.h
@@ -20,7 +20,7 @@
 #endif
 
 #ifndef DATE
-# define DATE "2020-01-04b2"
+# define DATE "2020-01-05b1"
 #endif
 
 #define AUTHORS "reprappro, dc42, chrishamm, t3p3, dnewman, printm3d"