Implemented and fixed many issues

Source/Components/GAMs/TimeArrayGAM/TimeArrayGAM.cpp

@@ -16,6 +16,10 @@ TimeArrayGAM::TimeArrayGAM() :
         GAM(),
         samplingRate(1000000.0),
         anchorIsFirst(true),
+        anchorIsCont(false),
+        contStarted(false),
+        contOriginNs(0u),
+        contSamples(0u),
         nElements(0u),
         inputTime(NULL_PTR(uint32 *)),
         outputBuf(NULL_PTR(uint64 *)) {
@@ -42,9 +46,12 @@ bool TimeArrayGAM::Initialise(StructuredDataI &data) {
         else if (anchor == "LastSample") {
             anchorIsFirst = false;
         }
+        else if (anchor == "Continuous") {
+            anchorIsCont = true;
+        }
         else {
             REPORT_ERROR(ErrorManagement::InitialisationError,
-                         "TimeArrayGAM: Anchor must be 'FirstSample' or 'LastSample'.");
+                         "TimeArrayGAM: Anchor must be 'FirstSample', 'LastSample' or 'Continuous'.");
             ok = false;
         }
     }
@@ -88,7 +95,21 @@ bool TimeArrayGAM::Execute() {
     /* Input is uint32 microseconds (LinuxTimer); convert to nanoseconds. */
     uint64 anchorNs  = static_cast<uint64>(*inputTime) * 1000u;
 
-    if (anchorIsFirst) {
+    if (anchorIsCont) {
+        /* Latch the timer once, then run off an internal sample counter so a
+         * lost RT cycle (LinuxTimer re-phases with counter += nCycles) cannot
+         * punch a hole into an otherwise contiguous sample stream. */
+        if (!contStarted) {
+            contOriginNs = anchorNs;
+            contStarted  = true;
+        }
+        for (uint32 k = 0u; k < nElements; k++) {
+            outputBuf[k] = contOriginNs +
+                           (contSamples + static_cast<uint64>(k)) * periodNs;
+        }
+        contSamples += static_cast<uint64>(nElements);
+    }
+    else if (anchorIsFirst) {
         /* out[k] = anchorNs + k * periodNs */
         for (uint32 k = 0u; k < nElements; k++) {
             outputBuf[k] = anchorNs + static_cast<uint64>(k) * periodNs;

Source/Components/GAMs/TimeArrayGAM/TimeArrayGAM.h

@@ -10,6 +10,15 @@
  *
  *   Anchor = FirstSample:  out[k] = input + k * period_us
  *   Anchor = LastSample:   out[k] = input - (N-1-k) * period_us
+ *   Anchor = Continuous:   out[k] = input(first cycle) + (n + k) * period_us
+ *
+ * FirstSample/LastSample re-read the timer every cycle, so they propagate any
+ * cycle the RT thread loses: LinuxTimer re-phases (counter += nCycles) and the
+ * emitted time base jumps by a whole period while only one array of samples is
+ * produced, leaving a hole. Continuous anchors once and then advances an
+ * internal sample counter by N per cycle, which is what an acquisition card
+ * with its own clock does — use it when the data signal is itself contiguous
+ * (SineArrayGAM, for instance, never skips phase on a lost cycle).
  *
  * The resulting time array is suitable as the TimeSignal for a UDPStreamer signal
  * configured with TimeMode = FullArray, providing exact per-sample timestamps.
@@ -19,7 +28,7 @@
  * +TimeArrayGAM1 = {
  *     Class         = TimeArrayGAM
  *     SamplingRate  = 1000000.0    // Sample rate in Hz (must match data signal)
- *     Anchor        = FirstSample  // FirstSample (default) or LastSample
+ *     Anchor        = FirstSample  // FirstSample (default), LastSample or Continuous
  *     InputSignals = {
  *         Time = { DataSource = DDB; Type = uint32 }
  *     }
@@ -54,6 +63,10 @@ public:
 private:
     float64  samplingRate;   /**< Sample rate [Hz] */
     bool     anchorIsFirst;  /**< true = FirstSample anchor, false = LastSample */
+    bool     anchorIsCont;   /**< true = Continuous anchor (internal sample counter) */
+    bool     contStarted;    /**< Continuous: origin has been latched */
+    uint64   contOriginNs;   /**< Continuous: timer value latched on the first cycle */
+    uint64   contSamples;    /**< Continuous: samples emitted so far */
     uint32   nElements;      /**< Number of output elements */
     uint32  *inputTime;      /**< Pointer to scalar input (microseconds, uint32 from LinuxTimer) */
     uint64  *outputBuf;      /**< Pointer to output array (nanoseconds, uint64) */