discrete_rx_acquisition_trigger.c

/*******************************************************************************
//
//   File:
//      discrete_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.
//
//   The program first starts the acquisition and waits for bit 5 to be 1.
//   Aperiodic transmission is then done to fire the trigger.
//
//   Hardware Requirements:
//       - MAXT Flex or MAXT 500 series carrier with IPM with discrete channel
//       - loopback between TX and RX discrete channels.
//
*******************************************************************************/

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

#define LOCAL

#define MAX_TX_RECORDS_TO_TRANSMIT     100
#define BUFFER_SIZE     MAX_TX_RECORDS_TO_TRANSMIT*sizeof(MXF_DISCRETE_DATAREC) // Space for at least 100 records

uint32 ReadAcquisitionData(HMXF_BUFFER rxBuffer, MXF_DISCRETE_DATAREC *recDiscrete);
uint32 TransmitAperiodicData(HMXF_BUFFER txBuffer, MXF_DISCRETE_DATAREC *recDiscrete, uint64 moduleType);

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

int main(void)
{
uint32 rc;
HMXF_SERVER  server;
uint64 count=0;
HMXF_CHANNEL rxChannel=0;
HMXF_CHANNEL txChannel=0;
HMXF_BUFFER  rxBuffer=0;
HMXF_BUFFER  txBuffer=0;
MXF_DISCRETE_DATAREC *recDiscrete=NULL;
uint64 dev, mod, port;
MXF_RXACQ_TRIG_COND_RDATA_DW_PARM condParam;
HMXF_COND_LIST condList=0;
HMXF_MODULE module=0;
uint64 moduleType=0;
   
   // Connect 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;
   }
   
   // Initialize the server
   printf("\nStarting\n");
   
   rc = mxfSystemInit(server);

   // Obtain the first Discrete RX channel (RX logical #0)
   if (!rc)
      rc = mxfChannelAllGet(server, MXF_CLASS_DISCRETE, MXF_SCLASS_RX_CHANNEL, MXF_MODULE_ALL, 1, &count, &rxChannel);

   // Obtain the first Discrete TX channel (TX logical #0)
   if (!rc && count)
      rc = mxfChannelAllGet(server, MXF_CLASS_DISCRETE, MXF_SCLASS_TX_CHANNEL, MXF_MODULE_ALL, 1, &count, &txChannel);

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

   // Set timebase to computer time 64-bit microseconds
   if (!rc)
      rc = mxfSystemTimeBaseSet(server, MXF_TIMEBASE_COMPUTER_USEC);
   
   // Get the physical port location
   if (!rc)
   {
      rc = mxfChannelLocationGet(rxChannel, &dev, &mod, &port);
      if (!rc)
         printf("Acquisition Channel (RX) location=%"PRIu64".%"PRIu64".%"PRIu64"\n", dev, mod, port);
   }

   if (!rc)
   {
      rc = mxfChannelLocationGet(txChannel, &dev, &mod, &port);
      if (!rc)
         printf("Transmitter Channel (TX) location=%"PRIu64".%"PRIu64".%"PRIu64"\n", dev, mod, port);
   }

   if (!rc)
      rc = mxfChannelInfoGet(rxChannel, NULL, &module);

   if (!rc)
      rc = mxfAttributeUint64Get(module, KMXF_MODULE_TYPE, &moduleType);

   if(!rc)
   {
      if(moduleType == MXF_MODULE_DIOFIFO_EH)
      {
         rc = mxfAttributeUint64Set(rxChannel, KMXF_DISCRETE_RX_PULSE_WIDTH_FILTER, 100);
      }
      else
      {
         rc = mxfAttributeUint64Set(rxChannel, KMXF_DISCRETE_DIRECTION, 0x00ff);
         if (!rc)
            rc = mxfAttributeUint64Set(rxChannel, KMXF_DISCRETE_RX_EDGE_FALLING, 0xff);

         if (!rc)
            rc = mxfAttributeUint64Set(rxChannel, KMXF_DISCRETE_RX_EDGE_RISING, 0xff);
      }
   }

   // Allocate RX acquisition buffer
   if (!rc)
      rc = mxfRxAcqBufferAlloc(rxChannel, BUFFER_SIZE, &rxBuffer, NULL);

   // Allocate TX Aperiodic buffer (1MiB)
   if(!rc)
      rc = mxfTxAperiodicBufferAlloc(txChannel, 0, BUFFER_SIZE, &txBuffer, NULL);

   // Allocate host buffer
   if (!rc)
   {
      recDiscrete = (MXF_DISCRETE_DATAREC*)malloc(BUFFER_SIZE);
      if (!recDiscrete)
         rc = MAXT_ERROR_MEM;
   }

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

   // The condition will be triggered when bit 5 will be high
   if(!rc)
   {
      condParam.mask = 1<<5;
      condParam.data = 1<<5;
      condParam.offset = 0;
      condParam.options = MXF_RXACQ_TRIG_COND_RDATA_OPTIONS_EQUAL;

      rc = mxfRxAcqTrigConditionAdd(condList, MXF_RXACQ_TRIG_COND_ID_RDATA_DW , &condParam);
   }

   // Set the trigger with a pretrig count of 3 which allows some records to be read before the condition was triggered.
   // For discrete channel, this number is rounded up to the closest internal acquisition buffer size.
   if(!rc)
      rc = mxfRxAcqTrigSet(rxBuffer, condList, 3);

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

   // Start discrete data transmission
   if (!rc)
   {
      rc = TransmitAperiodicData(txBuffer, recDiscrete, moduleType);
      if (!rc)
      {
         // Read discrete data in acquisition buffer
         rc = ReadAcquisitionData(rxBuffer, recDiscrete);
      }
   }

   // Stop and flush unread data
   if (!rc)
      rc = mxfRxAcqStop(rxBuffer);
   if (!rc)
   {
      rc = mxfRxAcqClear(rxBuffer);
      if (!rc)
         printf("\nAcquisition stopped\n\r");
   }

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

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

   if (recDiscrete)
      free(recDiscrete);
   
   mxfSystemTerminate(server);
   mxfServerDisconnect(server);

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

   return rc;
}

