ar429_rx_acquisition_trigger.cs

/*******************************************************************************
//
//   File:
//      ar429_rx_acquisition_trigger.cs
//
//     Copyright (c) MAX Technologies Inc. 1988-2019, 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 a basic periodic transmission using the periodic 
//   scheduling service. The acquisition process is then started and waits for 
//   bit 10 value of label 07 to be 1.
//
//   Hardware Requirements:
//       - MAXT Flex with loopback between first TX and RX ARINC 429 Enhanced channels.
//
*******************************************************************************/

//#define LOOPBACK
//#define LOCAL 

using System;
using static MAXT.MXFoundation.mxf;
using System.Runtime.InteropServices;
using System.Text;

namespace ar429_example
{
   class ar429_rx_acquisition_trigger
   {
      const int BUFFER_SIZE = 1 * 1024 * 1024; // 1 MiB
      const int LABEL = 7;
      const int SDI = 0;

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

      static void Main(string[] args)
      {
         UInt32 rc;
         UInt64 server;
         UInt64 device = 0;
         var module = new UInt64[1];
         UInt64 count = 0;
         UInt64 rxChannel = 0, txChannel = 0;
         UInt64 rxBuffer = 0;
         UInt64 txBuffer = 0;
         IntPtr rec429 = IntPtr.Zero;
         UInt64 dev, mod, port;
         MXF_RXACQ_TRIG_COND_RDATA_DW_PARM condParam;
         UInt64 condList = 0;

         // Connect to services local or remote 
#if LOCAL
            rc = mxfServerConnect("0.0.0.0", "", "", Convert.ToUInt32(false), out server);
#else
         rc = mxfServerConnect("192.168.0.1", "admin", "admin", 0, out server);
#endif
         if (rc != MAXT_SUCCESS)
         {
            Console.Write("Failed to connect; rc=0x{0:x8}", rc);
            Console.Write("\nPress a key to terminate\n");
            Console.ReadKey();
            return;
         }

         // Initialize the server
         Console.Write("\nStarting\n");

         rc = mxfSystemInit(server);

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

         if (rc == MAXT_SUCCESS)
            rc = mxfDeviceModuleAllGet(device, MXF_MODULE_A429_EH, 1, out count, module);

         //Obtain the first A429 Rx and Tx channels
         if (rc == MAXT_SUCCESS)
            rc = mxfChannelGet(server, MXF_CLASS_A429, MXF_SCLASS_RX_CHANNEL, MXF_MODULE_A429_EH, 0, out rxChannel);
         if (rc == MAXT_SUCCESS)
            rc = mxfChannelGet(server, MXF_CLASS_A429, MXF_SCLASS_TX_CHANNEL, MXF_MODULE_A429_EH, 0, out txChannel);

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

         // Set timebase to computer time 64-bit microseconds
         if (rc == MAXT_SUCCESS)
            rc = mxfSystemTimeBaseSet(server, MXF_TIMEBASE_COMPUTER_USEC);

         // Get the physical port location
         if (rc == MAXT_SUCCESS)
         {
            rc = mxfChannelLocationGet(rxChannel, out dev, out mod, out port);
            if (rc == MAXT_SUCCESS)
               Console.Write("Acquisition Channel (RX) location={0}.{1}.{2}\n", dev, mod, port);
         }

         if (rc == MAXT_SUCCESS)
         {
            rc = mxfChannelLocationGet(txChannel, out dev, out mod, out port);
            if (rc == MAXT_SUCCESS)
               Console.Write("Transmitter Channel (TX) location={0}.{1}.{2}\n", dev, mod, port);
         }

         //Activate loopback before transmission and reception
#if LOOPBACK
         if (rc == MAXT_SUCCESS)
            rc = mxfAttributeUint64Set(rxChannel, KMXF_A429_TX_RX_TEST_LB, VMXF_ENABLE);
#endif
         // Allocate RX acquisition buffer
         if (rc == MAXT_SUCCESS)
            rc = mxfRxAcqBufferAlloc(rxChannel, BUFFER_SIZE, out rxBuffer, IntPtr.Zero);

         // Allocate TX Periodic Update buffer (1MiB)
         if (rc == MAXT_SUCCESS)
            rc = mxfTxPeriodicUpdateMsgBufferAlloc(txChannel, LABEL, BUFFER_SIZE, out txBuffer, IntPtr.Zero);

         // Allocate host buffer
         if (rc == MAXT_SUCCESS)
         {
            try
            {
               rec429 = Marshal.AllocHGlobal(BUFFER_SIZE);
            }
            catch (OutOfMemoryException)
            {
               rc = MAXT_ERROR_MEM;
            }
         }

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

         // The condition will be triggered on bit 10 value of LABEL/SDI
         if (rc == MAXT_SUCCESS)
         {
            condParam.mask = 0x000007ff;
            condParam.data = (1 << 10) | (SDI << 8) | LABEL;
            condParam.offset = 0;
            condParam.options = MXF_RXACQ_TRIG_COND_RDATA_OPTIONS_EQUAL;

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

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

         // Start the acquisition process
         if (rc == MAXT_SUCCESS)
            rc = mxfRxAcqModeSet(rxBuffer, MXF_RXACQ_MODE_CIRCULAR);

         if (rc == MAXT_SUCCESS)
         {
            rc = mxfRxAcqStart(rxBuffer, MXF_RXACQ_FLAG_DEFAULT, 0, 0);
            if (rc == MAXT_SUCCESS)
               Console.Write("\nAcquisition started\n\r");
         }

         // Start 429 data transmission
         if (rc == MAXT_SUCCESS)
            rc = TX429PeriodicScheduling(txChannel, txBuffer, rec429);

         // Read 429 data in acquisition buffer
         if (rc == MAXT_SUCCESS)
            rc = RX429ReadAcquisitionData(rxBuffer, rec429);

         // Stop and flush unread data
         if (rc == MAXT_SUCCESS)
            rc = mxfRxAcqStop(rxBuffer);

         if (rc == MAXT_SUCCESS)
         {
            rc = mxfRxAcqClear(rxBuffer);
            if (rc == MAXT_SUCCESS)
               Console.Write("\nAcquisition stopped\n\r");
         }

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

         // Catch any previous error
         if (rc != MAXT_SUCCESS)
         {
            StringBuilder buffer = new StringBuilder(256);

            if (mxfSystemErrorStringGet(server, rc, (UInt32)buffer.Capacity, buffer) != MAXT_SUCCESS)
            {
               buffer.Clear();
               buffer.Append(string.Format("ERROR # 0x{0:x8}", rc));
            }
            Console.Write(buffer + "\n\r");
         }

         Console.Write("\nTerminating\n");

         // Free all buffers and terminate
         if (txBuffer > 0)
            mxfTxPeriodicUpdateMsgBufferFree(txBuffer);
         if (rxBuffer > 0)
            mxfRxAcqBufferFree(rxBuffer);

         if (rec429 != IntPtr.Zero)
            Marshal.FreeHGlobal(rec429);

         mxfSystemTerminate(server);
         mxfServerDisconnect(server);

         Console.Write("\nPress enter to terminate\n");
         Console.ReadKey();

         return;
      }

      /***************************************************************************************************************/
      //   TX429PeriodicScheduling
      /***************************************************************************************************************/

      private static UInt32 TX429PeriodicScheduling(UInt64 txChannel, UInt64 txBuffer, IntPtr recPtr)
      {
         var rec429 = new MXF_A429_DATAREC();
         UInt64 schedule;
         UInt64 msg = 0;
         UInt64 data = 0, ssm = 1, parity = VMXF_A429_PARITY_ODD;
         UInt32 rc;

         // Set the A429 records and create the schedule

         // Create the periodic scheduler
         rc = mxfTxPeriodicScheduleNew(txChannel, out schedule);

         // Set scheduling values: Rate=10 ms (.1sec), Phase=0 us
         if (rc == MAXT_SUCCESS)
            rc = mxfTxPeriodicScheduleMsgAdd(schedule, 10000, 0, out msg);

         // Define the number of buffer for the list and link to it
         if (rc == MAXT_SUCCESS)
            rc = mxfTxPeriodicScheduleBufferListAdd(msg, 1, 0, new UInt64[] { txBuffer });

         // Set record for the buffer: ARINC 429 LABEL=05, SDI=0
         if (rc == MAXT_SUCCESS)
         {
            rec429.timeTag = 0;
            rec429.control = 0;
            rec429.repeatCount = 1;
            rec429.reserved = 0;

            rc = mxfA429ArwCompose(LABEL, SDI, data, ssm, parity, out rec429.data);

            Marshal.StructureToPtr(rec429, recPtr, false);
            if (rc == MAXT_SUCCESS)
               rc = mxfTxPeriodicUpdateMsgWrite(txBuffer, 1, recPtr);
         }

         //  Run the scheduler, update records
         if (rc == MAXT_SUCCESS)
         {
            Console.Write("Running periodic transmission, please wait...\n\r");

            // Run the schedule now
            rc = mxfTxPeriodicScheduleRun(schedule);
         }

         // Wait 0.5 second
         if (rc == MAXT_SUCCESS)
         {
            mxfSleep(500);

            // fire trigger
            rec429.control = 0;
            data = 1;
            rc = mxfA429ArwCompose(LABEL, SDI, data, ssm, parity, out rec429.data);

            Marshal.StructureToPtr(rec429, recPtr, true);

            if (rc == MAXT_SUCCESS)
               rc = mxfTxPeriodicUpdateMsgWrite(txBuffer, 1, recPtr);
         }

         // Wait 0.5 second
         if (rc == MAXT_SUCCESS)
         {
            mxfSleep(500);
            rc = mxfTxPeriodicScheduleFree(schedule);
         }

         if (rc == MAXT_SUCCESS)
            Console.Write("\n\rTransmission stopped\n\r");

         return rc;
      }

      /***************************************************************************************************************/
      //   RX429ReadAcquisitionData
      /***************************************************************************************************************/

      private static UInt32 RX429ReadAcquisitionData(UInt64 rxBuffer, IntPtr rec429)
      {
         IntPtr recPtr = IntPtr.Zero;
         MXF_A429_DATAREC rec = new MXF_A429_DATAREC();
         UInt64 status, msgsCount, bytesCount, pendingBytes, freeBytes;
         UInt64 label, sdi, data, ssm, parity;
         UInt64 j, trigTime = 0;
         UInt32 rc;

         UInt64 usec;
         var offset = TimeZoneInfo.Local.GetUtcOffset(DateTime.UtcNow);
         var time = new DateTime(1970, 1, 1).AddTicks(offset.Ticks); //create a time object set to jan 01 1970 in current timezone

         // Check trigger happened
         rc = mxfRxAcqBufferStatusGet(rxBuffer, out status, out msgsCount, out pendingBytes, out freeBytes);
         if (rc == MAXT_SUCCESS)
         {
            if ((status & MXF_RXACQ_STATUS_TRIG_OCCURRED) > 0)
            {
               // Display the acquisition trigger time
               rc = mxfRxAcqTrigTimeGet(rxBuffer, out trigTime);
               if (rc == MAXT_SUCCESS)
               {
                  time = time.AddMilliseconds(trigTime / 1000);
                  usec = trigTime % 1000;

                  Console.WriteLine("Event triggered at {0}:{1:000}", time.ToString("yyyy-MM-dd HH:mm:ss:fff"), usec);
               }
            }
            else
               Console.Write("Trigger not fired\n");
         }

         // Read and display records
         recPtr = rec429;
         rc = mxfA429RxAcqRead(rxBuffer, 0, BUFFER_SIZE, out status, out msgsCount, out bytesCount, rec429);
         for (j = 0; j < msgsCount && rc == MAXT_SUCCESS; j++)
         {
            rec = (MXF_A429_DATAREC)Marshal.PtrToStructure(recPtr, typeof(MXF_A429_DATAREC));

            mxfA429ArwDecompose(rec.data, out label, out sdi, out data, out ssm, out parity);
            Console.Write("{0:00}: Timetag {1} - ARINC word=[{2},{3},{4:X5},{5},{6:000}] {7}\n",
                     j, rec.timeTag, parity, ssm, data, sdi, label, trigTime == rec.timeTag ? "*" : "");

            mxfNextRecordPtrGet(MXF_CLASS_A429, MXF_RECTYPE_DATAREC, recPtr, out recPtr);
         }
         return rc;
      }
   }
}