LinkTM-Capture-Software-12.15/Reference-Documentation/pps_example.c-Source-File

/*
 *
 * Copyright 2025 Napatech A/S. All Rights Reserved.
 *
 * 1. Copying, modification, and distribution of this file, or executable
 * versions of this file, is governed by the terms of the Napatech Software
 * license agreement under which this file was made available. If you do not
 * agree to the terms of the license do not install, copy, access or
 * otherwise use this file.
 *
 * 2. Under the Napatech Software license agreement you are granted a
 * limited, non-exclusive, non-assignable, copyright license to copy, modify
 * and distribute this file in conjunction with Napatech SmartNIC's and
 * similar hardware manufactured or supplied by Napatech A/S.
 *
 * 3. The full Napatech Software License Agreement is included in this
 * distribution, please see "NA-0009 Software License Agreement.pdf"
 *
 * 4. Redistributions of source code must retain this copyright notice,
 * list of conditions and the following disclaimer.
 *
 * THIS SOFTWARE IS PROVIDED "AS IS" WITHOUT ANY WARRANTIES, EXPRESS OR
 * IMPLIED, AND NAPATECH DISCLAIMS ALL IMPLIED WARRANTIES INCLUDING ANY
 * IMPLIED WARRANTY OF TITLE, MERCHANTABILITY, NONINFRINGEMENT, OR OF
 * FITNESS FOR A PARTICULAR PURPOSE. TO THE EXTENT NOT PROHIBITED BY
 * APPLICABLE LAW, IN NO EVENT SHALL NAPATECH BE LIABLE FOR PERSONAL INJURY,
 * OR ANY INCIDENTAL, SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES WHATSOEVER,
 * INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF PROFITS, CORRUPTION OR
 * LOSS OF DATA, FAILURE TO TRANSMIT OR RECEIVE ANY DATA OR INFORMATION,
 * BUSINESS INTERRUPTION OR ANY OTHER COMMERCIAL DAMAGES OR LOSSES, ARISING
 * OUT OF OR RELATED TO YOUR USE OR INABILITY TO USE NAPATECH SOFTWARE OR
 * SERVICES OR ANY THIRD PARTY SOFTWARE OR APPLICATIONS IN CONJUNCTION WITH
 * THE NAPATECH SOFTWARE OR SERVICES, HOWEVER CAUSED, REGARDLESS OF THE THEORY
 * OF LIABILITY (CONTRACT, TORT OR OTHERWISE) AND EVEN IF NAPATECH HAS BEEN
 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. SOME JURISDICTIONS DO NOT ALLOW
 * THE EXCLUSION OR LIMITATION OF LIABILITY FOR PERSONAL INJURY, OR OF
 * INCIDENTAL OR CONSEQUENTIAL DAMAGES, SO THIS LIMITATION MAY NOT APPLY TO YOU.
 *
 *

 */

/**
 * @example pps/pps_example.c
 * @section pps_example_description Description
 *
 * This source file is an example of how to use the PPS functionality.
 *
 * The following NTAPI functions are used:
 * - @ref NT_Init()
 * - @ref NT_ConfigOpen()
 * - @ref NT_ConfigWrite()
 * - @ref NT_ConfigRead()
 * - @ref NT_ConfigClose()
 * - @ref NT_ExplainError()
 *
 * <hr>
 * @section pps_example_prerequisites Prerequisites
 * A working system is needed.
 *
 * @section pps_example_flow Program flow
 * @{
 * The following is required to perform read and write operations on
 * the @ref ConfigStream "configuration stream":
 * - \#include/nt.h - Applications/Tools only need to include @ref
 *   nt.h to obtain prototypes, macros etc. from NTAPI.
 * - @ref NT_Init(@ref NTAPI_VERSION) - Initialize the NTAPI
 *   library. @ref NTAPI_VERSION is a define that describes the version
 *   of the API described in the header files included by @ref
 *   nt.h. NT_Init() will ask the NTAPI library to convert return data
 *   to the @ref NTAPI_VERSION if possible. This will ensure that
 *   applications can run on NTAPI libraries of newer versions.
 * - @ref NT_ConfigOpen() - Open a configuration stream.
 * - @ref NT_ConfigRead() - Read configuration.
 * - @ref NT_ConfigWrite() - Write configuration.
 * - @ref NT_ConfigClose() - Close the stream when terminating.
 *
 *<hr>
 * @}
 */

