Merge pull request #17 from nexdome/release/3.1.0

Release/3.1.0

Author: NameOfTheDragon

.vscode/c_cpp_properties.json

@@ -9,12 +9,14 @@
                 "C:\\Users\\Tim\\AppData\\Local\\Arduino15\\packages\\esp8266\\hardware\\esp8266\\2.4.2\\**",
                 "C:\\Users\\Tim\\AppData\\Local\\Arduino15\\packages\\arduino\\hardware\\avr\\1.6.209\\**",
                 "F:\\Arduino\\hardware\\arduino\\avr\\**",
-                "F:\\Arduino\\tools\\**"
+                "F:\\Arduino\\tools\\**",
+                "C:\\Users\\Tim\\AppData\\Local\\Arduino15\\packages\\arduino\\hardware\\avr\\1.6.23\\**"
             ],
             "forcedInclude": [
                 "C:\\Users\\Tim\\AppData\\Local\\Arduino15\\packages\\arduino\\hardware\\avr\\1.6.21\\cores\\arduino\\Arduino.h",
                 "C:\\Users\\Tim\\AppData\\Local\\Arduino15\\packages\\arduino\\hardware\\avr\\1.6.209\\cores\\arduino\\Arduino.h",
-                "F:\\Arduino\\hardware\\arduino\\avr\\cores\\arduino\\Arduino.h"
+                "F:\\Arduino\\hardware\\arduino\\avr\\cores\\arduino\\Arduino.h",
+                "C:\\Users\\Tim\\AppData\\Local\\Arduino15\\packages\\arduino\\hardware\\avr\\1.6.23\\cores\\arduino\\Arduino.h"
             ],
             "intelliSenseMode": "msvc-x64"
         }

SharedCode/Response.cpp

@@ -38,6 +38,6 @@ Response Response::NoResponse(Command& command)
 	return Response{ "" };
 	}
 
-const std::string Response::terminator = "#";
-const std::string Response::header = ":";
+const char Response::terminator = '#';
+const char Response::header = ':';
 

SharedCode/Response.h

