ar717_rx_acquisition_trigger.c

/*******************************************************************************
//
//   File:
//      ar717_rx_acquisition_trigger.c
//
//     Copyright (c) MAX Technologies Inc. 1988-2015, All Rights Reserved. 
//           CONFIDENTIAL AND PROPRIETARY INFORMATION WHICH IS THE 
//                      PROPERTY OF MAX TECHNOLOGIES INC. 
//
//   This demo illustrates how to use the trigger functionality
//   to start acquisition on a receive channel.
//
//
//   Hardware Requirements:
//       - MAXT FlexMulti or 500 series carrier with IPM-MULTI with A717 option
//       - Loopback between first TX and RX ARINC 717 channels if internal loopback is not used
//
*******************************************************************************/

#include "example.h"
#include <time.h>

//#define LOOPBACK
//#define LOCAL

#define MAX_TX_SUBFRAMES_TO_TRANSMIT     8  //minimum of 4 to have at least one full frame.
#define BUFFER_SIZE                 MAX_TX_SUBFRAMES_TO_TRANSMIT*sizeof(MXF_A717_DATAREC)


uint32 RX717ReadAcquisitionData(HMXF_BUFFER rxBuffer, uint64 subframesize, MXF_A717_DATAREC *rec717);
uint32 initHandler(HMXF_SERVER server, uint64 deviceIndex, uint64 moduleIndex, uint64 channelIndex, uint64 attrib, uint64* value);

/***************************************************************************************************************/
//   Main
/***************************************************************************************************************/

