csdb_aperiodic.c

/*******************************************************************************
//
//   File:
//       csdb_aperiodic.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 shows how to set a basic periodic transmission 
//    with the scheduler and update the CSDB data.
//
//    Hardware Requirements:
//       - MAXT Flex with loopback between first TX and RX CSDB Enhanced channels.
//
*******************************************************************************/

#include "example.h"

#define LOOPBACK
#define LOCAL

#define BUFFER_SIZE     4096 // 4KB
#define MAX_TX_RECORDS_TO_TRANSMIT 8
#define BLOCKCOUNT 6

uint32 initHandler(HMXF_SERVER server, uint64 deviceIndex, uint64 moduleIndex, uint64 channelIndex, uint64 attrib, uint64* value);
uint32 ReadAcquisitionData(HMXF_BUFFER rxBuffer, MXF_CSDB_DATAREC *recCsdb);
uint32 WaitQueueEmpty(HMXF_BUFFER txBuffer);
uint32 StartAperiodicTransmissionDefault(HMXF_BUFFER txBuffer, MXF_CSDB_DATAREC *recCsdb);
uint32 StartAperiodicTransmissionAbsolute(HMXF_DEVICE device, HMXF_BUFFER txBuffer, MXF_CSDB_DATAREC *recCsdb);
uint32 StartAperiodicTransmissionRecordAbsolute(HMXF_DEVICE device, HMXF_BUFFER txBuffer, MXF_CSDB_DATAREC *recCsdb);
uint32 StartAperiodicTransmissionRecordRelative(HMXF_BUFFER txBuffer, MXF_CSDB_DATAREC *recCsdb);

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

int main(void)
{
uint32 rc;
HMXF_SERVER  server;
HMXF_DEVICE  device=0;
HMXF_MODULE  module=0;
uint64       count=0;
HMXF_CHANNEL rxChannel=0;
HMXF_CHANNEL txChannel=0;
HMXF_BUFFER  rxBuffer=0;
HMXF_BUFFER  txBuffer=0;
MXF_CSDB_DATAREC *recCsdb=NULL;
uint64 dev, mod, port;
   
   // 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");
   
   // initialize init callback handler to set IPM-ASYNC-EH first TX and RX channel to CSDB
   rc = mxfSystemInitAttributeUint64CallbackHandler(server, &initHandler);
   
   if(!rc)
      rc = mxfSystemInit(server);

   // Get the first device handle
   if (!rc)
      rc = mxfSystemDeviceGet(server, 0, &device);

   if (!rc)
      rc = mxfDeviceModuleAllGet(device, MXF_MODULE_ASYNC_EH, 1, &count, &module);

   // Obtain the first CSDB Protocol RX channel (RX logical #0)
   if (!rc && count)
      rc = mxfModuleChannelAllGet(module, MXF_CLASS_CSDB, MXF_SCLASS_RX_CHANNEL, 1, &count, &rxChannel);

   // Obtain the first CSDB Protocol TX channel (TX logical #0)
   if (!rc && count)
      rc = mxfModuleChannelAllGet(module, MXF_CLASS_CSDB, MXF_SCLASS_TX_CHANNEL, 1, &count, &txChannel);

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

   // Set timebase to 64-bit microseconds
   if (!rc)
      rc = mxfSystemTimeBaseSet(server, MXF_TIMEBASE_DEVICE_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);
   }

   //Activate loopback before transmission and reception
   #ifdef LOOPBACK
      if (!rc)
         rc = mxfAttributeUint64Set(rxChannel, KMXF_CSDB_TX_RX_TEST_LB, VMXF_ENABLE);
   #endif
   
   // Set block count
   if(!rc)
      rc = mxfAttributeUint64Set(rxChannel, KMXF_CSDB_BLOCKCOUNT, BLOCKCOUNT);

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

   // Allocate Aperiodic TX static buffers for HIGH priority queue
   if (!rc)
      rc = mxfTxAperiodicBufferAlloc(txChannel, MXF_TXAPERIODIC_PRIORITY_HIGH, BUFFER_SIZE, &txBuffer, NULL);

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

   // 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");
   }

   if (!rc)
   {
      // Start CSDB data transmission
      rc = StartAperiodicTransmissionDefault(txBuffer, recCsdb);
      if (!rc)
         rc = ReadAcquisitionData(rxBuffer, recCsdb);
      if (!rc)
         rc = StartAperiodicTransmissionAbsolute(device, txBuffer, recCsdb);
      if (!rc)
         rc = ReadAcquisitionData(rxBuffer, recCsdb);
      if (!rc)
         rc = StartAperiodicTransmissionRecordAbsolute(device, txBuffer, recCsdb);
      if (!rc)
         rc = ReadAcquisitionData(rxBuffer, recCsdb);
      if (!rc)
         rc = StartAperiodicTransmissionRecordRelative(txBuffer, recCsdb);
      if (!rc)
         rc = ReadAcquisitionData(rxBuffer, recCsdb);
   }
   
   // Stop and flush unread data
   if (!rc)
      rc = mxfRxAcqStop(rxBuffer);
   if (!rc)
   {
      rc = mxfRxAcqClear(rxBuffer);
      if (!rc)
         printf("\nAcquisition stopped\n\r");
   }

   // Catch any previous error
   if (rc)
   {
   char buffer[256];
      rc = mxfSystemErrorStringGet(server, rc, sizeof(buffer), buffer);
      printf("%s\n", buffer);
   }
   
   printf("\nTerminating\n");
   
   // Free all buffers and terminate
   if (rxBuffer)
      mxfRxAcqBufferFree(rxBuffer);
   if(txBuffer)
      mxfTxAperiodicBufferFree(txBuffer);

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

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

   return rc;
}

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