// Include this in order to access the Napatech API
#include <nt.h>

#if defined(WIN32) || defined (WIN64)
  #include <winsock2.h>
  #include <sys/timeb.h>
#else
  #include <signal.h>
  #include <sys/time.h>
  #include <unistd.h> // sleep()
  #include <stdatomic.h>
#endif

#include <stdlib.h>
#include <time.h>

#define MAX_TS_CARDS 4

typedef struct TimeSync_s{
  unsigned timeSyncEnabled;
  unsigned timeSyncConStatus;
} TimeSync_t;

TimeSync_t TS_os[MAX_TS_CARDS];


#if defined(WIN32) || defined (WIN64)
static volatile int appRunning = 1; // The application will run as long as appRunning == 1
#else
static atomic_int appRunning = 1;   // The application will run as long as appRunning == 1
#endif


#if defined(WIN32) || defined (WIN64)

#if defined(_MSC_VER)
  struct timezone {
    int tz_minuteswest;     /* minutes west of Greenwich */
    int tz_dsttime;         /* type of DST correction */
  };
#endif // _MSC_VER

  int gettimeofday(struct timeval *tv, struct timezone *tz);

#endif


#define NT_CONST64(a) a##ULL
#define UNIX_EPOCH_OFFSET_MAGIC 116444736000000000ULL

/**
 * 32bit struct timeval. Used because our HW is only 32bit PCAP compatible
 */
struct nttimeval
{
  uint32_t tv_sec;
  uint32_t  tv_usec;
};

// Forward declarations
int PpsGetOsTime(uint64_t *osTime);
int PrintTimestamp(uint64_t timeValue);
int PpsPrintStatusAndTime(int i, uint64_t timeSyncPpsSampled, int64_t timeSyncTimeSkew);


/*
 * The function called when user is pressing CTRL-C
 */
#if defined(WIN32) || defined (WIN64)
static BOOL WINAPI StopApplication(int sig)
{
  (void) sig;
  appRunning = 0;
  return TRUE;
}
#else
static void StopApplication(int sig)
{
  if (sig == SIGINT)
    appRunning = 0;
}
#endif


/*
 * This function returns the OS time in seconds.
 * ----------------------------------------------------------------------*/
int                                /* Ret Result.                        */
PpsGetOsTime(uint64_t *osTime)     /* Seconds since 1. jan 1970.         */
{
  struct timeval timeofday;
  struct timezone timeZone;
  int result;

  result = gettimeofday(&timeofday, &timeZone);

  *osTime = (uint64_t)(timeofday.tv_sec & 0xFFFFFFFF);
  return result;
}