/***************************************************************************************************************/
//   TransmitAperiodicData
/***************************************************************************************************************/

uint32 TransmitAperiodicData(HMXF_BUFFER txBuffer, MXF_DISCRETE_DATAREC *recDiscrete, uint64 moduleType)
{
uint32 rc;
MXF_DISCRETE_DATAREC* rec=recDiscrete;
uint64 data;
uint64 startTime = 100*1000; //100 msec
uint64 delay  = 1*1000;  //1 msec

   // Prepare data
   for(data=0; data<MAX_TX_RECORDS_TO_TRANSMIT; data++)
   {
      rec->timeTag      = startTime+(data*delay); // 1 msec between each
      rec->control      = 0;
      rec->repeatCount  = 1;
      rec->highDuration = 0;
      rec->lowDuration  = 0;
      rec->data = (uint16)data;
      rec->edge = (moduleType==MXF_MODULE_DIOFIFO_EH)?0xffff:0;
      mxfNextRecordPtrGet(MXF_CLASS_DISCRETE, MXF_RECTYPE_DATAREC, rec, (void **)&rec);
   }

   printf("Transmitting ...\n");
   rc = mxfTxAperiodicWrite(txBuffer, MXF_TXAPERIODIC_FLAG_USE_RECORD_RELATIVE_TIME, 0, MAX_TX_RECORDS_TO_TRANSMIT, recDiscrete);

   // Wait a little for transmission to occur
   if(!rc)
      mxfSleep(1000);
   
   return rc;
}

/***************************************************************************************************************/
//   ReadAcquisitionData
/***************************************************************************************************************/

uint32 ReadAcquisitionData(HMXF_BUFFER rxBuffer, MXF_DISCRETE_DATAREC *recDiscrete)
{
MXF_DISCRETE_DATAREC* rec=recDiscrete;
uint64 status, msgsCount, bytesCount;
uint64 j, trigTime=0;
uint32 rc;
time_t timeTemp;
struct tm * ptm;
char szTime[1024];
uint64 msec, usec;

   // Check trigger happened
   rc = mxfRxAcqBufferStatusGet(rxBuffer, &status, NULL, NULL, NULL);
   if(!rc)
   {
      if(status & MXF_RXACQ_STATUS_TRIG_OCCURRED)
      {
         // Display 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:%03"PRIu64":%03"PRIu64"\n", szTime, msec, usec);
         }
      }
      else
         printf("Trigger not fired\n");
   }

   // Read and display records
   rc = mxfRxAcqRead(rxBuffer, 0, BUFFER_SIZE, &status, &msgsCount, &bytesCount, recDiscrete);
   for (j=0; j<msgsCount && !rc; j++)
   {
      printf("   %02"PRIu64": Timetag=%012"PRIu64", Data=0x%04x %s\n", j, rec->timeTag, rec->data, trigTime==rec->timeTag?" *":"");

      mxfNextRecordPtrGet(MXF_CLASS_DISCRETE, MXF_RECTYPE_DATAREC, rec, (void **)&rec);
   }
   
   return rc;
}