uint32 ReadAcquisitionData(HMXF_BUFFER rxBuffer, MXF_CSDB_DATAREC *recCsdb)
{
MXF_CSDB_DATAREC *recPtr=recCsdb;
uint64 status, msgsCount, bytesCount;
uint64 j;
uint32 rc, data;
   
   // Read and display records
   rc = mxfCSDBRxAcqRead(rxBuffer, 0, BUFFER_SIZE, &status, &msgsCount, &bytesCount, recCsdb);
   if(!rc)
   {
      printf("Read %"PRIu64" messages\n\r", msgsCount);

      for (j=0; !rc && j<msgsCount; j++)
      {
         printf("%02"PRIu64": Timetag %"PRIu64" - ", j, recPtr->timeTag);
         for(data=0; data<6; data++)
            printf("%02x", recPtr->data[data]);

         printf("\n\r");
         rc = mxfCSDBNextDataRecordPtrGet(recPtr, &recPtr);
      }
   }
   
   if(rc)
      printf("Acquisition read failed; rc=0x%08x\n\r", rc);

return rc;
}

/***************************************************************************************************************/
//   WaitQueueEmpty
/***************************************************************************************************************/

uint32 WaitQueueEmpty(HMXF_BUFFER txBuffer)
{
uint64 msgCount, usedBytes, freeBytes;
uint32 rc;
   
   // Wait till all records are sent on the interface
   do
   {
      rc = mxfTxAperiodicBufferStatusGet(txBuffer, &msgCount, &usedBytes, &freeBytes);
      if (rc)
         return rc;
   }while (msgCount!=0);
 
   // Make sure they are received
   mxfSleep(100);
   
   return MAXT_SUCCESS;
}

/***************************************************************************************************************/
//   StartAperiodicTransmissionDefault
/***************************************************************************************************************/