int PrintTimestamp(uint64_t timeValue)
{
  time_t   timeT;
  struct tm *ptm;
  char wday[7][4]={"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"};
  char wmon[12][4]={"Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};

  timeT = (time_t)(timeValue/1000000000ULL);
  ptm = gmtime(&timeT);
  if (ptm == NULL) {
    printf("Time is invalid");
  } else {
    printf("UTC Time : %s %d-%s-%d %02d:%02d:%02d.%09lld",
            wday[ptm->tm_wday], ptm->tm_mday, wmon[ptm->tm_mon], ptm->tm_year+1900,
            ptm->tm_hour, ptm->tm_min, ptm->tm_sec, ((unsigned long long)timeValue%100000000));
  }
  return 0;
}


int PpsPrintStatusAndTime(int i, uint64_t timeSyncPpsSampled, int64_t timeSyncTimeSkew)
{
  /* Check if more than 100 milli seconds off and conclude loss of SYNC */
  if ((timeSyncTimeSkew < -100000000) ||
      (timeSyncTimeSkew > 100000000)) {
      printf("%d: PPS not in SYNC: ", i);
  } else {
    /* Check if more than 1 milli second off and conclude trying to SYNC */
    if ((timeSyncTimeSkew < -1000000) ||
        (timeSyncTimeSkew > 1000000)) {
      printf("%d PPS SYNCING:     ", i);
    } else {
      /* Less than 1 milli second off, conclude it's in SYNC */
      printf("%d PPS in SYNC:     ", i);
    }
  }

  PrintTimestamp(timeSyncPpsSampled);
  printf("   ClockSkew   : %13lld nano seconds          \n", (long long)(timeSyncTimeSkew));
  return 0;
}


int main(void)
{
  int i;
  int32_t status;
  uint32_t timeout = 1000;
  uint64_t osTime;
  uint64_t helpTime;
  uint64_t printTime=0;
  NtInfoStream_t hInfoStream;  // Info stream handle
  NtEventStream_t hEventStream;
  NtConfigStream_t hConfigStream;
  NtInfo_t hInfo;              // Info handle
  NtEvent_t hEvent;
  NtConfig_t configInfo;
  char errorBuffer[NT_ERRBUF_SIZE];
  int numAdapters=0;
  int found=0;

  // Register ctrl+c handler so we are able to stop again
#if defined(WIN32) || defined (WIN64)
  SetConsoleCtrlHandler((PHANDLER_ROUTINE)StopApplication, TRUE);
#else
  struct sigaction newaction; // Ctrl+c signal handler container
  memset(&newaction, 0, sizeof(newaction));
  newaction.sa_handler = StopApplication;
  if (sigaction(SIGINT, &newaction, NULL) < 0) {
    fprintf(stderr, "Failed to register SIGINT sigaction.\n");
    exit(EXIT_FAILURE);
  }
#endif

  printf("Running the PPS example.\n\n");

  if ((status = NT_Init(NTAPI_VERSION)) != NT_SUCCESS) {
    // Get the status code as text
    NT_ExplainError(status, errorBuffer, sizeof(errorBuffer));
    fprintf(stderr, "NT_Init() failed: %s\n", errorBuffer);
    return -1;
  }

  /* Init local variables */
  for (i=0;i<MAX_TS_CARDS;i++) {
    TS_os[i].timeSyncConStatus = NT_TIMESYNC_CONNECTOR_STATUS_NONE;
  }

  printf("Opening info stream\n");
  /* Open the info stream */
  if ((status = NT_InfoOpen(&hInfoStream, "InfoPps")) != NT_SUCCESS) {
    // Get the status code as text
    NT_ExplainError(status, errorBuffer, sizeof(errorBuffer));
    fprintf(stderr, "NT_ConfigRead() failed: %s\n", errorBuffer);
    return -1;
  }
  printf("Info stream opened successfully\n");

  /* Read number of adapters */
  hInfo.cmd=NT_INFO_CMD_READ_SYSTEM;
  if ((status = NT_InfoRead(hInfoStream, &hInfo)) != 0) {
    // Get the status code as text
    NT_ExplainError(status, errorBuffer, sizeof(errorBuffer));
    fprintf(stderr, "NT_ConfigRead() failed: %s\n", errorBuffer);
    return -1;
  }

  numAdapters = hInfo.u.system.data.numAdapters;

  printf("Found %d adapters\n", numAdapters);

  for (i=0;i<numAdapters;i++) {
    /* Read timesync info */
    hInfo.cmd=NT_INFO_CMD_READ_TIMESYNC_V4;
    hInfo.u.timeSync_v4.adapterNo = (uint8_t)i;
    if ((status = NT_InfoRead(hInfoStream, &hInfo)) != NT_SUCCESS) {
      // Get the status code as text
      NT_ExplainError(status, errorBuffer, sizeof(errorBuffer));
      fprintf(stderr, "Failed to read timesync info: %s\n", errorBuffer);
      return -1;
    }

    /* Print timesync info */
    printf("Adapter %d:\n", i);
    printf("  TimeSync reference priority: %d, %d, %d\n", hInfo.u.timeSync_v4.data.tsRefPrio[0],
            hInfo.u.timeSync_v4.data.tsRefPrio[1], hInfo.u.timeSync_v4.data.tsRefPrio[2]);
    printf("  TimeSync reference: %d\n", hInfo.u.timeSync_v4.data.timeRef);
    printf("  TimeSync connector Ext1: %d\n", hInfo.u.timeSync_v4.data.timeSyncConnectorExt1);
    printf("  TimeSync connector Int1: %d\n", hInfo.u.timeSync_v4.data.timeSyncConnectorInt1);
    printf("  TimeSync connector Int2: %d\n", hInfo.u.timeSync_v4.data.timeSyncConnectorInt2);
    if (hInfo.u.timeSync_v4.data.timeSyncClockAdjustmentMode == 1) {
      printf("  TimeSync Time Jump (s): %d\n", hInfo.u.timeSync_v4.data.timeSyncTimeJumpThreshold);
    } else {
      printf("  TimeSync Time Jump Allowed : %d\n", hInfo.u.timeSync_v4.data.timeSyncHardReset);
    }
    printf("  TimeSync Time Offset (ns): %d\n\n", hInfo.u.timeSync_v4.data.timeSyncTimeOffset);

    // Check if the adapter is configured for PPS
    if (((hInfo.u.timeSync_v4.data.tsRefPrio[0] == NT_TIMESYNC_REFERENCE_INT1) &&
         (hInfo.u.timeSync_v4.data.timeSyncConnectorInt1 == NT_TIMESYNC_CONNECTOR_SETTING_PPS_IN)) ||
        ((hInfo.u.timeSync_v4.data.tsRefPrio[0] == NT_TIMESYNC_REFERENCE_INT2) &&
         (hInfo.u.timeSync_v4.data.timeSyncConnectorInt2 == NT_TIMESYNC_CONNECTOR_SETTING_PPS_IN)) ||
        ((hInfo.u.timeSync_v4.data.tsRefPrio[0] == NT_TIMESYNC_REFERENCE_EXT1) &&
         (hInfo.u.timeSync_v4.data.timeSyncConnectorExt1 == NT_TIMESYNC_CONNECTOR_SETTING_PPS_IN))) {
      found = 1;
      TS_os[i].timeSyncEnabled = 1;

      // Read the Timestamp type from the adapter
      hInfo.cmd=NT_INFO_CMD_READ_ADAPTER_V7;
      hInfo.u.adapter_v7.adapterNo = (uint8_t) i;
      if ((status = NT_InfoRead(hInfoStream, &hInfo)) != NT_SUCCESS) {
        // Get the status code as text
        NT_ExplainError(status, errorBuffer, sizeof(errorBuffer));
        fprintf(stderr, "NT_InfoRead() failed: %s\n", errorBuffer);
        return -1;
      }

      // Check that Timestamp type is set to Native UNIX
      if (hInfo.u.adapter_v7.data.timestampType != NT_TIMESTAMP_TYPE_NATIVE_UNIX) {
        fprintf(stderr, "Timestamp should be Native UNIX, please configure in the Ntservice.ini file.\n");
        return -1;
      }
    }
  }

  if (found == 0) {
    fprintf(stderr, "No PPS Enabled adapters found! Please configure PPS in ntservice.ini\n");
    return -1;
  }

  /* Open the event stream */
  if ((status = NT_EventOpen(&hEventStream, "PpsEvent", NT_EVENT_SOURCE_TIMESYNC)) != NT_SUCCESS) {
    // Get the status code as text
    NT_ExplainError(status, errorBuffer, sizeof(errorBuffer));
    fprintf(stderr, "NT_EventOpen() failed: %s\n", errorBuffer);
    return -1;
  }

  // Open the config stream
  if ((status = NT_ConfigOpen(&hConfigStream, "CONFIG"))) {
    // Get the status code as text
    NT_ExplainError(status, errorBuffer, sizeof(errorBuffer));
    fprintf(stderr, "NT_ConfigOpen() failed: %s\n", errorBuffer);
    return -1;
  }

  // Enable PPS
  for (i=0;i<numAdapters;i++) {
    if (TS_os[i].timeSyncEnabled == 1) {
      configInfo.parm = NT_CONFIG_PARM_ADAPTER_TIMESYNC;
      configInfo.u.timesyncWrite.adapter = (uint8_t) i;
      configInfo.u.timesyncWrite.data.action = NT_TIMESYNC_PPS_ACTION_ENABLE;

      /* Set Initial PPS time */
      PpsGetOsTime(&osTime);
      configInfo.u.timesyncWrite.data.refTime = osTime;

      if ((status = NT_ConfigWrite(hConfigStream, &configInfo)) != NT_SUCCESS) {
        // Get the status code as text
        NT_ExplainError(status, errorBuffer, sizeof(errorBuffer));
        fprintf(stderr, "NT_ConfigWrite() failed: %s\n", errorBuffer);
        return -1;
      }
    }
  }

  fprintf(stderr, "PPS example starting in 5 seconds\n");
#if defined(WIN32) || defined (WIN64)
  Sleep(5000); // sleep 5000 milliseconds = 5 second
#else
  sleep(5);    // sleep 5 sec
#endif

#if defined(WIN32) || defined (WIN64)
  /* Clear screen */
  if (system("cls")==0) {
    // Avoid compiler warning
  }
#else
  /* Clear screen */
  if (system("clear")==0) {
    // Avoid compiler warning
  }
#endif
  printf("PPS Example running (press CTRL-C to exit)\n");

  while (appRunning == 1) {

    status = NT_EventRead(hEventStream, &hEvent, timeout);
    if (status == NT_STATUS_TIMEOUT) {
      // Timeout try again
    } else {
      if (status != NT_SUCCESS) {
        // Get the status code as text
        NT_ExplainError(status, errorBuffer, sizeof(errorBuffer));
        fprintf(stderr, "NT_EventRead() failed: %s\n", errorBuffer);
        return -1;
      }

      // Handle event
      if (hEvent.type == NT_EVENT_SOURCE_TIMESYNC) {
        if (hEvent.u.timeSyncEvent.action == NT_EVENT_TIMESYNC_PPS_REQUEST_TIME) {
          // Send PPS Reference Time
          configInfo.parm = NT_CONFIG_PARM_ADAPTER_TIMESYNC;
          configInfo.u.timesyncWrite.adapter = hEvent.u.timeSyncEvent.adapter;
          configInfo.u.timesyncWrite.data.action = NT_TIMESYNC_PPS_ACTION_REFERENCE_TIME;

          /* Set PPS Reference Time */
          PpsGetOsTime(&osTime);
          configInfo.u.timesyncWrite.data.refTime = osTime;

          if ((status = NT_ConfigWrite(hConfigStream, &configInfo)) != NT_SUCCESS) {
            // Get the status code as text
            NT_ExplainError(status, errorBuffer, sizeof(errorBuffer));
            fprintf(stderr, "NT_ConfigWrite() failed: %s\n", errorBuffer);
            return -1;
          }
        }
      }
    }
    PpsGetOsTime(&helpTime);
    if (helpTime != printTime) {
      printTime=helpTime;

#if defined(WIN32) || defined (WIN64)
      /* Clear screen */
      if (system("cls")==0) {
        // Avoid compiler warning
      }
#else
      /* Clear screen */
      if (system("clear")==0) {
        // Avoid compiler warning
      }
#endif

      /* Read timesync info */
      for (i=0;i<numAdapters;i++) {
        if (TS_os[i].timeSyncEnabled == 1) {
          /* Read timesync info */
          hInfo.cmd=NT_INFO_CMD_READ_TIMESYNC_V4;
          hInfo.u.timeSync_v4.adapterNo = (uint8_t) i;
          if ((status = NT_InfoRead(hInfoStream, &hInfo)) != NT_SUCCESS) {
            // Get the status code as text
            NT_ExplainError(status, errorBuffer, sizeof(errorBuffer));
            fprintf(stderr, "Failed to read timesync info: %s\n", errorBuffer);
            return -1;
          }
          if (hInfo.u.timeSync_v4.data.timeSyncCurrentConStatus == NT_TIMESYNC_CONNECTOR_STATUS_SIGNAL_LOST) {
            if (TS_os[i].timeSyncConStatus != NT_TIMESYNC_CONNECTOR_STATUS_SIGNAL_LOST) {
              TS_os[i].timeSyncConStatus = NT_TIMESYNC_CONNECTOR_STATUS_SIGNAL_LOST;
            }
            printf("PPS signal lost on adapter %d\n", i);
          } else
          if (hInfo.u.timeSync_v4.data.timeSyncCurrentConStatus == NT_TIMESYNC_CONNECTOR_STATUS_SIGNAL_PRESENT) {
            if (TS_os[i].timeSyncConStatus != NT_TIMESYNC_CONNECTOR_STATUS_SIGNAL_PRESENT) {
              TS_os[i].timeSyncConStatus = NT_TIMESYNC_CONNECTOR_STATUS_SIGNAL_PRESENT;
            }
            printf("PPS signal found on adapter %d\n", i);
            /* Print timesync info */
            PpsPrintStatusAndTime(i, hInfo.u.timeSync_v4.data.timeSyncPpsSampled, hInfo.u.timeSync_v4.data.timeSyncTimeSkew);
          }
        }
      }
    }
  }

  // Disable PPS
  for (i=0;i<numAdapters;i++) {
    if (TS_os[i].timeSyncEnabled == 1) {
      configInfo.parm = NT_CONFIG_PARM_ADAPTER_TIMESYNC;
      configInfo.u.timesyncWrite.adapter = (uint8_t)i;
      configInfo.u.timesyncWrite.data.action = NT_TIMESYNC_PPS_ACTION_DISABLE;
      configInfo.u.timesyncWrite.data.refTime = 0;

      if ((status = NT_ConfigWrite(hConfigStream, &configInfo)) != NT_SUCCESS) {
        // Get the status code as text
        NT_ExplainError(status, errorBuffer, sizeof(errorBuffer));
        fprintf(stderr, "NT_ConfigWrite() failed: %s\n", errorBuffer);
        return -1;
      }
    }
  }

  // Close the configuration stream
  if ((status = NT_ConfigClose(hConfigStream)) != NT_SUCCESS) {
    // Get the status code as text
    NT_ExplainError(status, errorBuffer, sizeof(errorBuffer));
    fprintf(stderr, "NT_ConfigClose() failed: %s\n", errorBuffer);
    return -1;
  }

  // Close the event stream
  if ((status = NT_EventClose(hEventStream)) != NT_SUCCESS) {
    // Get the status code as text
    NT_ExplainError(status, errorBuffer, sizeof(errorBuffer));
    fprintf(stderr, "NT_EventClose() failed: %s\n", errorBuffer);
    return -1;
  }

  /* Close the info stream */
  if ((status = NT_InfoClose(hInfoStream)) != NT_SUCCESS) {
    // Get the status code as text
    NT_ExplainError(status, errorBuffer, sizeof(errorBuffer));
    fprintf(stderr, "NT_InfoClose() failed: %s\n", errorBuffer);
    return -1;
  }

  printf("Streams closed\n");
  return 0;
}