ar629_freshnessCounter_manyCID.c

/*****************************************************************************
//
//     File:
//        ar629_freshnessCounter_manyCID.c
//
//       Copyright (c) MAX Technologies Inc. 1988-2016, 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 in block
//    mode and set the ARINC 629 data. 2 labels 0xA and 0xB with different CIDs
//    are transmitted. Label 0xA has FC enabled.
//    We also check if the FC incrementation is correct.
//
//    Hardware Requirements:
//       - MAXT FlexMulti-629 or MAXT 500 series carrier with IPM-629.
//
*****************************************************************************/

#include "example.h"

#define TTL
#define LOCAL

#define MAX_RX_RECORDS_TO_RECEIVE 1000
#define RX_BUFFER_SIZE     MAX_RX_RECORDS_TO_RECEIVE*sizeof(MXF_A629_DATAREC)

#define MAX_TX_RECORDS_TO_TRANSMIT 1
#define TX_BUFFER_SIZE     MAX_TX_RECORDS_TO_TRANSMIT*sizeof(MXF_A629_DATAREC)

//***************************************************************************
//
//   Main()
//
//***************************************************************************
int main(void)
{
uint32 rc;
HMXF_SERVER  server;
HMXF_MODULE  module=0;
uint64       count=0;
HMXF_CHANNEL rxChannel=0;
HMXF_CHANNEL txChannel[2];
HMXF_BUFFER  rxBuffer=0;
HMXF_BUFFER  txBuffer[2];
MXF_A629_DATAREC *hostBuffer=NULL;
MXF_A629_DATAREC *rec629=NULL;
MXF_A629_DATAREC txRec629;
uint64 dev, mod, port;
MXF_A629_TXPERIODIC_MJRFRAME_MSG minorFrame[3];
uint64 index, word;
MXF_A629_TXPERIODIC_MJRFRAME_PROPERTIES majorProperties;
uint64 status, msgsCount, bytesCount, indexBuffer, fcCounter = 0;
MXF_A629_FC fc={0};

   //Initializes the txChannel and txBuffer array elements to 0
   memset(txChannel, 0, sizeof(txChannel));
   memset(txBuffer, 0, sizeof(txBuffer));

   // 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 ARINC 629 Protocol RX channel (RX logical #0)
   if(!rc)
      rc = mxfChannelGet(server, MXF_CLASS_A629, MXF_SCLASS_BM_CHANNEL, MXF_MODULE_ALL, 0, &rxChannel);

   // Obtain the first two ARINC 629 Protocol TX channel (TX logical #0)
   if (!rc)
      rc = mxfChannelAllGet(server, MXF_CLASS_A629, MXF_SCLASS_RT_CHANNEL, MXF_MODULE_ALL, 2, &count, txChannel);

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

   // Set timebase to 64-bit nanoseconds
   if (!rc)
      rc = mxfSystemTimeBaseSet(server, MXF_TIMEBASE_DEVICE_NSEC);

   // Get the physical port location
   if (!rc)
   {
      rc = mxfChannelLocationGet(rxChannel, &dev, &mod, &port);
      if (!rc)
         printf("Acquisition Channel (RX) location=%llu.%llu.%llu\n", dev, mod, port);
   }

   for (index =0; index < count && !rc; index++)
   {
      rc = mxfChannelLocationGet(txChannel[index], &dev, &mod, &port);
      if (!rc)
         printf("Transmitter Channel (TX) location=%llu.%llu.%llu\n", dev, mod, port);
   }

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

   // Set interface to SIM or TTL
   #ifdef TTL
      if (!rc)
         rc = mxfAttributeUint64Set(module, KMXF_A629_MODULE_INTERFACE, VMXF_A629_MODULE_INTERFACE_TTL);
   #else
      if (!rc)
         rc = mxfAttributeUint64Set(module, KMXF_A629_MODULE_INTERFACE, VMXF_A629_MODULE_INTERFACE_SIM);
   #endif

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

   // Allocate two TX Periodic Update Message buffer
   for (indexBuffer = 0; indexBuffer < count && !rc; indexBuffer++)
   {
      rc = mxfTxPeriodicUpdateMsgBufferAlloc(txChannel[indexBuffer], indexBuffer, TX_BUFFER_SIZE, &txBuffer[indexBuffer], NULL);
   }

   // Allocate host buffer
   if (!rc)
   {
      hostBuffer = (MXF_A629_DATAREC*)malloc(max(RX_BUFFER_SIZE, TX_BUFFER_SIZE));
      if (!hostBuffer)
         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");
   }

   //Set the TI to 25 msec
   if(!rc)
      rc = mxfAttributeUint64Set(module, KMXF_A629_MODULE_TI, 25000000);

   //Set the SG to 16
   if(!rc)
      rc = mxfAttributeUint64Set(module, KMXF_A629_MODULE_SG, VMXF_A629_MODULE_SG_16);

   //Sets the TG for the different RTs
   if (!rc)
      rc = mxfAttributeUint64Set(txChannel[0], KMXF_A629_RT_TG, 2);
   if (!rc)
      rc = mxfAttributeUint64Set(txChannel[1], KMXF_A629_RT_TG, 4);


   //Sets the CID for the different labels
   if(!rc)
      rc = mxfAttributeUint64Set(txChannel[0], KMXF_A629_RT_CID, 0xC);
   if(!rc)
      rc = mxfAttributeUint64Set(txChannel[1], KMXF_A629_RT_CID, 0xD);

   //Stops and clears the major frames
   for (index =0; index < count && !rc; index++)
   {
      rc = mxfTxPeriodicMajorFrameStop(txChannel[index], 0, 0);
      if (!rc)
         rc = mxfTxPeriodicMajorFrameClear(txChannel[index], 0);
   }

   //--- Sets the minor frame #0 with 1 WordString --//
   if(!rc)
   {
      memset(minorFrame, 0, sizeof(minorFrame));

      //WordString #0 : Label 0xA, CID 0xC
      minorFrame[0].buffer  = txBuffer[0];
      minorFrame[0].label   = 0xA;
      minorFrame[0].cid     = 0;
      minorFrame[0].length  = 1;
      minorFrame[0].options = MXF_A629_TXPERIODIC_MJRFRAME_MSG_OPT_DEFAULT;

      rc = mxfA629TxPeriodicMajorFrameSet(txChannel[0], 0, 0, 1, minorFrame);

      // Adds a FC to label 0xA
      if(!rc)
      {
         fc.enable = TRUE;
         fc.position = 1;
         fc.mask = 0x00f0;
         fc.modulo = 1;
         rc = mxfA629MsgFreshnessCounterSet(txBuffer[0], &fc);
      }
   }

   //------------------------------------------------//

   //--- Sets the minor frame #0 with 1 WordString --//
   if(!rc)
   {
      //WordString #0 : Label 0xB, CID 0xD
      minorFrame[0].buffer  = txBuffer[1];
      minorFrame[0].label   = 0xB;
      minorFrame[0].cid     = 0;
      minorFrame[0].length  = 1;
      minorFrame[0].options = MXF_A629_TXPERIODIC_MJRFRAME_MSG_OPT_DEFAULT;

      rc = mxfA629TxPeriodicMajorFrameSet(txChannel[1], 0, 0, 1, minorFrame);
   }
   //------------------------------------------------//

   //--- Sets default data for label 0xA, CID 0xC ---//
   if(!rc)
   {
      memset(&txRec629, 0, sizeof(txRec629));

      txRec629.control     = 0;
      txRec629.repeatCount = 1;
      txRec629.dataSize    = 4; //4 bytes (label (2 bytes) + 1 data words)
      txRec629.data[0] = 0;
      txRec629.data[1] = 0x1111;
      rc = mxfA629TxPeriodicUpdateMsgWrite(txBuffer[0], 1, &txRec629);
   }

   //------------------------------------------------//

   //--- Sets default data for label 0xB, CID 0xD ---//
   if(!rc)
   {
      txRec629.control     = 0;
      txRec629.repeatCount = 1;
      txRec629.dataSize    = 4;
      txRec629.data[0] = 0;
      txRec629.data[1] = 0x2222;
      rc = mxfA629TxPeriodicUpdateMsgWrite(txBuffer[1], 1, &txRec629);
   }
   //------------------------------------------------//

   //Starts the major frames in the Block mode
   for (index = 0; index < count && !rc; index++)
   {
      majorProperties.mode = MXF_A629_TXPERIODIC_MJRFRAME_PROPERTIES_MODE_BLOCK;
      majorProperties.reserved = 0;
      rc = mxfA629TxPeriodicMajorFrameStart(txChannel[index], 0, &majorProperties);
   }

   //Waiting 2 seconds. Allows major frame to run a little bit.
   if(!rc)
      mxfSleep(2000);

   //Stops the major frames
   for (index = 0; index < count && !rc; index++)
   {
      rc = mxfTxPeriodicMajorFrameStop(txChannel[index], 0, 0);
   }

   // Stop acquisition and read data
   if (!rc)
      rc = mxfRxAcqStop(rxBuffer);

   if (!rc)
   {
      rc = mxfA629RxAcqRead(rxBuffer, 0, RX_BUFFER_SIZE, &status, &msgsCount, &bytesCount, hostBuffer);
      if (!rc)
      {
         //Writes the program results in a file (results.txt)
         {
            char s[500];
            FILE *f = fopen("results.txt", "w");

            if (f == NULL)
               printf("Error opening file!\n");

            // Display received messages
            rec629 = hostBuffer;
            for(index=0; index<msgsCount && !rc; index++)
            {
               sprintf(s,"   %02llu: Timetag=%012llu, Size=%u", index, rec629->timeTag, rec629->dataSize);
               fprintf(f, s);

               if(rec629->control & MXF_A629_RX_REC_CTRL_STRING_CRC_ERROR)
               {
                  sprintf(s," CRC error");
                  fprintf(f, s);
               }

               if(rec629->control & MXF_A629_RX_REC_CTRL_STRING_DATA_SYNC_ERROR)
               {
                  sprintf(s," Data sync error");
                  fprintf(f, s);
               }

               if(rec629->control & (MXF_A629_RX_REC_CTRL_STRING_LABEL_MANCHESTER_ERROR|MXF_A629_RX_REC_CTRL_STRING_DATA_MANCHESTER_ERROR))
               {
                  sprintf(s," Manchester error");
                  fprintf(f, s);
               }

               if(rec629->control & (MXF_A629_RX_REC_CTRL_STRING_LABEL_PARITY_ERROR|MXF_A629_RX_REC_CTRL_STRING_DATA_PARITY_ERROR))
               {
                  sprintf(s," Parity error");
                  fprintf(f, s);
               }

               if(rec629->control & MXF_A629_RX_REC_CTRL_STRING_EOS_ERROR)
               {
                  sprintf(s," End of String error");
                  fprintf(f, s);
               }

               sprintf(s,"\n       Data=");
               fprintf(f, s);
               for(word=0; word<rec629->dataSize/2; word++)
               {
                  sprintf(s,"%04X ", rec629->data[word]);
                  fprintf(f, s);
                  if (rec629->data[0] == 0xC00A)
                  {
                     if (word == fc.position)
                     {
                        if (fcCounter == ((rec629->data[word] & fc.mask)>>4))
                        {
                           sprintf(s,"Freshness Counter ok. \n");
                           fprintf(f, s);
                           fcCounter++;
                           if (fcCounter == 16)
                              fcCounter = 0;
                        }
                        else
                        {
                           sprintf(s,"ERROR Freshness Counter. \n");
                           fprintf(f, s);
                        }
                     }
                  }
               }
               sprintf(s,"\n");
               fprintf(f, s);
               mxfA629NextDataRecordPtrGet(rec629, &rec629);
            }

            fclose(f);
         }
      }
   }

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

   for (indexBuffer = 0; indexBuffer < 2; indexBuffer++)
   {
      if (txBuffer[indexBuffer])
         mxfTxPeriodicUpdateMsgBufferFree(txBuffer[indexBuffer]);
   }

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

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

return rc;
}