uint32 StartAperiodicTransmissionDefault(HMXF_BUFFER txBuffer, MXF_CSDB_DATAREC *recCsdb)
{
MXF_CSDB_DATAREC* rec;
uint64 dataIdx;
uint32 record;
uint64 delay100ms = 100000;
uint32 rc;
   
   //  In the example below the record are sent back-to-back 100 ms in the future.
   
   printf("\nAperiodic transmission (Relative Start Time-Default)\n");
   
   // Set the record
   rec = recCsdb;
   for (record=0; record<MAX_TX_RECORDS_TO_TRANSMIT; record++)
   {
      if(record == 0)
      {
         // Set sync block
         rec->timeTag = 0;
         rec->control = 0;
         rec->repeatCount = 1;
         rec->reserved = 0;
         for(dataIdx=0; dataIdx<BLOCKCOUNT; dataIdx++)
            rec->data[dataIdx] = 0xA5;
      }
      else
      {
         // Set each record: LABEL=5, SI=1
         rec->timeTag = 0;
         rec->control = 0;
         rec->repeatCount = 1;
         rec->reserved = 0;
         rec->data[0] = 5;
         rec->data[1] = 1;
         for(dataIdx=2; dataIdx<BLOCKCOUNT; dataIdx++)
            rec->data[dataIdx] = (uint8)(0x11*record);
      }

      mxfCSDBNextDataRecordPtrGet(rec, &rec);
   }
   
   // Transmit the array of records
   rc = mxfCSDBTxAperiodicWrite(txBuffer, MXF_TXAPERIODIC_FLAG_DEFAULT, delay100ms, MAX_TX_RECORDS_TO_TRANSMIT, recCsdb);
   
   // Wait TX completion
   if (!rc)
      rc = WaitQueueEmpty(txBuffer);
   
   return rc;
}

/***************************************************************************************************************/
//   StartAperiodicTransmissionAbsolute
/***************************************************************************************************************/

uint32 StartAperiodicTransmissionAbsolute(HMXF_DEVICE device, HMXF_BUFFER txBuffer, MXF_CSDB_DATAREC *recCsdb)
{
MXF_CSDB_DATAREC* rec;
uint64 dataIdx;
uint32 record, rc;
uint32 delay100ms = 100000;
uint64 currentTime;
   
   // Get the current time
   rc = mxfDeviceTimerGet(device, &currentTime);
   if (rc)
      return rc;
   
   //  In the example below the option MXF_TXAPERIODIC_FLAG_ABSOLUTE_START_TIME
   //  is used. In this case the records are sent freely (no time clock control)
   //  with a start transmission time based on the device clock + 100ms in the futur.
   
   printf("\nAperiodic transmission (Absolute)\n");
   rec = recCsdb;
   for (record=0; record<MAX_TX_RECORDS_TO_TRANSMIT; record++)
   {
      if(record == 0)
      {
         // Set sync block
         rec->timeTag = 0;
         rec->control = 0;
         rec->repeatCount = 1;
         rec->reserved = 0;
         for(dataIdx=0; dataIdx<BLOCKCOUNT; dataIdx++)
            rec->data[dataIdx] = 0xA5;
      }
      else
      {
         // Set each record: LABEL=6, SI=2
         rec->timeTag = 0;
         rec->control = 0;
         rec->repeatCount = 1;
         rec->reserved = 0;
         rec->data[0] = 6;
         rec->data[1] = 2;
         for(dataIdx=2; dataIdx<BLOCKCOUNT; dataIdx++)
            rec->data[dataIdx] = (uint8)record;
      }

      mxfCSDBNextDataRecordPtrGet(rec, &rec);
   }
   
   // Transmit the array of records
   rc = mxfCSDBTxAperiodicWrite(txBuffer, MXF_TXAPERIODIC_FLAG_ABSOLUTE_START_TIME, currentTime+delay100ms, MAX_TX_RECORDS_TO_TRANSMIT, recCsdb);
   
   // Wait TX completion 
   if (!rc)
      rc = WaitQueueEmpty(txBuffer);
   
   return rc;
}

/***************************************************************************************************************/
//   StartAperiodicTransmissionRecordAbsolute
/***************************************************************************************************************/