int main(void)
{
MXF_RXACQ_TRIG_COND_RDATA_DW_PARM condParam;
HMXF_COND_LIST condList=0;
uint32                  rc;
HMXF_SERVER             server=0;
HMXF_CHANNEL            rxChannel=0;
HMXF_CHANNEL            txChannel=0;
HMXF_BUFFER             rxBuffer=0;
HMXF_BUFFER             txBuffer=0;
MXF_A717_DATAREC*       rec717=NULL;
uint64                  channelCount=0;
MXF_A717_DATAREC*       rxHostBuffer=0;
MXF_A717_DATAREC*       txHostBuffer=0;
uint64                  data;
uint64                  word;
uint64                  subframeSize = 128;
uint16                  value=0;

   // Connects to services local or remote
#ifdef LOCAL
   rc = mxfServerConnect("0.0.0.0", "", "", FALSE, &server);
#else
   rc = mxfServerConnect("192.168.0.1", "admin", "admin", FALSE, &server);
#endif

   if (rc)
   {
      printf("Failed to connect; rc=0x%08x", rc);
      printf("\nPress a key to terminate\n");
      getchar();
      return 0;
   }

   // Initializes init callback handler to set first TX and RX channel to A717
   rc = mxfSystemInitAttributeUint64CallbackHandler(server, &initHandler);

   // Initializes MX Foundation library
   if (!rc)
   {
      printf("Starting ...\n");
      rc = mxfSystemInit(server);
   }

   // Gets handle of first A717 RX channel
   if(!rc)
      rc = mxfChannelAllGet(server, MXF_CLASS_A717, MXF_SCLASS_RX_CHANNEL, MXF_MODULE_ALL, 1, &channelCount, &rxChannel);

   // Gets handle of first A717 TX channel
   if(!rc && channelCount)
      rc = mxfChannelAllGet(server, MXF_CLASS_A717, MXF_SCLASS_TX_CHANNEL, MXF_MODULE_ALL, 1, &channelCount, &txChannel);

   // If channel not found, returns an error
   if(!rc && !channelCount)
      rc = MAXT_ERROR_NOT_FOUND;

   // Enables loopback
#ifdef LOOPBACK
   if(!rc)
      rc = mxfAttributeUint64Set(rxChannel, KMXF_A717_TX_RX_TEST_LB , VMXF_ENABLE);
#endif

   #if (MAX_TX_SUBFRAMES_TO_TRANSMIT < 4)
   if(!rc)
      printf("Number of subframes to transmit less than 4: synchronization will not occur.\n");
   #endif

   // Sets subframe size
   if(!rc)
      rc=mxfAttributeUint64Set(rxChannel, KMXF_A717_SUBFRAME_SIZE, subframeSize);
   if(!rc)
      rc=mxfAttributeUint64Set(txChannel, KMXF_A717_SUBFRAME_SIZE, subframeSize);

   // Sets timebase to computer usec
   if(!rc)
      rc = mxfSystemTimeBaseSet(server, MXF_TIMEBASE_COMPUTER_USEC);

   // Allocates TX Aperiodic Update buffer
   if(!rc)
   {
      rc=mxfTxAperiodicBufferAlloc(txChannel, MXF_TXAPERIODIC_PRIORITY_HIGH, BUFFER_SIZE, &txBuffer, NULL);
      // Host buffer allocation
      if(!rc)
      {
         txHostBuffer = (MXF_A717_DATAREC*) calloc(1, BUFFER_SIZE);
         if(!txHostBuffer)
            rc = MAXT_ERROR_MEM;
      }
   }

   // Allocates RX acquisition buffer
   if (!rc)
   {
      rc = mxfRxAcqBufferAlloc(rxChannel, BUFFER_SIZE, &rxBuffer, NULL);
      // Host buffer allocation
      if(!rc)
      {
         rxHostBuffer = (MXF_A717_DATAREC*) calloc(1, BUFFER_SIZE);
         if(!rxHostBuffer)
            rc = MAXT_ERROR_MEM;
      }
   }

   // Allocates host buffer
   if (!rc)
   {
      rec717 = (MXF_A717_DATAREC*)malloc(BUFFER_SIZE);
      if (!rec717)
         rc = MAXT_ERROR_MEM;
   }

   // Configures trigger
   // Creates the condition list
   if (!rc)
      rc = mxfRxAcqTrigConditionListAlloc(server, &condList);

   // The condition will be triggered when data is 0x315 at word 21 of any subframe
   if(!rc)
   {
      condParam.mask = 0x0FFF0000;
      condParam.data = 0x03150000;
      condParam.offset = 10;
      condParam.options = MXF_RXACQ_TRIG_COND_RDATA_OPTIONS_EQUAL;
      rc = mxfRxAcqTrigConditionAdd(condList, MXF_RXACQ_TRIG_COND_ID_RDATA_DW , &condParam);
   }

   // Sets the trigger with a pretrig count of 3 which allows some records to be read before the condition was triggered.
   if(!rc)
      rc = mxfRxAcqTrigSet(rxBuffer, condList, 3);

   // Starts the acquisition process
   if (!rc)
      rc = mxfRxAcqModeSet(rxBuffer, MXF_RXACQ_MODE_CIRCULAR);
   if (!rc)
   {
      rc = mxfRxAcqStart(rxBuffer, MXF_RXACQ_FLAG_DEFAULT, 0, 0);
      if (!rc)
         printf("\nAcquisition started\n\r");
   }

   // Starts 717 data transmission
   if(!rc)
   {
      // Prepares string array
      rec717 = txHostBuffer;
      for(data=0; data<MAX_TX_SUBFRAMES_TO_TRANSMIT; data++)
      {
         rec717->timeTag      = 0;
         rec717->control      = 0;
         rec717->dataSize     = 2 * (uint32)subframeSize; // 16 bits per word in subframe
         rec717->repeatCount  = 1;
         rec717->reserved     = 0;
         for(word=0; word < subframeSize ; word++, value++)
         {
            if (word == 0)
            {
               //1st word of each subframe has to be a sync word
               // sync words are: 
               // - 0x247 for subframe #0 
               // - 0x5B8 for subframe #1
               // - 0xA47 for subframe #2 
               // - 0xDB8 for subframe #3
               switch (data%4)
               {
               case 0:
                  rec717->data[word] = 0x247;
                  break;
               case 1:
                  rec717->data[word] = 0x5B8;
                  break;
               case 2:
                  rec717->data[word] = 0xA47;
                  break;
               case 3:
                  rec717->data[word] = 0xDB8;
                  break;
               default:
                  break;
               }
            }
            else
               rec717->data[word] = value;
         }
         rc = mxfA717NextDataRecordPtrGet(rec717, &rec717);
      }
   }

   if(!rc)
   {
      printf("Transmitting ...\n");
      // Transmits strings
      rc = mxfA717TxAperiodicWrite(txBuffer, MXF_TXAPERIODIC_FLAG_DEFAULT, 0, MAX_TX_SUBFRAMES_TO_TRANSMIT, txHostBuffer);
   }

   if(!rc)
   {
      mxfSleep((MAX_TX_SUBFRAMES_TO_TRANSMIT+1) * 1000); // 1 second per subframe + 1 second to be sure to exceed the minimum duration to wait.
      
      // Reads 717 data in acquisition buffer
      rc = RX717ReadAcquisitionData(rxBuffer, subframeSize, rxHostBuffer);
   }

   // Stops and flushes unread data
   if (!rc)
      rc = mxfRxAcqStop(rxBuffer);

   if (!rc)
   {
      rc = mxfRxAcqClear(rxBuffer);
      if (!rc)
         printf("\nAcquisition stopped\n\r");
   }

   // Frees trigger condition list
   if(!rc && condList)
      rc = mxfRxAcqTrigConditionListFree(condList);

   // Catches any previous error
   if (rc)
   {
      char buffer[256];
      rc = mxfSystemErrorStringGet(server, rc, sizeof(buffer), buffer);
      printf("%s\n", buffer);
   }

   printf("\nTerminating\n");

   // Frees all buffers and terminate
   if (rxBuffer)
      mxfRxAcqBufferFree(rxBuffer);
   if (txBuffer)
      mxfTxAperiodicBufferFree(txBuffer);

   if(txHostBuffer)
      free(txHostBuffer);
   if(rxHostBuffer)
      free(rxHostBuffer);

   mxfSystemTerminate(server);
   mxfServerDisconnect(server);

   printf("\nPress enter to terminate\n");
   getchar();

   return rc;
}


