task: count a G28.2 homing run that ends between two status reads

Task decided that a queued home had started by catching homing_active or
a joint's .homing in one of its status reads. Homing in place takes a
few servo cycles, so a run could start and end between two reads. On a
re-home the joints read homed before and after it, and after 2s task
reported "G28.2 home did not start" for a home that had run.

Motion now counts homing_active going true in homing_runs, and task
treats a changed count as started. A home that motion refuses leaves
the count alone, so the start timeout still reports it.

Part of #4669.

Author: grandixximo

src/emc/motion/control.c

@@ -2273,6 +2273,9 @@ static void update_status(void)
     }
 
     emcmotStatus->jogging_active = hal_get_bool(emcmot_hal_data->jog_is_active);
+    if (get_homing_is_active() && !emcmotStatus->homing_active) {
+        emcmotStatus->homing_runs++;
+    }
     emcmotStatus->homing_active = get_homing_is_active();
 
     /*! \todo FIXME - the rest of this function is stuff that was apparently

src/emc/motion/motion.h

@@ -683,6 +683,9 @@ Suggestion: Split this in to an Error and a Status flag register..
 			   Aggregate: stays true across the gap between
 			   HOME_SEQUENCE groups, when every joint's per-joint
 			   .homing flag is momentarily false. */
+    unsigned int homing_runs; /* counts homing_active going true, so a run
+			   that starts and ends between two status reads
+			   still shows */
 
 	int    switchkins_seq;  /* echoes the config counter once acted on */
 	int    switchkins_type; /* switchkins type now in force */

src/emc/nml_intf/emc.cc

@@ -1843,6 +1843,7 @@ void EMC_MOTION_STAT::update(CMS * cms)
     cms->update(numExtraJoints);
     cms->update(jogging_active);
     cms->update(homing_active);
+    cms->update(homing_runs);
     cms->update(heartbeat);
 }
 

src/emc/nml_intf/emc_nml.hh

@@ -1190,6 +1190,10 @@ class EMC_MOTION_STAT:public EMC_MOTION_STAT_MSG {
     // groups, where every joint momentarily reads .homing == false while the
     // machine is still homing (see the race note in motion/homing.c).
     bool homing_active;
+    // counts homing_active going true; a homing run shorter than the gap
+    // between two status reads leaves this changed even if homing_active
+    // never read true
+    unsigned int homing_runs;
     uint64_t heartbeat;  // motion controller's heartbeat counter
 
 };

src/emc/nml_intf/emcops.cc

@@ -127,6 +127,7 @@ EMC_MOTION_STAT::EMC_MOTION_STAT()
     numExtraJoints(0),
     jogging_active(0),
     homing_active(false),
+    homing_runs(0),
     heartbeat(0)
 {
 }

src/emc/task/emctaskmain.cc

@@ -418,6 +418,7 @@ static int homingWaitJoint = -1;         // joint (-1 = all) we're waiting on
 static bool homingWaiting = false;       // true while EMC_TASK_EXEC::WAITING_FOR_HOMING is active
 static bool homingStarted = false;       // true once we've observed .homing go true at least once
 static double homingIssueTime = 0.0;     // etime() when issued, for the start-timeout below
+static unsigned int homingRunsAtIssue = 0; // motion's homing_runs before the home was issued
 // Some motion-side guards (e.g. "must be in joint mode to home",
 // motion.homing-inhibit, already-homing) reject with reportError() and a
 // bare return, without setting commandStatus to a failure -- so a rejected
@@ -1744,6 +1745,7 @@ static int emcTaskIssueCommand(NMLmsg * cmd)
 	    homingWaitJoint = target_joint;
 	    homingStarted = false;
 	    homingIssueTime = etime();
+	    homingRunsAtIssue = emcStatus->motion.homing_runs;
 	    homingWaiting = true;
 	    retval = emcJointHome(target_joint);
 	    if (retval != 0) {
@@ -2926,6 +2928,13 @@ static int emcTaskExecute(void)
 		homingStarted = true;
 		break; // still running; no timeout once started (see HOMING_START_TIMEOUT comment)
 	    }
+	    // A short run (homing in place takes a few servo cycles) can start
+	    // and end between two of task's status reads. On a re-home the
+	    // joints read homed before and after it, so only motion's run
+	    // counter shows that it happened.
+	    if (emcStatus->motion.homing_runs != homingRunsAtIssue) {
+		homingStarted = true;
+	    }
 	    if (!homingStarted) {
 		// Never observed homing go active: motion silently rejected
 		// it (a guard like "must be in joint mode", or

src/emc/task/taskintf.cc

@@ -2149,6 +2149,7 @@ int emcMotionUpdate(EMC_MOTION_STAT * stat)
 
     stat->jogging_active = emcmotStatus.jogging_active;
     stat->homing_active = emcmotStatus.homing_active;
+    stat->homing_runs = emcmotStatus.homing_runs;
     stat->numExtraJoints = emcmotStatus.numExtraJoints;
 
     // set the status flag