uint32 StartAperiodicTransmissionRecordAbsolute(HMXF_DEVICE device, HMXF_BUFFER txBuffer, MXF_CSDB_DATAREC *recCsdb)
{
MXF_CSDB_DATAREC* rec;
uint64 dataIdx;
uint32 record;
uint64 currentTime;
uint32 rc;
   
   //  In the example below the timetag in the record is set
   //  and the option MXF_TXAPERIODIC_FLAG_USE_RECORD_ABSOLUTE_TIME
   //  In this case the records are sent based on the absolute clock
   //  timing specified in the timetag field for each records.
   
   printf("\nAperiodic transmission (Absolute with timetag)\n");
   
   // Get the current time
   rc = mxfDeviceTimerGet(device, &currentTime);
   if (rc)
      return rc;
   
   currentTime+=100000;
   
   // Set the record
   rec = recCsdb;
   for (record=0; record<MAX_TX_RECORDS_TO_TRANSMIT; record++)
   {
      // The scheduling timetag is as follow:
      // clock current time + 1 ms
      // Each record are sent with a timetag a 10000 uS (10 ms) interval.

      if(record == 0)
      {
         // Set sync block
         rec->timeTag = currentTime+((record+1)*10000LL);
         rec->control = 0;
         rec->repeatCount = 1;
         rec->reserved = 0;
         for(dataIdx=0; dataIdx<BLOCKCOUNT; dataIdx++)
            rec->data[dataIdx] = 0xA5;
      }
      else
      {
         // Set each records: LABEL=7, SI=1
         rec->timeTag = currentTime+((record+1)*10000LL);
         rec->control = 0;
         rec->repeatCount = 1;
         rec->reserved = 0;
         rec->data[0] = 7;
         rec->data[1] = 1;
         for(dataIdx=2; dataIdx<BLOCKCOUNT; dataIdx++)
            rec->data[dataIdx] = (uint8)(2*record);
      }
      mxfCSDBNextDataRecordPtrGet(rec, &rec);
   }
   
   // Transmit the array of records
   rc = mxfCSDBTxAperiodicWrite(txBuffer, MXF_TXAPERIODIC_FLAG_USE_RECORD_ABSOLUTE_TIME, 0, MAX_TX_RECORDS_TO_TRANSMIT, recCsdb);
   
   // Wait TX completion
   if (!rc)
      rc = WaitQueueEmpty(txBuffer);
   
   return rc;
}

/***************************************************************************************************************/
//   StartAperiodicTransmissionRecordRelative
/***************************************************************************************************************/

uint32 StartAperiodicTransmissionRecordRelative(HMXF_BUFFER txBuffer, MXF_CSDB_DATAREC *recCsdb)
{
MXF_CSDB_DATAREC* rec;
uint64 dataIdx;
uint32 record;
uint64 currentTime;
uint32 rc;
   
   //  In the example below the timetag in the record is set
   //  and the option MXF_TXAPERIODIC_FLAG_USE_RECORD_RELATIVE_TIME.
   //  The relative time between each records is set in the 
   //  timetag field of the record array.
   
   printf("\nAperiodic transmission (Record Relative)\n");
   
   // Set the record
   rec = recCsdb;
   for (record=0, currentTime=100000; record<MAX_TX_RECORDS_TO_TRANSMIT; record++)
   {
      // The scheduling timetag is as follow:
      // clock current time + 1 ms
      // Each record are sent with a timetag a 10000 uS (10 ms) interval.
      if(record == 0)
      {
         // Set sync block
         rec->timeTag = currentTime+((record+1)*10000LL);
         rec->control = 0;
         rec->repeatCount = 1;
         rec->reserved = 0;
         for(dataIdx=0; dataIdx<BLOCKCOUNT; dataIdx++)
            rec->data[dataIdx] = 0xA5;
      }
      else
      {
         // Set each records: LABEL=8, SI=1
         rec->timeTag = currentTime+((record+1)*10000LL);
         rec->control = 0;
         rec->repeatCount = 1;
         rec->reserved = 0;
         rec->data[0] = 8;
         rec->data[1] = 1;
         for(dataIdx=2; dataIdx<BLOCKCOUNT; dataIdx++)
            rec->data[dataIdx] = (uint8)(3*record);
      }
      mxfCSDBNextDataRecordPtrGet(rec, &rec);
   }
   
   // Transmit the array of records
   rc = mxfCSDBTxAperiodicWrite(txBuffer, MXF_TXAPERIODIC_FLAG_USE_RECORD_RELATIVE_TIME, 0, MAX_TX_RECORDS_TO_TRANSMIT, recCsdb);
   
   // Wait TX completion 
   if (!rc)
      rc = WaitQueueEmpty(txBuffer);
   
   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_ASYNC_EH))
      {
         // Sets IPM-ASYNC-EH first TX and RX channel to CSDB
         if ((channelIndex == 0) || (channelIndex == deviceInfo.modules[moduleIndex].txCount))
         {
            *value = MXF_CLASS_CSDB;
            return TRUE;
         }
      }
   }

   return FALSE;
}