@@ -11,8 +11,8 @@
 
 struct Response
 {
-	static const std::string terminator;
-	static const std::string header;
+	static const char terminator;
+	static const char header;
 	std::string Message;
 
 	friend std::ostream& operator<<(std::ostream&, const Response&);

TA.NexDome.Rotator/CommandProcessor.cpp

@@ -8,6 +8,22 @@
 CommandProcessor::CommandProcessor(MicrosteppingMotor& rotator, PersistentSettings& settings, XBeeStateMachine& machine)
 	: rotator(rotator), settings(settings), machine(machine) { }
 
+/*
+ * Sends an encapsulated response to the host application
+ */
+void CommandProcessor::responseToHost(const std::string& rxMessage)
+	{
+	auto length = rxMessage.length();
+	if (length < 1) return;
+	if (rxMessage[0] != ':')
+		std::cout << ':';
+	std::cout << rxMessage;
+	if (rxMessage[length - 1] != '#')
+		std::cout << '#';
+	std::cout << std::endl;
+	}
+
+
 Response CommandProcessor::HandleDR(Command& command) const
 	{
 	const auto deadZone = getDeadZoneWholeSteps();
@@ -39,6 +55,8 @@ Response CommandProcessor::HandleHW(Command& command) const
 
 void CommandProcessor::sendStatus() const
 	{
+	if (HomeSensor::homingInProgress())
+		return;
 	const char separator = ',';
 	std::ostringstream status;
 	status << std::dec << ":SER,"
@@ -61,6 +79,8 @@ void CommandProcessor::sendDirection(const int direction)
 		std::cout << Response::header << clockwise << Response::terminator << std::endl;
 	}
 
+
+
 Response CommandProcessor::ForwardToShutter(Command& command) const
 	{
 	machine.SendToRemoteXbee(command.RawCommand);
@@ -121,9 +141,9 @@ Response CommandProcessor::HandleGA(Command& command) const
 	const auto currentPosition = rotator.getCurrentPosition();
 	const auto delta = target - currentPosition;
 	const auto direction = sgn(delta);
-	std::cout << delta << " [" << settings.deadZone << "]" << std::endl;
 	if (abs(delta) >= settings.deadZone)
 		{
+		HomeSensor::cancelHoming();
 		sendDirection(direction);
 		rotator.moveToPosition(target);
 		}

TA.NexDome.Rotator/CommandProcessor.h

@@ -18,6 +18,7 @@ class CommandProcessor
 	{
 public:
 	CommandProcessor(MicrosteppingMotor& rotator, PersistentSettings& settings, XBeeStateMachine& machine);
+	static void responseToHost(const std::string& rxMessage);
 	Response HandleDR(Command& command) const;
 	Response HandleDW(Command& command) const;
 	Response HandleCommand(Command& command) const;

TA.NexDome.Rotator/HomeSensor.cpp

@@ -1,11 +1,11 @@
 /*
  * Provides interrupt processing for the home sensor.
- * 
+ *
  * The home sensor synchronizes the dome rotation step position when it is triggered.
  * When rotating in the positive direction, we synchronise to the falling edge.
  * When rotating in the negative direction, we synchronise to the rising edge.
  * When not rotating, activity is ignored.
- * 
+ *
  * Note: some fields have to be static because they are used during interrupts
  */
 
@@ -14,11 +14,9 @@
 
 #pragma region static fields used within interrupt service routines
 MicrosteppingMotor* HomeSensor::motor;
-Home* HomeSensor::settings;
+Home* HomeSensor::homeSettings;
 uint8_t HomeSensor::sensorPin;
-volatile bool HomeSensor::state;
-volatile bool HomeSensor::homingInProgress;
-volatile bool HomeSensor::performingPostHomeSlew;
+volatile HomingPhase HomeSensor::phase;
 #pragma endregion
 
 /*
@@ -31,7 +29,7 @@ HomeSensor::HomeSensor(MicrosteppingMotor* stepper, Home* settings, const uint8_
 	: commandProcessor(processor)
 	{
 	motor = stepper;
-	HomeSensor::settings = settings;
+	HomeSensor::homeSettings = settings;
 	HomeSensor::sensorPin = sensorPin;
 	}
 
@@ -42,19 +40,9 @@ HomeSensor::HomeSensor(MicrosteppingMotor* stepper, Home* settings, const uint8_
  */
 void HomeSensor::onHomeSensorChanged()
 	{
-	state = digitalRead(sensorPin);
-	if (homingInProgress)
+	const auto state = digitalRead(sensorPin);
+	if (state == 0 && phase==Detecting)
 		foundHome();
-	//if (!motor->isMoving()) // Ignore state change if rotator not moving
-	//	return;
-	//const auto direction = motor->getCurrentDirection();
-	//if ((state && direction < 0) || (!state && direction > 0))
-	//	{
-	//	// sync position on either the rising or falling edge, depending on rotation direction.
-	//	motor->SetCurrentPosition(settings->position);
-	//	if (homingInProgress)
-	//		foundHome();
-	//	}
 	}
 
 /*
@@ -63,67 +51,87 @@ void HomeSensor::onHomeSensorChanged()
 void HomeSensor::init()
 	{
 	pinMode(sensorPin, INPUT_PULLUP);
-	state = digitalRead(sensorPin);
-	homingInProgress = false;
-	performingPostHomeSlew = false;
+	setPhase(Idle);
 	attachInterrupt(digitalPinToInterrupt(sensorPin), onHomeSensorChanged, CHANGE);
 	}
 
 
+/// <summary>
+/// Indicates whether the dome is currently in the home position
+/// (only valid after a successful homing operation and before and slews occur)
+/// </summary>
 bool HomeSensor::atHome()
 	{
-	return !state && !homingInProgress && !performingPostHomeSlew;
+	return phase == AtHome;
+	}
+
+void HomeSensor::setPhase(HomingPhase newPhase)
+	{
+	phase = newPhase;
+	Serial.print("Phase ");
+	Serial.println(phase);
 	}
 
 /*
  * Rotates up to 2 full rotations clockwise while attempting to detect the home sensor.
+ * Ignored if a homing operation is already in progress.
  */
 void HomeSensor::findHome(int direction)
 	{
-	homingInProgress = true;
-	performingPostHomeSlew = false;
-	const auto distance = 2 * settings->microstepsPerRotation;	// Allow 2 full rotations only
-	motor->moveToPosition(distance);
+	if (phase == Idle || phase == AtHome)
+		{
+		const auto distance = 2 * homeSettings->microstepsPerRotation;	// Allow 2 full rotations only
+		setPhase(Detecting);
+		motor->moveToPosition(distance);
+		}
 	}
 
 /*
  * Stops a homing operation in progress.
  */
 void HomeSensor::cancelHoming()
 	{
-	performingPostHomeSlew = false;
-	homingInProgress = false;
+	setPhase(Idle);
 	if (motor->isMoving())
 		motor->SoftStop();
 	}
 
 /*
  * Once the home sensor has been detected, we instruct the motor to soft-stop.
- * We also set the flaf performingPostHomeSlew.
+ * We also set the flag performPostHomeSlew.
  * At some point in the future, the onMotorStopped method will be called, which will
  * then initiate the final slew to return exactly to the home sensor position.
  */
 void HomeSensor::foundHome()
 	{
-	std::cout << "foundHome" << std::endl;
-	motor->SetCurrentPosition(settings->position);
-	homingInProgress = false;
-	performingPostHomeSlew = true;
+	setPhase(Stopping);
+	motor->SetCurrentPosition(homeSettings->position);
 	motor->SoftStop();
 	}
 
-void HomeSensor::onMotorStopped()
+/*
+ * Handles the onMotorStopped event. Action depends on the homing phase.
+ */
+void HomeSensor::onMotorStopped() const
 	{
-	std::cout << "onMotorStopped" << std::endl;
-	homingInProgress = false;
-	if (performingPostHomeSlew)
+	std::cout << "Hstop " << phase << std::endl;
+	switch (phase)
 		{
-		performingPostHomeSlew = false;
-		const auto target = commandProcessor.targetStepPosition(settings->position);
-		std::cout << "Post slew from "
-			<< motor->getCurrentPosition()
-			<< " to " << target
-			<< std::endl;
-		motor->moveToPosition(target);
+		case Reversing:
+			setPhase(AtHome);
+			break;
+		case Stopping:
+			setPhase(Reversing);
+			const auto target = commandProcessor.targetStepPosition(homeSettings->position);
+			motor->moveToPosition(target);
+			break;
+		default:
+			setPhase(Idle);
+			return;
 		}
 	}
+
+bool HomeSensor::homingInProgress()
+	{
+	return !(phase == Idle || phase == AtHome);
+	}

TA.NexDome.Rotator/HomeSensor.h

@@ -12,12 +12,21 @@
 #include <AdvancedStepper.h>
 #include "CommandProcessor.h"
 
+enum HomingPhase
+	{
+	Idle = 0,
+	Detecting,
+	Stopping,
+	Reversing,
+	AtHome,
+	};
+
 struct Home
 	{
 	int32_t position;	// Home sensor azimuth in microsteps
 	unsigned int width;
 	int32_t microstepsPerRotation;
-	Home(int32_t stepPosition, unsigned width, int32_t circumferenceMicrosteps) 
+	Home(int32_t stepPosition, unsigned width, int32_t circumferenceMicrosteps)
 		: position(stepPosition), width(width), microstepsPerRotation(circumferenceMicrosteps) {}
 	};
 
@@ -29,17 +38,17 @@ class HomeSensor
 	static bool atHome();
 	static void findHome(int direction);
 	static void cancelHoming();
-	static void foundHome();
-	void onMotorStopped();
+	void onMotorStopped() const;
+	static bool homingInProgress();
 private:
+	static volatile HomingPhase phase;
 	static uint8_t sensorPin;
-	static volatile bool state;
 	static MicrosteppingMotor* motor;
-	static Home* settings;
+	static Home* homeSettings;
 	CommandProcessor& commandProcessor;
+	static void foundHome();
 	static void onHomeSensorChanged();
-	static volatile bool homingInProgress;
-	static volatile bool performingPostHomeSlew;
+	static void setPhase(HomingPhase newPhase);
 	};
 
 

TA.NexDome.Rotator/PersistentSettings.cpp

@@ -1,6 +1,6 @@
-// 
-// 
-// 
+//
+//
+//
 
 #include <EEPROM.h>
 #include "NexDome.h"
@@ -21,25 +21,20 @@ PersistentSettings::PersistentSettings() :
 
 /*
 	Saves persistent settings to EEPROM.
-	Uses update rather than write in an attempt to minimize unnecessary
-	write cycles.
-	Writes a 16-bit fingerprint into the first two EEPROM locations to indicate
-	that valid settings exist.
+	Uses update rather than write in an attempt to minimize unnecessary write cycles.
+	The settings structure already includes the fingerprint. This is validated on loading.
 */
 void PersistentSettings::Save()
 	{
 	uint16_t* destination = 0;
 	const auto source = reinterpret_cast<const byte*>(this);
 	const auto byteCount = sizeof(PersistentSettings);
 	eeprom_update_block(source, destination, byteCount);
-	// Now write a "fingerprint" immediately after the settings.
-	destination += sizeof(PersistentSettings);
-	eeprom_update_word(destination, fingerprint);
 	}
 
 /*
 	Loads and returns persistent settings from EEPROM.
-	The fingerprint must be valid, and the loaded settings must have the same
+	The fingerprints must be valid, and the loaded settings must have the same
 	major version as the firmware version. If these conditions are not met
 	then default settings will be used.
 */
@@ -50,9 +45,8 @@ PersistentSettings PersistentSettings::Load()
 	auto loadedSettings = PersistentSettings();
 	eeprom_read_block(&loadedSettings, source, sizeof(PersistentSettings));
 	// Read the fingerprint and make sure it is valid
-	source += sizeof(PersistentSettings);
-	auto eepromFingerprint = eeprom_read_word(source);
-	if (eepromFingerprint != fingerprint)
+
+	if (loadedSettings.fingerprintHead != fingerprint || loadedSettings.fingerprintTail != fingerprint )
 		return defaultSettings;	// use defaults if fingerprint is invalid
 	// Ensure that the firmware major version is the same as when the settings were saved.
 	if (loadedSettings.majorVersion != MajorVersion)

TA.NexDome.Rotator/PersistentSettings.h

@@ -13,14 +13,16 @@
 #include "HomeSensor.h"
 #include "Version.h"
 
+constexpr uint16_t fingerprint = 0x4AFB;
 struct PersistentSettings
 {
-	static const uint16_t fingerprint = 0x4AFB;
+	uint16_t fingerprintHead = fingerprint;
 	uint8_t majorVersion = MajorVersion;
 	uint8_t minorVersion = MinorVersion;
 	struct MotorSettings motor{};
 	struct Home home;
 	int deadZone = 1000;
+	uint16_t fingerprintTail = fingerprint;
 	PersistentSettings();
 	static PersistentSettings Load();
 	void Save();