Work towards v3.3

Introduced new "obsolete" attribute for object model fields
Marked some fields in the object model obsolete
Warnings are now shown when obsolete fields are used
Reduced object model size a bit of grid definitions
Added back some grid properties for backwards-compatibility
Added new o-flag to M409 and rr_model

12 files changed, 224 insertions, 167 deletions

diff --git a/src/Configuration.h b/src/Configuration.h
index dd345363..baad4c8c 100644
--- a/src/Configuration.h
+++ b/src/Configuration.h
@@ -154,23 +154,23 @@ constexpr unsigned int MaxBlockIndent = 10;				// maximum indentation of GCode.
 //   So 32 points using double precision arithmetic need 3584 bytes of stack space.
 #if SAM4E || SAM4S || SAME70 || SAME5x
 constexpr size_t MaxGridProbePoints = 441;				// 441 allows us to probe e.g. 400x400 at 20mm intervals
-constexpr size_t MaxAxis0GridPoints = 41;					// Maximum number of grid points in one X row
+constexpr size_t MaxAxis0GridPoints = 41;				// Maximum number of grid points in one X row
 constexpr size_t MaxProbePoints = 32;					// Maximum number of G30 probe points
 constexpr size_t MaxCalibrationPoints = 32;				// Should a power of 2 for speed
 #elif SAM3XA
 constexpr size_t MaxGridProbePoints = 121;				// 121 allows us to probe 200x200 at 20mm intervals
-constexpr size_t MaxAxis0GridPoints = 21;					// Maximum number of grid points in one X row
+constexpr size_t MaxAxis0GridPoints = 21;				// Maximum number of grid points in one X row
 constexpr size_t MaxProbePoints = 32;					// Maximum number of G30 probe points
 constexpr size_t MaxCalibrationPoints = 32;				// Should a power of 2 for speed
 #elif __LPC17xx__
 # if defined(LPC_NETWORKING)
 constexpr size_t MaxGridProbePoints = 121;    			// 121 allows us to probe 200x200 at 20mm intervals
-constexpr size_t MaxAxis0GridPoints = 21;         			// Maximum number of grid points in one X row
+constexpr size_t MaxAxis0GridPoints = 21;         		// Maximum number of grid points in one X row
 constexpr size_t MaxProbePoints = 32;       			// Maximum number of G30 probe points
 constexpr size_t MaxCalibrationPoints = 16; 			// Should a power of 2 for speed
 # else
 constexpr size_t MaxGridProbePoints = 441;				// 441 allows us to probe e.g. 400x400 at 20mm intervals
-constexpr size_t MaxAxis0GridPoints = 41;					// Maximum number of grid points in one X row
+constexpr size_t MaxAxis0GridPoints = 41;				// Maximum number of grid points in one X row
 constexpr size_t MaxProbePoints = 32;					// Maximum number of G30 probe points
 constexpr size_t MaxCalibrationPoints = 32;				// Should a power of 2 for speed
 # endif
diff --git a/src/Endstops/ZProbe.cpp b/src/Endstops/ZProbe.cpp
index eed8a791..ba9ea24c 100644
--- a/src/Endstops/ZProbe.cpp
+++ b/src/Endstops/ZProbe.cpp
@@ -64,7 +64,7 @@ constexpr ObjectModelTableEntry ZProbe::objectModelTable[] =
 	{ "offsets",					OBJECT_MODEL_FUNC_NOSELF(&offsetsArrayDescriptor), 					ObjectModelEntryFlags::none },
 	{ "recoveryTime",				OBJECT_MODEL_FUNC(self->recoveryTime, 1), 							ObjectModelEntryFlags::none },
 	{ "speed",						OBJECT_MODEL_FUNC(self->probeSpeed, 1), 							ObjectModelEntryFlags::none },
-	{ "temperatureCoefficient",		OBJECT_MODEL_FUNC(self->temperatureCoefficients[0], 5), 			ObjectModelEntryFlags::none },
+	{ "temperatureCoefficient",		OBJECT_MODEL_FUNC(self->temperatureCoefficients[0], 5), 			ObjectModelEntryFlags::obsolete },
 	{ "temperatureCoefficients",	OBJECT_MODEL_FUNC_NOSELF(&temperatureCoefficientsArrayDescriptor), 	ObjectModelEntryFlags::none },
 	{ "threshold",					OBJECT_MODEL_FUNC((int32_t)self->adcValue), 						ObjectModelEntryFlags::none },
 	{ "tolerance",					OBJECT_MODEL_FUNC(self->tolerance, 3), 								ObjectModelEntryFlags::none },
diff --git a/src/GCodes/GCodeBuffer/ExpressionParser.cpp b/src/GCodes/GCodeBuffer/ExpressionParser.cpp
index e33c1ffd..310c58bd 100644
--- a/src/GCodes/GCodeBuffer/ExpressionParser.cpp
+++ b/src/GCodes/GCodeBuffer/ExpressionParser.cpp
@@ -9,6 +9,7 @@
 
 #include "GCodeBuffer.h"
 #include <RepRap.h>
+#include <Platform.h>
 #include <General/NamedEnum.h>
 #include <General/NumericConverter.h>
 
@@ -35,8 +36,20 @@ ExpressionValue ExpressionParser::ParseExpectKet(bool evaluate, char closingBrac
 	return rslt;
 }
 