/***************************************************************************************************************/
//   RX717ReadAcquisitionData
/***************************************************************************************************************/

uint32 RX717ReadAcquisitionData(HMXF_BUFFER rxBuffer, uint64 subframesize, MXF_A717_DATAREC *rxHostBuffer)
{
MXF_A717_DATAREC* rec;
uint64 status, msgsCount=0, bytesCount;
uint64 data;
uint64 trigTime=0;
uint32 rc;
time_t timeTemp;
struct tm * ptm;
char szTime[1024];
uint64 msec, usec;
uint64 word;

   // Checks if trigger happened
   rc = mxfRxAcqBufferStatusGet(rxBuffer, &status, NULL, NULL, NULL);
   if(!rc)
   {
      if(status & MXF_RXACQ_STATUS_TRIG_OCCURRED)
      {
         // Displays the acquisition trigger time
         rc = mxfRxAcqTrigTimeGet(rxBuffer, &trigTime);
         if(!rc)
         {
            timeTemp = trigTime/1000000;
            ptm = localtime(&timeTemp);
            strftime(szTime, sizeof(szTime), "%Y-%m-%d %H:%M:%S", ptm);
            usec = trigTime%1000;
            timeTemp = trigTime/1000;
            msec = timeTemp%1000;
            printf("Event triggered at %s:%03llu:%03llu\n", szTime, msec, usec);
         }
      }
      else
         printf("Trigger not fired\n");
   }

   // Reads and displays records
   if(!rc)
      rc = mxfA717RxAcqRead(rxBuffer, 0, BUFFER_SIZE, &status, &msgsCount, &bytesCount, rxHostBuffer);

   // Displays received strings
   rec = rxHostBuffer;
   for(data=0; data<msgsCount && !rc; data++)
   {
      printf("\n%02llu: Timetag=%012llu, Size=%u words\n", data, rec->timeTag, (rec->dataSize)/2);
      for(word=0; word < subframesize ; word++)
         printf("%03X ", rec->data[word]);
      printf("\n");
      rc = mxfA717NextDataRecordPtrGet(rec, &rec);
   }

   return rc;
}

uint32 initHandler(HMXF_SERVER server, uint64 deviceIndex, uint64 moduleIndex, uint64 channelIndex, uint64 attrib, uint64* value)
{
HMXF_DEVICE device;
MXF_DEVICE_INFO deviceInfo;
uint32 rc;

   server=server;
   deviceIndex=deviceIndex;

   if(attrib == KMXF_CHANNEL_CLASS)
   {
      rc = mxfSystemDeviceGet(server, deviceIndex, &device);
      if (!rc)
         rc = mxfDeviceInfoGet(device, &deviceInfo);

      if(!rc && ((deviceInfo.modules[moduleIndex].type == MXF_MODULE_MULTI_EH) || (deviceInfo.modules[moduleIndex].type == MXF_MODULE_MULTI)))
      {
         // Sets MXF_MODULE_MULTI_EH first TX and RX channels to A717
         if ((channelIndex == 0) || (channelIndex == deviceInfo.modules[moduleIndex].txCount))
         {
            *value = MXF_CLASS_A717;
            return TRUE;
         }
      }
   }

   return FALSE;
}