-// Evaluate an expression, stopping before any binary operators with priority 'priority' or lower
-ExpressionValue ExpressionParser::Parse(bool evaluate, uint8_t priority) THROWS(GCodeException)
+// Evaluate an expression
+ExpressionValue ExpressionParser::Parse(bool evaluate) THROWS(GCodeException)
+{
+	obsoleteField.Clear();
+	ExpressionValue result = ParseInternal(evaluate);
+	if (!obsoleteField.IsEmpty())
+	{
+		reprap.GetPlatform().MessageF(WarningMessage, "obsolete object model field %s queried\n", obsoleteField.c_str());
+	}
+	return result;
+}
+
+// Evaluate an expression internally, stopping before any binary operators with priority 'priority' or lower
+ExpressionValue ExpressionParser::ParseInternal(bool evaluate, uint8_t priority) THROWS(GCodeException)
 {
 	// Lists of binary operators and their priorities
 	static constexpr const char *operators = "?^&|!=<>+-*/";				// for multi-character operators <= and >= and != this is the first character
@@ -57,7 +70,7 @@ ExpressionValue ExpressionParser::Parse(bool evaluate, uint8_t priority) THROWS(
 
 	case '-':
 		AdvancePointer();
-		val = Parse(evaluate, UnaryPriority);
+		val = ParseInternal(evaluate, UnaryPriority);
 		switch (val.GetType())
 		{
 		case TypeCode::Int32:
@@ -75,7 +88,7 @@ ExpressionValue ExpressionParser::Parse(bool evaluate, uint8_t priority) THROWS(
 
 	case '+':
 		AdvancePointer();
-		val = Parse(evaluate, UnaryPriority);
+		val = ParseInternal(evaluate, UnaryPriority);
 		switch (val.GetType())
 		{
 		case TypeCode::Uint32:
@@ -103,7 +116,7 @@ ExpressionValue ExpressionParser::Parse(bool evaluate, uint8_t priority) THROWS(
 		}
 		else
 		{
-			val = Parse(evaluate, UnaryPriority);
+			val = ParseInternal(evaluate, UnaryPriority);
 			if (val.GetType() == TypeCode::CString)
 			{
 				const char* s = val.sVal;
@@ -130,7 +143,7 @@ ExpressionValue ExpressionParser::Parse(bool evaluate, uint8_t priority) THROWS(
 
 	case '!':
 		AdvancePointer();
-		val = Parse(evaluate, UnaryPriority);
+		val = ParseInternal(evaluate, UnaryPriority);
 		ConvertToBool(val, evaluate);
 		val.bVal = !val.bVal;
 		break;
@@ -158,6 +171,7 @@ ExpressionValue ExpressionParser::Parse(bool evaluate, uint8_t priority) THROWS(
 		char opChar = CurrentCharacter();
 		if (opChar == 0)	// don't pass null to strchr
 		{
+
 			return val;
 		}
 
@@ -206,7 +220,7 @@ ExpressionValue ExpressionParser::Parse(bool evaluate, uint8_t priority) THROWS(
 		case '&':
 			ConvertToBool(val, evaluate);
 			{
-				ExpressionValue val2 = Parse(evaluate && val.bVal, opPrio);		// get the next operand
+				ExpressionValue val2 = ParseInternal(evaluate && val.bVal, opPrio);		// get the next operand
 				if (val.bVal)
 				{
 					ConvertToBool(val2, evaluate);
@@ -218,7 +232,7 @@ ExpressionValue ExpressionParser::Parse(bool evaluate, uint8_t priority) THROWS(
 		case '|':
 			ConvertToBool(val, evaluate);
 			{
-				ExpressionValue val2 = Parse(evaluate && !val.bVal, opPrio);		// get the next operand
+				ExpressionValue val2 = ParseInternal(evaluate && !val.bVal, opPrio);		// get the next operand
 				if (!val.bVal)
 				{
 					ConvertToBool(val2, evaluate);
@@ -230,20 +244,20 @@ ExpressionValue ExpressionParser::Parse(bool evaluate, uint8_t priority) THROWS(
 		case '?':
 			ConvertToBool(val, evaluate);
 			{
-				ExpressionValue val2 = Parse(evaluate && val.bVal, opPrio);		// get the second operand
+				ExpressionValue val2 = ParseInternal(evaluate && val.bVal, opPrio);		// get the second operand
 				if (CurrentCharacter() != ':')
 				{
 					throw ConstructParseException("expected ':'");
 				}
 				AdvancePointer();
-				ExpressionValue val3 = Parse(evaluate && !val.bVal, opPrio - 1);	// get the third operand, which may be a further conditional expression
+				ExpressionValue val3 = ParseInternal(evaluate && !val.bVal, opPrio - 1);	// get the third operand, which may be a further conditional expression
 				return (val.bVal) ? val2 : val3;
 			}
 
 		default:
 			// Handle binary operators that always evaluate both operands
 			{
-				ExpressionValue val2 = Parse(evaluate, opPrio);	// get the next operand
+				ExpressionValue val2 = ParseInternal(evaluate, opPrio);	// get the next operand
 				switch(opChar)
 				{
 				case '+':
@@ -1000,7 +1014,16 @@ ExpressionValue ExpressionParser::ParseIdentifierExpression(bool evaluate, bool
 	}
 
 	// If we are not evaluating then the object expression doesn't have to exist, so don't retrieve it because that might throw an error
-	return (evaluate) ? reprap.GetObjectValue(context, nullptr, id.c_str()) : ExpressionValue(nullptr);
+	if (evaluate)
+	{
+		ExpressionValue value = reprap.GetObjectValue(context, nullptr, id.c_str());
+		if (context.ObsoleteFieldQueried() && obsoleteField.IsEmpty())
+		{
+			obsoleteField.copy(id.c_str());
+		}
+		return value;
+	}
+	return ExpressionValue(nullptr);
 }
 
 // Parse a quoted string, given that the current character is double-quote
diff --git a/src/GCodes/GCodeBuffer/ExpressionParser.h b/src/GCodes/GCodeBuffer/ExpressionParser.h
index 2a16286f..4c70393a 100644
--- a/src/GCodes/GCodeBuffer/ExpressionParser.h
+++ b/src/GCodes/GCodeBuffer/ExpressionParser.h
@@ -18,7 +18,7 @@ class ExpressionParser
 public:
 	ExpressionParser(const GCodeBuffer& p_gb, const char *text, const char *textLimit, int p_column = -1) noexcept;
 
-	ExpressionValue Parse(bool evaluate = true, uint8_t priority = 0) THROWS(GCodeException);
+	ExpressionValue Parse(bool evaluate = true) THROWS(GCodeException);
 	bool ParseBoolean() THROWS(GCodeException);
 	float ParseFloat() THROWS(GCodeException);
 	int32_t ParseInteger() THROWS(GCodeException);
@@ -33,6 +33,7 @@ private:
 	GCodeException ConstructParseException(const char *str, const char *param) const noexcept;
 	GCodeException ConstructParseException(const char *str, uint32_t param) const noexcept;
 
+	ExpressionValue ParseInternal(bool evaluate = true, uint8_t priority = 0) THROWS(GCodeException);
 	ExpressionValue ParseExpectKet(bool evaluate, char expectedKet) THROWS(GCodeException);
 	ExpressionValue ParseNumber() noexcept
 		pre(readPointer >= 0; isdigit(gb.buffer[readPointer]));
@@ -61,6 +62,7 @@ private:
 	int column;
 	char stringBufferStorage[StringBufferLength];
 	StringBuffer stringBuffer;
+	String<MaxVariableNameLength> obsoleteField;
 };
 
 #endif /* SRC_GCODES_GCODEBUFFER_EXPRESSIONPARSER_H_ */
diff --git a/src/GCodes/GCodes.cpp b/src/GCodes/GCodes.cpp
index 7768688b..ad302ba7 100644
--- a/src/GCodes/GCodes.cpp
+++ b/src/GCodes/GCodes.cpp
@@ -2092,8 +2092,8 @@ bool GCodes::DoStraightMove(GCodeBuffer& gb, bool isCoordinated, const char *& e
 			const unsigned int minMeshSegments = max<unsigned int>(
 					1,
 					heightMap.GetMinimumSegments(
-							currentUserPosition[grid.GetNumber0()] - initialUserPosition[grid.GetNumber0()],
-							currentUserPosition[grid.GetNumber1()] - initialUserPosition[grid.GetNumber1()]
+							currentUserPosition[grid.GetAxisNumber(0)] - initialUserPosition[grid.GetAxisNumber(0)],
+							currentUserPosition[grid.GetAxisNumber(1)] - initialUserPosition[grid.GetAxisNumber(1)]
 					)
 			);
 			if (minMeshSegments > moveBuffer.totalSegments)
diff --git a/src/GCodes/GCodes4.cpp b/src/GCodes/GCodes4.cpp
index 5cf81e89..00f5b40e 100644
--- a/src/GCodes/GCodes4.cpp
+++ b/src/GCodes/GCodes4.cpp
@@ -537,12 +537,12 @@ void GCodes::RunStateMachine(GCodeBuffer& gb, const StringRef& reply) noexcept
 			// Move to the current probe point
 			Move& move = reprap.GetMove();
 			const GridDefinition& grid = move.AccessHeightMap().GetGrid();
-			const float axis0Coord = grid.GetCoordinate0(gridAxis0index);
-			const float axis1Coord = grid.GetCoordinate1(gridAxis1index);
+			const float axis0Coord = grid.GetCoordinate(0, gridAxis0index);
+			const float axis1Coord = grid.GetCoordinate(1, gridAxis1index);
 			if (grid.IsInRadius(axis0Coord, axis1Coord))
 			{
-				const size_t axis0Num = grid.GetNumber0();
-				const size_t axis1Num = grid.GetNumber1();
+				const size_t axis0Num = grid.GetAxisNumber(0);
+				const size_t axis1Num = grid.GetAxisNumber(1);
 				AxesBitmap axes;
 				axes.SetBit(axis0Num);
 				axes.SetBit(axis1Num);
@@ -567,7 +567,7 @@ void GCodes::RunStateMachine(GCodeBuffer& gb, const StringRef& reply) noexcept
 				}
 				else
 				{
-					platform.MessageF(WarningMessage, "Skipping grid point %c=%.1f, %c=%.1f because Z probe cannot reach it\n", grid.GetLetter0(), (double)axis0Coord, grid.GetLetter1(), (double)axis1Coord);
+					platform.MessageF(WarningMessage, "Skipping grid point %c=%.1f, %c=%.1f because Z probe cannot reach it\n", grid.GetAxisLetter(0), (double)axis0Coord, grid.GetAxisLetter(1), (double)axis1Coord);
 					gb.SetState(GCodeState::gridProbing6);
 				}
 			}
@@ -765,7 +765,7 @@ void GCodes::RunStateMachine(GCodeBuffer& gb, const StringRef& reply) noexcept
 			else
 			{
 				// Even row, so increasing X
-				if (gridAxis0index + 1 == hm.GetGrid().NumAxis0points())
+				if (gridAxis0index + 1 == hm.GetGrid().NumAxisPoints(0))
 				{
 					++gridAxis1index;
 				}
@@ -775,7 +775,7 @@ void GCodes::RunStateMachine(GCodeBuffer& gb, const StringRef& reply) noexcept
 				}
 			}
 
-			if (gridAxis1index == hm.GetGrid().NumAxis1points())
+			if (gridAxis1index == hm.GetGrid().NumAxisPoints(1))
 			{
 				// Done all the points
 				gb.AdvanceState();
diff --git a/src/Linux/DataTransfer.cpp b/src/Linux/DataTransfer.cpp
index ade89e1d..a605ef92 100644
--- a/src/Linux/DataTransfer.cpp
+++ b/src/Linux/DataTransfer.cpp
@@ -1143,12 +1143,6 @@ bool DataTransfer::WriteHeightMap() noexcept
 {
 	const GridDefinition& grid = reprap.GetMove().GetGrid();
 
-	// TODO: Remove this check once DCS is aware of the new format
-	if (!(grid.letter0 == 'X' && grid.letter1 == 'Y'))
-	{
-		return false;
-	}
-
 	size_t numPoints = reprap.GetMove().AccessHeightMap().UsingHeightMap() ? grid.NumPoints() : 0;
 	size_t bytesToWrite = sizeof(HeightMapHeader) + numPoints * sizeof(float);
 	if (!CanWritePacket(bytesToWrite))
@@ -1161,15 +1155,15 @@ bool DataTransfer::WriteHeightMap() noexcept
 
 	// Write heightmap header
 	HeightMapHeader *header = WriteDataHeader<HeightMapHeader>();
-	header->xMin = grid.min0;
-	header->xMax = grid.max0;
-	header->xSpacing = grid.spacing0;
-	header->yMin = grid.min1;
-	header->yMax = grid.max1;
-	header->ySpacing = grid.spacing1;
+	header->xMin = grid.GetMin(0);
+	header->xMax = grid.GetMax(0);
+	header->xSpacing = grid.GetSpacing(0);
+	header->yMin = grid.GetMin(1);
+	header->yMax = grid.GetMax(1);
+	header->ySpacing = grid.GetSpacing(1);
 	header->radius = grid.radius;
-	header->numX = grid.num0;
-	header->numY = grid.num1;
+	header->numX = grid.NumAxisPoints(0);
+	header->numY = grid.NumAxisPoints(1);
 
 	// Write Z points
 	if (numPoints != 0)
diff --git a/src/Movement/BedProbing/Grid.cpp b/src/Movement/BedProbing/Grid.cpp
index b1bba196..7948112e 100644
--- a/src/Movement/BedProbing/Grid.cpp
+++ b/src/Movement/BedProbing/Grid.cpp
@@ -24,22 +24,53 @@
 #define OBJECT_MODEL_FUNC(...) OBJECT_MODEL_FUNC_BODY(GridDefinition, __VA_ARGS__)
 #define OBJECT_MODEL_FUNC_IF(...) OBJECT_MODEL_FUNC_IF_BODY(GridDefinition, __VA_ARGS__)
 
+static constexpr ObjectModelArrayDescriptor axisArrayDescriptor =
+{
+	nullptr,					// no lock needed
+	[] (const ObjectModel *self, const ObjectExplorationContext&) noexcept -> size_t { return 2; },
+	[] (const ObjectModel *self, ObjectExplorationContext& context) noexcept -> ExpressionValue { return ExpressionValue(((const GridDefinition*)self)->GetAxisLetter(context.GetLastIndex())); }
+};
+
+static constexpr ObjectModelArrayDescriptor maxsArrayDescriptor =
+{
+	nullptr,					// no lock needed
+	[] (const ObjectModel *self, const ObjectExplorationContext&) noexcept -> size_t { return 2; },
+	[] (const ObjectModel *self, ObjectExplorationContext& context) noexcept -> ExpressionValue { return ExpressionValue(((const GridDefinition*)self)->GetMax(context.GetLastIndex()), 1); }
+};
+
+static constexpr ObjectModelArrayDescriptor minsArrayDescriptor =
+{
+	nullptr,					// no lock needed
+	[] (const ObjectModel *self, const ObjectExplorationContext&) noexcept -> size_t { return 2; },
+	[] (const ObjectModel *self, ObjectExplorationContext& context) noexcept -> ExpressionValue { return ExpressionValue(((const GridDefinition*)self)->GetMin(context.GetLastIndex()), 1); }
+};
+
+static constexpr ObjectModelArrayDescriptor spacingsArrayDescriptor =
+{
+	nullptr,					// no lock needed
+	[] (const ObjectModel *self, const ObjectExplorationContext&) noexcept -> size_t { return 2; },
+	[] (const ObjectModel *self, ObjectExplorationContext& context) noexcept -> ExpressionValue { return ExpressionValue(((const GridDefinition*)self)->GetSpacing(context.GetLastIndex()), 1); }
+};
+
 constexpr ObjectModelTableEntry GridDefinition::objectModelTable[] =
 {
 	// Within each group, these entries must be in alphabetical order
 	// 0. GridDefinition members
-	{ "axis0",		OBJECT_MODEL_FUNC(self->letter0),			ObjectModelEntryFlags::none },
-	{ "axis1",		OBJECT_MODEL_FUNC(self->letter1),			ObjectModelEntryFlags::none },
-	{ "max0",		OBJECT_MODEL_FUNC(self->max0, 1),			ObjectModelEntryFlags::none },
-	{ "max1",		OBJECT_MODEL_FUNC(self->max1, 1),			ObjectModelEntryFlags::none },
-	{ "min0",		OBJECT_MODEL_FUNC(self->min0, 1),			ObjectModelEntryFlags::none },
-	{ "min1",		OBJECT_MODEL_FUNC(self->min1, 1),			ObjectModelEntryFlags::none },
-	{ "radius",		OBJECT_MODEL_FUNC(self->radius, 1),			ObjectModelEntryFlags::none },
-	{ "spacing0",	OBJECT_MODEL_FUNC(self->spacing0, 1),		ObjectModelEntryFlags::none },
-	{ "spacing1",	OBJECT_MODEL_FUNC(self->spacing1, 1),		ObjectModelEntryFlags::none },
+	{ "axes",		OBJECT_MODEL_FUNC_NOSELF(&axisArrayDescriptor), 		ObjectModelEntryFlags::none },
+	{ "maxs",		OBJECT_MODEL_FUNC_NOSELF(&maxsArrayDescriptor), 		ObjectModelEntryFlags::none },
+	{ "mins",		OBJECT_MODEL_FUNC_NOSELF(&minsArrayDescriptor), 		ObjectModelEntryFlags::none },
+	{ "radius",		OBJECT_MODEL_FUNC(self->radius, 1),						ObjectModelEntryFlags::none },
+	{ "spacings",	OBJECT_MODEL_FUNC_NOSELF(&spacingsArrayDescriptor), 	ObjectModelEntryFlags::none },
+
+	{ "xMax",		OBJECT_MODEL_FUNC(self->maxs[0], 1),					ObjectModelEntryFlags::obsolete },
+	{ "xMin",		OBJECT_MODEL_FUNC(self->mins[0], 1),					ObjectModelEntryFlags::obsolete },
+	{ "xSpacing",	OBJECT_MODEL_FUNC(self->spacings[0], 1),				ObjectModelEntryFlags::obsolete },
+	{ "yMax",		OBJECT_MODEL_FUNC(self->maxs[1], 1),					ObjectModelEntryFlags::obsolete },
+	{ "yMin",		OBJECT_MODEL_FUNC(self->mins[1], 1),					ObjectModelEntryFlags::obsolete },
+	{ "ySpacing",	OBJECT_MODEL_FUNC(self->spacings[1], 1),				ObjectModelEntryFlags::obsolete },
 };
 
-constexpr uint8_t GridDefinition::objectModelTableDescriptor[] = { 1, 9 };
+constexpr uint8_t GridDefinition::objectModelTableDescriptor[] = { 1, 11 };
 
 DEFINE_GET_OBJECT_MODEL_TABLE(GridDefinition)
 
@@ -53,31 +84,30 @@ const char * const GridDefinition::HeightMapLabelLines[] =
 };
 
 // Initialise the grid to be invalid
-GridDefinition::GridDefinition() noexcept
-	: letter0('X'), letter1('Y'),
-	  min0(0.0), max0(-1.0),
-	  min1(0.0), max1(-1.0),
-	  radius(-1.0),
-	  spacing0(0.0), spacing1(0.0),
-	  axis0Number(X_AXIS), axis1Number(Y_AXIS),
-	  num0(0), num1(0),
-	  recipAxis0spacing(0.0), recipAxis1spacing(0.0),
-	  isValid(false)
+GridDefinition::GridDefinition() noexcept : radius(-1.0), isValid(false)
 {
+	letters[0] = 'X';
+	letters[1] = 'Y';
+	mins[0] = mins[1] = 0.0;
+	maxs[0] = maxs[1] = -1.0;
+	spacings[0] = spacings[1] = 0.0;
+
+	nums[0] = nums[1] = 0;
+	recipAxisSpacings[0] = recipAxisSpacings[1] = 0.0;
 }
 
 // Set the grid parameters ands return true if it is now valid
-bool GridDefinition::Set(const char axesLetters[2], const float axis0Range[2], const float axis1Range[2], float pRadius, const float pSpacings[2]) noexcept
+bool GridDefinition::Set(const char axisLetters[2], const float axis0Range[2], const float axis1Range[2], float pRadius, const float pSpacings[2]) noexcept
 {
-	letter0 = axesLetters[0];
-	letter1 = axesLetters[1];
-	min0 = axis0Range[0];
-	max0 = axis0Range[1];
-	min1 = axis1Range[0];
-	max1 = axis1Range[1];
+	letters[0] = axisLetters[0];
+	letters[1] = axisLetters[1];
+	mins[0] = axis0Range[0];
+	maxs[0] = axis0Range[1];
+	mins[1] = axis1Range[0];
+	maxs[1] = axis1Range[1];
 	radius = pRadius;
-	spacing0 = pSpacings[0];
-	spacing1 = pSpacings[1];
+	spacings[0] = pSpacings[0];
+	spacings[1] = pSpacings[1];
 	CheckValidity();
 	return isValid;
 }
@@ -86,39 +116,29 @@ bool GridDefinition::Set(const char axesLetters[2], const float axis0Range[2], c
 // numAxis0, numAxis1 are always set up, but recipAxis0spacing, recipAxis1spacing only if the grid is valid
 void GridDefinition::CheckValidity() noexcept
 {
-	num0 = (max0 - min0 >= MinRange && spacing0 >= MinSpacing) ? (uint32_t)((max0 - min0)/spacing0) + 1 : 0;
-	num1 = (max1 - min1 >= MinRange && spacing1 >= MinSpacing) ? (uint32_t)((max1 - min1)/spacing1) + 1 : 0;
+	nums[0] = (maxs[0] - mins[0] >= MinRange && spacings[0] >= MinSpacing) ? (uint32_t)((maxs[0] - mins[0])/spacings[0]) + 1 : 0;
+	nums[1] = (maxs[1] - mins[1] >= MinRange && spacings[1] >= MinSpacing) ? (uint32_t)((maxs[1] - mins[1])/spacings[1]) + 1 : 0;
 
-	const size_t axis0NumForLetter = reprap.GetGCodes().GetAxisNumberForLetter(letter0);
-	const size_t axis1NumForLetter = reprap.GetGCodes().GetAxisNumberForLetter(letter1);
+	const size_t axis0NumForLetter = reprap.GetGCodes().GetAxisNumberForLetter(letters[0]);
+	const size_t axis1NumForLetter = reprap.GetGCodes().GetAxisNumberForLetter(letters[1]);
 	const size_t numVisibleAxes = reprap.GetGCodes().GetVisibleAxes();
 
 	isValid = NumPoints() != 0 && NumPoints() <= MaxGridProbePoints
 			&& (radius < 0.0 || radius >= 1.0)
-			&& NumAxis0points() <= MaxAxis0GridPoints
-			&& letter0 != letter1
+			&& NumAxisPoints(0) <= MaxAxis0GridPoints
+			&& letters[0] != letters[1]
 			&& axis0NumForLetter < numVisibleAxes
 			&& axis1NumForLetter < numVisibleAxes;
 
 	if (isValid)
 	{
-		axis0Number = axis0NumForLetter;
-		axis1Number = axis1NumForLetter;
-		recipAxis0spacing = 1.0/spacing0;
-		recipAxis1spacing = 1.0/spacing1;
+		axisNumbers[0] = axis0NumForLetter;
+		axisNumbers[1] = axis1NumForLetter;
+		recipAxisSpacings[0] = 1.0/spacings[0];
+		recipAxisSpacings[1] = 1.0/spacings[1];
 	}
 }
 
-float GridDefinition::GetCoordinate0(unsigned int axis0Index) const noexcept
-{
-	return min0 + (axis0Index * spacing0);
-}
-
-float GridDefinition::GetCoordinate1(unsigned int axis1Index) const noexcept
-{
-	return min1 + (axis1Index * spacing1);
-}
-
 bool GridDefinition::IsInRadius(float axis0, float y) const noexcept
 {
 	return radius < 0.0 || fsquare(axis0) + fsquare(y) < fsquare(radius);
@@ -128,14 +148,14 @@ bool GridDefinition::IsInRadius(float axis0, float y) const noexcept
 void GridDefinition::PrintParameters(const StringRef& s) const noexcept
 {
 	s.catf("%c%.1f:%.1f, %c%.1f:%.1f, radius %.1f, %c spacing %.1f, %c spacing %.1f, %" PRIu32 " points",
-			letter0, (double)min0, (double)max0, letter1, (double)min1, (double)max1, (double)radius, letter0, (double)spacing0, letter1, (double)spacing1, NumPoints());
+			letters[0], (double)mins[0], (double)maxs[0], letters[1], (double)mins[1], (double)maxs[1], (double)radius, letters[0], (double)spacings[0], letters[1], (double)spacings[1], NumPoints());
 }
 
 // Write the parameter label line to a string
 void GridDefinition::WriteHeadingAndParameters(const StringRef& s) const noexcept
 {
 	s.printf("%s\n%c,%c,%.2f,%.2f,%.2f,%.2f,%.2f,%.2f,%.2f,%" PRIi32 ",%" PRIi32 "\n",
-				HeightMapLabelLines[ARRAY_UPB(HeightMapLabelLines)], letter0, letter1, (double)min0, (double)max0, (double)min1, (double)max1, (double)radius, (double)spacing0, (double)spacing1, num0, num1);
+				HeightMapLabelLines[ARRAY_UPB(HeightMapLabelLines)], letters[0], letters[1], (double)mins[0], (double)maxs[0], (double)mins[1], (double)maxs[1], (double)radius, (double)spacings[0], (double)spacings[1], nums[0], nums[1]);
 }
 
 // Check the parameter label line, returning -1 if not recognised, else the version we found
@@ -161,19 +181,19 @@ bool GridDefinition::ReadParameters(const StringRef& s, int version) noexcept
 
 	if (version < 2)
 	{
-		letter0 = 'X';
-		letter1 = 'Y';
+		letters[0] = 'X';
+		letters[1] = 'Y';
 	}
 	else
 	{
-		letter0 = *p;
+		letters[0] = *p;
 		++p;
 		if (*p != ',')
 		{
 			return false;
 		}
 		++p;
-		letter1 = *p;
+		letters[1] = *p;
 		++p;
 		if (*p != ',')
 		{
@@ -182,28 +202,28 @@ bool GridDefinition::ReadParameters(const StringRef& s, int version) noexcept
 		++p;
 	}
 
-	min0 = SafeStrtof(p, &q);
+	mins[0] = SafeStrtof(p, &q);
 	if (p == q || *q != ',')
 	{
 		return false;
 	}
 	p = q + 1;
 
-	max0 = SafeStrtof(p, &q);
+	maxs[0] = SafeStrtof(p, &q);
 	if (p == q || *q != ',')
 	{
 		return false;
 	}
 	p = q + 1;
 
-	min1 = SafeStrtof(p, &q);
+	mins[1] = SafeStrtof(p, &q);
 	if (p == q || *q != ',')
 	{
 		return false;
 	}
 	p = q + 1;
 
-	max1 = SafeStrtof(p, &q);
+	maxs[1] = SafeStrtof(p, &q);
 	if (p == q || *q != ',')
 	{
 		return false;
@@ -217,7 +237,7 @@ bool GridDefinition::ReadParameters(const StringRef& s, int version) noexcept
 	}
 	p = q + 1;
 
-	spacing0 = SafeStrtof(p, &q);
+	spacings[0] = SafeStrtof(p, &q);
 	if (p == q || *q != ',')
 	{
 		return false;
@@ -226,11 +246,11 @@ bool GridDefinition::ReadParameters(const StringRef& s, int version) noexcept
 
 	if (version == 0)
 	{
-		spacing1 = spacing0;
+		spacings[1] = spacings[0];
 	}
 	else
 	{
-		spacing1 = SafeStrtof(p, &q);
+		spacings[1] = SafeStrtof(p, &q);
 		if (p == q || *q != ',')
 		{
 			return false;
@@ -238,14 +258,14 @@ bool GridDefinition::ReadParameters(const StringRef& s, int version) noexcept
 		p = q + 1;
 	}
 
-	num0 = StrToU32(p, &q);
+	nums[0] = StrToU32(p, &q);
 	if (p == q || *q != ',')
 	{
 		return false;
 	}
 	p = q + 1;
 
-	num1 = StrToU32(p, &q);
+	nums[1] = StrToU32(p, &q);
 	if (p == q)
 	{
 		return false;
@@ -258,20 +278,20 @@ bool GridDefinition::ReadParameters(const StringRef& s, int version) noexcept
 // Print what is wrong with the grid, appending it to the existing string
 void GridDefinition::PrintError(float originalAxis0range, float originalAxis1range, const StringRef& r) const noexcept
 {
-	if (spacing0 < MinSpacing || spacing1 < MinSpacing)
+	if (spacings[0] < MinSpacing || spacings[1] < MinSpacing)
 	{
 		r.cat("Spacing too small");
 	}
-	else if (num0 == 0)
+	else if (nums[0] == 0)
 	{
-		r.cat("X range too small");
+		r.catf("%c range too small", letters[0]);
 	}
-	else if (num1 == 0)
+	else if (nums[1] == 0)
 	{
-		r.cat("Y range too small");
+		r.catf("%c range too small", letters[1]);
 	}
-	else if (   num0 > MaxAxis0GridPoints
-			 || num0 > MaxGridProbePoints || num1 > MaxGridProbePoints		// check X and Y individually in case X*Y overflows
+	else if (   nums[0] > MaxAxis0GridPoints
+			 || nums[0] > MaxGridProbePoints || nums[1] > MaxGridProbePoints		// check X and Y individually in case X*Y overflows
 			 || NumPoints() > MaxGridProbePoints
 			)
 	{
@@ -312,7 +332,7 @@ void HeightMap::ClearGridHeights() noexcept
 // Set the height of a grid point
 void HeightMap::SetGridHeight(size_t axis0Index, size_t axis1Index, float height) noexcept
 {
-	SetGridHeight(axis1Index * def.num0 + axis0Index, height);
+	SetGridHeight(axis1Index * def.nums[0] + axis0Index, height);
 }
 
 void HeightMap::SetGridHeight(size_t index, float height) noexcept
@@ -329,10 +349,10 @@ void HeightMap::SetGridHeight(size_t index, float height) noexcept
 unsigned int HeightMap::GetMinimumSegments(float deltaAxis0, float deltaAxis1) const noexcept
 {
 	const float axis0Distance = fabsf(deltaAxis0);
-	unsigned int axis0Segments = (axis0Distance > 0.0) ? (unsigned int)(axis0Distance * def.recipAxis0spacing + 0.4) : 1;
+	unsigned int axis0Segments = (axis0Distance > 0.0) ? (unsigned int)(axis0Distance * def.recipAxisSpacings[0] + 0.4) : 1;
 
 	const float axis1Distance = fabsf(deltaAxis1);
-	unsigned int axis1Segments = (axis1Distance > 0.0) ? (unsigned int)(axis1Distance * def.recipAxis1spacing + 0.4) : 1;
+	unsigned int axis1Segments = (axis1Distance > 0.0) ? (unsigned int)(axis1Distance * def.recipAxisSpacings[1] + 0.4) : 1;
 
 	return max<unsigned int>(axis0Segments, axis1Segments);
 }
@@ -373,10 +393,10 @@ bool HeightMap::SaveToFile(FileStore *f, const char *fname, float zOffset) noexc
 
 	// Write the grid heights. We use a fixed field with of 6 characters to make is easier to view.
 	uint32_t index = 0;
-	for (uint32_t i = 0; i < def.num1; ++i)
+	for (uint32_t i = 0; i < def.nums[1]; ++i)
 	{
 		buf.Clear();
-		for (uint32_t j = 0; j < def.num0; ++j)
+		for (uint32_t j = 0; j < def.nums[0]; ++j)
 		{
 			if (j != 0)
 			{
@@ -446,7 +466,7 @@ bool HeightMap::LoadFromFile(FileStore *f, const char *fname, const StringRef& r
 	else
 	{
 		SetGrid(newGrid);
-		for (uint32_t row = 0; row < def.num1; ++row)		// read the grid a row at a time
+		for (uint32_t row = 0; row < def.nums[1]; ++row)	// read the grid a row at a time
 		{
 			if (f->ReadLine(buffer, sizeof(buffer)) <= 0)
 			{
@@ -454,7 +474,7 @@ bool HeightMap::LoadFromFile(FileStore *f, const char *fname, const StringRef& r
 				return true;								// failed to read a line
 			}
 			const char *p = buffer;
-			for (uint32_t col = 0; col < def.num0; ++col)
+			for (uint32_t col = 0; col < def.nums[0]; ++col)
 			{
 				while (*p == ' ' || *p == '\t')
 				{
@@ -504,9 +524,9 @@ void HeightMap::SetFileName(const char *name) noexcept
 void HeightMap::SaveToArray(float *arr, float zOffset) const noexcept
 {
 	size_t index = 0;
-	for (size_t i = 0; i < def.num1; ++i)
+	for (size_t i = 0; i < def.nums[1]; ++i)
 	{
-		for (size_t j = 0; j < def.num0; ++j)
+		for (size_t j = 0; j < def.nums[0]; ++j)
 		{
 			arr[index] = gridHeightSet.IsBitSet(index) ? (gridHeights[index] + zOffset) : std::numeric_limits<float>::quiet_NaN();
 			index++;
@@ -563,21 +583,21 @@ float HeightMap::GetInterpolatedHeightError(float axis0, float axis1) const noex
 	}
 
 	// Last grid point
-	const float xLast = def.min0 + (def.num0-1)*def.spacing0;
-	const float yLast = def.min1 + (def.num1-1)*def.spacing1;
+	const float xLast = def.mins[0] + (def.nums[0]-1)*def.spacings[0];
+	const float yLast = def.mins[1] + (def.nums[1]-1)*def.spacings[1];
 
 	// Clamp to rectangle so InterpolateXY will always have valid parameters
 	const float fEPSILON = 0.01;
-	if (axis0 < def.min0) { axis0 = def.min0; }
-	if (axis1 < def.min1) {	axis1 = def.min1; }
+	if (axis0 < def.mins[0]) { axis0 = def.mins[0]; }
+	if (axis1 < def.mins[1]) { axis1 = def.mins[1]; }
 	if (axis0 > xLast -fEPSILON) { axis0 = xLast -fEPSILON; }
 	if (axis1 > yLast -fEPSILON) { axis1 = yLast -fEPSILON; }
 
 
-	const float xf = (axis0 - def.min0) * def.recipAxis0spacing;
+	const float xf = (axis0 - def.mins[0]) * def.recipAxisSpacings[0];
 	const float xFloor = floor(xf);
 	const int32_t xIndex = (int32_t)xFloor;
-	const float yf = (axis1 - def.min1) * def.recipAxis1spacing;
+	const float yf = (axis1 - def.mins[1]) * def.recipAxisSpacings[1];
 	const float yFloor = floor(yf);
 	const int32_t yIndex = (int32_t)yFloor;
 
@@ -588,7 +608,7 @@ float HeightMap::InterpolateAxis0Axis1(uint32_t axis0Index, uint32_t axis1Index,
 {
 	const uint32_t indexX0Y0 = GetMapIndex(axis0Index, axis1Index);	// (X0,Y0)
 	const uint32_t indexX1Y0 = indexX0Y0 + 1;						// (X1,Y0)
-	const uint32_t indexX0Y1 = indexX0Y0 + def.num0;			// (X0 Y1)
+	const uint32_t indexX0Y1 = indexX0Y0 + def.nums[0];				// (X0 Y1)
 	const uint32_t indexX1Y1 = indexX0Y1 + 1;						// (X1,Y1)
 
 	const float xyFrac = axis0Frac * axis1Frac;
@@ -606,15 +626,15 @@ void HeightMap::ExtrapolateMissing() noexcept
 	//algorithm: http://www.ilikebigbits.com/blog/2015/3/2/plane-from-points
 	float sumAxis0 = 0, sumAxis1 = 0, sumZ = 0;
 	int n = 0;
-	for (uint32_t iAxis1 = 0; iAxis1 < def.num1; iAxis1++)
+	for (uint32_t iAxis1 = 0; iAxis1 < def.nums[1]; iAxis1++)
 	{
-		for (uint32_t iAxis0 = 0; iAxis0 < def.num0; iAxis0++)
+		for (uint32_t iAxis0 = 0; iAxis0 < def.nums[0]; iAxis0++)
 		{
 			const uint32_t index = GetMapIndex(iAxis0, iAxis1);
 			if (gridHeightSet.IsBitSet(index))
 			{
-				const float fAxis0 = (def.spacing0 * iAxis0) + def.min0;
-				const float fAxis1 = (def.spacing1 * iAxis1) + def.min1;
+				const float fAxis0 = (def.spacings[0] * iAxis0) + def.mins[0];
+				const float fAxis1 = (def.spacings[1] * iAxis1) + def.mins[1];
 				const float fZ = gridHeights[index];
 
 				n++;
@@ -630,15 +650,15 @@ void HeightMap::ExtrapolateMissing() noexcept
 	float axis0Axis0 = 0.0; float axis0Axis1 = 0.0; float axis0z = 0.0;
 	float axis1Axis1 = 0.0; float axis1z = 0.0; float zz = 0.0;
 
-	for (uint32_t iAxis1 = 0; iAxis1 < def.num1; iAxis1++)
+	for (uint32_t iAxis1 = 0; iAxis1 < def.nums[1]; iAxis1++)
 	{
-		for (uint32_t iAxis0 = 0; iAxis0 < def.num0; iAxis0++)
+		for (uint32_t iAxis0 = 0; iAxis0 < def.nums[0]; iAxis0++)
 		{
 			const uint32_t index = GetMapIndex(iAxis0, iAxis1);
 			if (gridHeightSet.IsBitSet(index))
 			{
-				const float fAxis0 = (def.spacing0 * iAxis0) + def.min0;
-				const float fAxis1 = (def.spacing1 * iAxis1) + def.min1;
+				const float fAxis0 = (def.spacings[0] * iAxis0) + def.mins[0];
+				const float fAxis1 = (def.spacings[1] * iAxis1) + def.mins[1];
 				const float fZ = gridHeights[index];
 
 				const float rAxis0 = fAxis0 - centAxis0;
@@ -673,15 +693,15 @@ void HeightMap::ExtrapolateMissing() noexcept
 	const float d = centAxis0*a + centAxis1*b + centZ*c;
 
 	// Fill in the blanks
-	for (uint32_t iAxis1 = 0; iAxis1 < def.num1; iAxis1++)
+	for (uint32_t iAxis1 = 0; iAxis1 < def.nums[1]; iAxis1++)
 	{
-		for (uint32_t iAxis0 = 0; iAxis0 < def.num0; iAxis0++)
+		for (uint32_t iAxis0 = 0; iAxis0 < def.nums[0]; iAxis0++)
 		{
 			const uint32_t index = GetMapIndex(iAxis0, iAxis1);
 			if (!gridHeightSet.IsBitSet(index))
 			{
-				const float fAxis0 = (def.spacing0 * iAxis0) + def.min0;
-				const float fAxis1 = (def.spacing1 * iAxis1) + def.min1;
+				const float fAxis0 = (def.spacings[0] * iAxis0) + def.mins[0];
+				const float fAxis1 = (def.spacings[1] * iAxis1) + def.mins[1];
 				const float fZ = (d - (a * fAxis0 + b * fAxis1)) * invC;
 				gridHeights[index] = fZ;	// fill in Z but don't mark it as set so we can always differentiate between measured and extrapolated
 			}
diff --git a/src/Movement/BedProbing/Grid.h b/src/Movement/BedProbing/Grid.h
index 5e00fe10..6ce5b742 100644
--- a/src/Movement/BedProbing/Grid.h
+++ b/src/Movement/BedProbing/Grid.h
@@ -23,19 +23,19 @@ public:
 
 	GridDefinition() noexcept;
 
-	uint32_t NumAxis0points() const noexcept { return num0; }
-	uint32_t NumAxis1points() const noexcept { return num1; }
-	uint32_t NumPoints() const noexcept { return num0 * num1; }
-	uint8_t GetLetter0() const noexcept { return letter0; }
-	uint8_t GetLetter1() const noexcept { return letter1; }
-	uint8_t GetNumber0() const noexcept { return axis0Number; }
-	uint8_t GetNumber1() const noexcept { return axis1Number; }
-	float GetCoordinate0(unsigned int axis0Index) const noexcept;
-	float GetCoordinate1(unsigned int axis1Index) const noexcept;
+	char GetAxisLetter(size_t axis) const noexcept pre(axis < 2) { return letters[axis]; }
+	uint8_t GetAxisNumber(size_t axis) const noexcept pre(axis < 2) { return axisNumbers[axis]; }
+	float GetMin(size_t axis) const noexcept pre(axis < 2) { return mins[axis]; }
+	float GetMax(size_t axis) const noexcept pre(axis < 2) { return maxs[axis]; }
+	float GetSpacing(size_t axis) const noexcept pre(axis < 2) { return spacings[axis]; }
+
+	uint32_t NumAxisPoints(size_t axis) const noexcept pre(axis < 2) { return nums[axis]; }
+	uint32_t NumPoints() const noexcept { return nums[0] * nums[1]; }
+	float GetCoordinate(size_t axis, size_t coordinateIndex) pre(axis < 2) const noexcept { return mins[axis] + (coordinateIndex * spacings[axis]); }
 	bool IsInRadius(float x, float y) const noexcept;
 	bool IsValid() const noexcept { return isValid; }
 
-	bool Set(const char axesLetter[2], const float axis0Range[2], const float axis1Range[2], float pRadius, const float pSpacings[2]) noexcept;
+	bool Set(const char axisLetters[2], const float axis0Range[2], const float axis1Range[2], float pRadius, const float pSpacings[2]) noexcept;
 	void PrintParameters(const StringRef& r) const noexcept;
 	void WriteHeadingAndParameters(const StringRef& r) const noexcept;
 	static int CheckHeading(const StringRef& s) noexcept;
@@ -55,15 +55,15 @@ private:
 	static const char * const HeightMapLabelLines[];				// The line we write to the height map file listing the parameter names
 
 	// Primary parameters
-	char letter0, letter1;											// Axes letters for this grid
-	float min0, max0, min1, max1;									// The edges of the grid for G29 probing
+	char letters[2];												// Axis letters for this grid
+	float mins[2], maxs[2];											// The edges of the grid for G29 probing
 	float radius;													// The grid radius to probe
-	float spacing0, spacing1;										// The spacing of the grid probe points
+	float spacings[2];												// The spacings of the grid probe points
 
 	// Derived parameters
-	uint8_t axis0Number, axis1Number;								// Axes numbers for this grid
-	uint32_t num0, num1;
-	float recipAxis0spacing, recipAxis1spacing;
+	uint8_t axisNumbers[2];											// Axis numbers for this grid
+	uint32_t nums[2];												// Number of probe points in each direction
+	float recipAxisSpacings[2];										// Reciprocals of the axis spacings
 	bool isValid;
 };
 
@@ -117,7 +117,7 @@ private:
 #endif
 	bool useMap;													// True to do bed compensation
 
-	uint32_t GetMapIndex(uint32_t axis0Index, uint32_t axis1Index) const noexcept { return (axis1Index * def.NumAxis0points()) + axis0Index; }
+	uint32_t GetMapIndex(uint32_t axis0Index, uint32_t axis1Index) const noexcept { return (axis1Index * def.NumAxisPoints(0)) + axis0Index; }
 
 	float InterpolateAxis0Axis1(uint32_t axis0Index, uint32_t axis1Index, float axis0Frac, float axis1Frac) const noexcept;
 };
diff --git a/src/Movement/Move.cpp b/src/Movement/Move.cpp
index 3d03f5ce..cf6c6656 100644
--- a/src/Movement/Move.cpp
+++ b/src/Movement/Move.cpp
@@ -88,7 +88,7 @@ constexpr ObjectModelTableEntry Move::objectModelTable[] =
 	{ "travelAcceleration",		OBJECT_MODEL_FUNC(self->maxTravelAcceleration, 1),										ObjectModelEntryFlags::none },
 	{ "virtualEPos",			OBJECT_MODEL_FUNC_NOSELF(reprap.GetGCodes().GetVirtualExtruderPosition(), 5),			ObjectModelEntryFlags::live },
 	{ "workplaceNumber",		OBJECT_MODEL_FUNC_NOSELF((int32_t)reprap.GetGCodes().GetWorkplaceCoordinateSystemNumber() - 1),	ObjectModelEntryFlags::none },
-	{ "workspaceNumber",		OBJECT_MODEL_FUNC_NOSELF((int32_t)reprap.GetGCodes().GetWorkplaceCoordinateSystemNumber()),	ObjectModelEntryFlags::none },
+	{ "workspaceNumber",		OBJECT_MODEL_FUNC_NOSELF((int32_t)reprap.GetGCodes().GetWorkplaceCoordinateSystemNumber()),	ObjectModelEntryFlags::obsolete },
 
 	// 1. Move.Idle members
 	{ "factor",					OBJECT_MODEL_FUNC_NOSELF(reprap.GetPlatform().GetIdleCurrentFactor(), 1),				ObjectModelEntryFlags::none },
@@ -593,10 +593,10 @@ void Move::BedTransform(float xyzPoint[MaxAxes], const Tool *tool) const noexcep
 			float zCorrection = 0.0;
 			unsigned int numCorrections = 0;
 			const GridDefinition& grid = GetGrid();
-			const AxesBitmap axis1Axes = Tool::GetAxisMapping(tool, grid.GetNumber1());
+			const AxesBitmap axis1Axes = Tool::GetAxisMapping(tool, grid.GetAxisNumber(1));
 
 			// Transform the Z coordinate based on the average correction for each axis used as an X or Y axis.
-			Tool::GetAxisMapping(tool, grid.GetNumber0())
+			Tool::GetAxisMapping(tool, grid.GetAxisNumber(0))
 				.Iterate([this, xyzPoint, tool, axis1Axes, &zCorrection, &numCorrections](unsigned int axis0Axis, unsigned int)
 							{
 								const float axis0Coord = xyzPoint[axis0Axis] + Tool::GetOffset(tool, axis0Axis);
@@ -629,10 +629,10 @@ void Move::InverseBedTransform(float xyzPoint[MaxAxes], const Tool *tool) const
 		float zCorrection = 0.0;
 		unsigned int numCorrections = 0;
 		const GridDefinition& grid = GetGrid();
-		const AxesBitmap axis1Axes = Tool::GetAxisMapping(tool, grid.GetNumber1());
+		const AxesBitmap axis1Axes = Tool::GetAxisMapping(tool, grid.GetAxisNumber(1));
 
 		// Transform the Z coordinate based on the average correction for each axis used as an X or Y axis.
-		Tool::GetAxisMapping(tool, grid.GetNumber0())
+		Tool::GetAxisMapping(tool, grid.GetAxisNumber(0))
 			.Iterate([this, xyzPoint, tool, axis1Axes, &zCorrection, &numCorrections](unsigned int axis0Axis, unsigned int)
 						{
 							const float axis0Coord = xyzPoint[axis0Axis] + Tool::GetOffset(tool, axis0Axis);
@@ -678,7 +678,7 @@ void Move::SetZeroHeightError(const float coords[MaxAxes]) noexcept
 		memcpyf(tempCoords, coords, ARRAY_SIZE(tempCoords));
 		AxisTransform(tempCoords, nullptr);
 		const GridDefinition& grid = GetGrid();
-		zShift = -heightMap.GetInterpolatedHeightError(tempCoords[grid.GetNumber0()], tempCoords[grid.GetNumber1()]);
+		zShift = -heightMap.GetInterpolatedHeightError(tempCoords[grid.GetAxisNumber(0)], tempCoords[grid.GetAxisNumber(1)]);
 	}
 	else
 	{
diff --git a/src/ObjectModel/ObjectModel.cpp b/src/ObjectModel/ObjectModel.cpp
index 430821cf..917cc6e2 100644
--- a/src/ObjectModel/ObjectModel.cpp
+++ b/src/ObjectModel/ObjectModel.cpp
@@ -215,7 +215,7 @@ ObjectModel::ObjectModel() noexcept
 ObjectExplorationContext::ObjectExplorationContext(bool wal, const char *reportFlags, unsigned int initialMaxDepth) noexcept
 	: startMillis(millis()), maxDepth(initialMaxDepth), currentDepth(0), numIndicesProvided(0), numIndicesCounted(0),
 	  line(-1), column(-1),
-	  shortForm(false), onlyLive(false), includeVerbose(false), wantArrayLength(wal), includeNulls(false)
+	  shortForm(false), onlyLive(false), includeVerbose(false), wantArrayLength(wal), includeNulls(false), includeObsolete(false), obsoleteFieldQueried(false)
 {
 	while (true)
 	{
@@ -235,6 +235,9 @@ ObjectExplorationContext::ObjectExplorationContext(bool wal, const char *reportF
 		case 'n':
 			includeNulls = true;
 			break;
+		case 'o':
+			includeObsolete = true;
+			break;
 		case 'd':
 			maxDepth = 0;
 			while (isdigit(*reportFlags))
@@ -257,7 +260,7 @@ ObjectExplorationContext::ObjectExplorationContext(bool wal, const char *reportF
 ObjectExplorationContext::ObjectExplorationContext(bool wal, int p_line, int p_col) noexcept
 	: startMillis(millis()), maxDepth(99), currentDepth(0), numIndicesProvided(0), numIndicesCounted(0),
 	  line(p_line), column(p_col),
-	  shortForm(false), onlyLive(false), includeVerbose(true), wantArrayLength(wal), includeNulls(false)
+	  shortForm(false), onlyLive(false), includeVerbose(true), wantArrayLength(wal), includeNulls(false), includeObsolete(true), obsoleteFieldQueried(false)
 {
 }
 
@@ -282,7 +285,8 @@ int32_t ObjectExplorationContext::GetLastIndex() const THROWS(GCodeException)
 bool ObjectExplorationContext::ShouldReport(const ObjectModelEntryFlags f) const noexcept
 {
 	return (!onlyLive || ((uint8_t)f & (uint8_t)ObjectModelEntryFlags::live) != 0)
-		&& (includeVerbose || ((uint8_t)f & (uint8_t)ObjectModelEntryFlags::verbose) == 0);
+		&& (includeVerbose || ((uint8_t)f & (uint8_t)ObjectModelEntryFlags::verbose) == 0)
+		&& (includeObsolete || ((uint8_t)f & (uint8_t)ObjectModelEntryFlags::obsolete) == 0);
 }
 
 GCodeException ObjectExplorationContext::ConstructParseException(const char *msg) const noexcept
@@ -771,6 +775,10 @@ ExpressionValue ObjectModel::GetObjectValue(ObjectExplorationContext& context, c
 		const ObjectModelTableEntry * const e = FindObjectModelTableEntry(classDescriptor, tableNumber, idString);
 		if (e != nullptr)
 		{
+			if (e->IsObsolete())
+			{
+				context.SetObsoleteFieldQueried();
+			}
 			idString = GetNextElement(idString);
 			const ExpressionValue val = e->func(this, context);
 			return GetObjectValue(context, classDescriptor, val, idString);
diff --git a/src/ObjectModel/ObjectModel.h b/src/ObjectModel/ObjectModel.h
index f400a60e..f46e54e7 100644
--- a/src/ObjectModel/ObjectModel.h
+++ b/src/ObjectModel/ObjectModel.h
@@ -162,6 +162,8 @@ enum class ObjectModelEntryFlags : uint8_t
 	// canAlter can be or'ed in
 	canAlter = 4,			// we can alter this value
 	liveCanAlter = 5,		// we can alter this value
+
+	obsolete = 8			// entry is deprecated and should not be used any more
 };
 
 // Context passed to object model functions
@@ -190,6 +192,9 @@ public:
 	bool ShouldIncludeNulls() const noexcept { return includeNulls; }
 	uint64_t GetStartMillis() const { return startMillis; }
 
+	bool ObsoleteFieldQueried() const noexcept { return obsoleteFieldQueried; }
+	void SetObsoleteFieldQueried() noexcept { obsoleteFieldQueried = true; }
+
 	GCodeException ConstructParseException(const char *msg) const noexcept;
 	GCodeException ConstructParseException(const char *msg, const char *sparam) const noexcept;
 
@@ -208,7 +213,9 @@ private:
 				onlyLive : 1,
 				includeVerbose : 1,
 				wantArrayLength : 1,
-				includeNulls : 1;
+				includeNulls : 1,
+				includeObsolete : 1,
+				obsoleteFieldQueried : 1;
 };
 
 // Entry to describe an array of objects or values. These must be brace-initializable into flash memory.
@@ -300,6 +307,9 @@ public:
 	// Return true if this object table entry matches a filter or query
 	bool Matches(const char *filter, const ObjectExplorationContext& context) const noexcept;
 
+	// Check if the queried field is obsolete
+	bool IsObsolete() const noexcept { return ((uint8_t)flags & (uint8_t)ObjectModelEntryFlags::obsolete) != 0; }
+
 	// See whether we should add the value of this element to the buffer, returning true if it matched the filter and we did add it
 	bool ReportAsJson(OutputBuffer* buf, ObjectExplorationContext& context, const ObjectModelClassDescriptor *classDescriptor, const ObjectModel *self, const char* filter, bool first) const noexcept;