ar664_error_injection_detection.cs

/*******************************************************************************
//
//   File:
//       ar664_error_injection_detection.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 shows how to modify A664 frame for generating error
//    injection errors on specific frame headers or data and register
//    the A664 stack for reporting the errors using the async/event API.
//
//    Hardware Requirements:
//       - FlexMulti A664 
//
*******************************************************************************/

#define LOOPBACK
//#define LOCAL

using System;
using System.Net;
using System.Runtime.InteropServices;

using static MAXT.MXFoundation.mxf;


namespace ar664_example
{
    public class ar664_error_injection_detection
    {

        private const UInt32 TEST_DATASIZE = 64;

        private const UInt64 DATARECS_BUFFER_SIZE_MAX = 64 * 1024;

        private const string SRC_IP_ADRS = "10.0.0.111";
        private const UInt32 SRC_UDP_PORT = 1234;
        private const string DST_IP_ADRS = "10.0.0.222";
        private const UInt32 DST_UDP_PORT = 5678;

        static void Main(string[] args)
        {
            UInt64 server = 0;
            UInt64 portTx = 0;
            UInt64 portRx = 0;
            UInt64 vlTx = 0, vlRx = 0;
            UInt64 rxBuffer = 0, rxBufferRaw = 0;
            var data = new MXF_A664_DATAREC();
            var module = new UInt64[1];
            UInt64 device = 0;
            var phyChn = new UInt64[1];
            IntPtr recPtr = IntPtr.Zero;
            IntPtr rxRec = IntPtr.Zero;
            IntPtr txRec = IntPtr.Zero;
            var vlParamTx = new MXF_A664_VL_PARAM_TX();
            var vlParamRx = new MXF_A664_VL_PARAM_RX();
            var portParam = new MXF_A664_PORT_PARAM();
            MXF_ASYNCEVENT_HANDLER asyncEventHandler = AsyncEventHandler;
            var asyncEventInfoRx = new MXF_ASYNCEVENT_CONDITION[1];
            var errorInjectionTx = new MXF_A664_ERROR_INJ();
            UInt64 asyncEvent = 0;
            int srcIpAdrs = 0, dstIpAdrs = 0;
            UInt64 status;
            UInt64 usedBytes, freeBytes;
            UInt64 msgCount = 0;
            UInt64 acqStopTime;
            UInt32 recordIdx, dataIdx;
            UInt32 maxTxRecords = 4;
            UInt32 vlid = 100;
            UInt32 rc;
            UInt64 count = 0;

            Console.Write("\nARINC664 Error Injection / Detection Demo\n\n");

            // Connect to server
#if LOCAL
            rc = mxfServerConnect("0.0.0.0", "", "", VMXF_DISABLE, 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}\n", rc);
                Console.Write("\nPress a key to terminate\n");
                Console.ReadKey();
                return;
            }

            // Initialize server, allocate base resources
            rc = mxfSystemInit(server);


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

            // Get the first A664 module
            if (rc == MAXT_SUCCESS)
                rc = mxfDeviceModuleAllGet(device, MXF_MODULE_A664, 1, out count, module);

            // Obtain the first ARINC 664 Phy channel (Phy logical #0)
            if (rc == MAXT_SUCCESS && count > 0)
                rc = mxfModuleChannelAllGet(module[0], MXF_CLASS_A664, MXF_SCLASS_ALL, 1, out count, phyChn);

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

#if LOOPBACK
            if (rc == MAXT_SUCCESS)
                rc = mxfAttributeUint64Set(phyChn[0], KMXF_A664_PHY_LOOPBACK, VMXF_A664_PHY_LOOPBACK_EXTERNAL);
#endif
            // Raw port will receive erroneous frames
            if (rc == MAXT_SUCCESS)
                rc = mxfAttributeUint64Set(phyChn[0], KMXF_A664_RAW_RX_ERROR_ONLY, VMXF_ENABLE);

            // Set Timebase
            if (rc == MAXT_SUCCESS)
                rc = mxfSystemTimeBaseSet(server, MXF_TIMEBASE_DEVICE_NSEC);
               

            // Create the transmission (TX) virtual link
            if (rc == MAXT_SUCCESS)
            {
                vlParamTx.dir.Tx.subVl = new MXF_A664_VL_PARAM_TX.Dir.TX.SubVl[4];

                vlParamTx.direction = MXF_A664_VL_DIR_TX;
                vlParamTx.VLId = vlid;
                vlParamTx.frameType = MXF_A664_FRAME_TYPE_ARINC664;
                vlParamTx.frameSizeMax = 512;
                vlParamTx.dir.Tx.subVlNumber = 1;
                vlParamTx.dir.Tx.bag = 1 * 1000 * 1000;  // 1ms
                vlParamTx.dir.Tx.netSelection = MXF_A664_NETSELECT_ALL;
                vlParamTx.dir.Tx.Ede.enable = VMXF_DISABLE;
                vlParamTx.dir.Tx.subVl[0].bufferSize = vlParamTx.frameSizeMax;
                vlParamTx.dir.Tx.subVl[0].maxBuffers = maxTxRecords + 1;

                rc = mxfA664VlCreate(phyChn[0], ref vlParamTx, out vlTx);
            }


            // Create the transmission COM port
            if (rc == MAXT_SUCCESS)
            {
                srcIpAdrs = BitConverter.ToInt32(IPAddress.Parse(SRC_IP_ADRS).GetAddressBytes(), 0);
                srcIpAdrs = IPAddress.HostToNetworkOrder(srcIpAdrs); // address is in host byte order
                dstIpAdrs = BitConverter.ToInt32(IPAddress.Parse(DST_IP_ADRS).GetAddressBytes(), 0);
                dstIpAdrs = IPAddress.HostToNetworkOrder(dstIpAdrs);

                portParam = new MXF_A664_PORT_PARAM();
                portParam.portType = MXF_A664_PORT_TYPE_COM;
                portParam.family = MXF_A664_PORT_FAMILY_IPV4;
                portParam.mode = MXF_A664_PORT_MODE_QUEUING;
                portParam.type.COM.destAddress.port = DST_UDP_PORT;
                portParam.type.COM.destAddress.version.IPv4.address = (UInt32)dstIpAdrs;
                portParam.type.COM.srcAddress.port = SRC_UDP_PORT;
                portParam.type.COM.srcAddress.version.IPv4.address = (UInt32)srcIpAdrs;

                rc = mxfA664PortCreate(vlTx, ref portParam, out portTx);
            }

            if (rc == MAXT_SUCCESS)
            {
                try
                {
                    txRec = Marshal.AllocHGlobal((int)DATARECS_BUFFER_SIZE_MAX);
                }
                catch (OutOfMemoryException)
                {
                    rc = MAXT_ERROR_MEM;
                }
            }

            // Create the reception (RX) virtual link
            if (rc == MAXT_SUCCESS)
            {

                vlParamRx = new MXF_A664_VL_PARAM_RX();
                vlParamRx.VLId = vlid;
                vlParamRx.frameType = MXF_A664_FRAME_TYPE_ARINC664;
                vlParamRx.direction = MXF_A664_VL_DIR_RX;
                vlParamRx.frameSizeMax = 512;
                vlParamRx.dir.Rx.Mac.skewMax = 4 * 1000 * 1000;
                vlParamRx.dir.Rx.Mac.rmPSNRange = 2;

                rc = mxfA664VlCreate(phyChn[0], ref vlParamRx, out vlRx);
            }

            // Create COM RX port
            if (rc == MAXT_SUCCESS)
            {
                portParam = new MXF_A664_PORT_PARAM();
                portParam.portType = MXF_A664_PORT_TYPE_COM;
                portParam.family = MXF_A664_PORT_FAMILY_IPV4;
                portParam.mode = MXF_A664_PORT_MODE_QUEUING;
                portParam.dir.Rx.network = MXF_A664_NETSELECT_ALL;
                portParam.dir.Rx.maxBuffers = 16;
                portParam.dir.Rx.bufferSize = 1518;
                portParam.type.COM.destAddress.port = DST_UDP_PORT;
                portParam.type.COM.destAddress.version.IPv4.address = (UInt32)dstIpAdrs;
                portParam.type.COM.srcAddress.port = SRC_UDP_PORT;
                portParam.type.COM.srcAddress.version.IPv4.address = (UInt32)srcIpAdrs;

                rc = mxfA664PortCreate(vlRx, ref portParam, out portRx);
            }

            // Get buffer handle automatically allocated for the port
            if (rc == MAXT_SUCCESS)
                rc = mxfRxAcqBufferGet(portRx, out rxBuffer);

            if (rc == MAXT_SUCCESS)
            {
                try
                {
                    rxRec = Marshal.AllocHGlobal((int)DATARECS_BUFFER_SIZE_MAX);
                }
                catch (OutOfMemoryException)
                {
                    rc = MAXT_ERROR_MEM;
                }
            }

            if (rc == MAXT_SUCCESS)
                rc = mxfRxAcqBufferAlloc(phyChn[0], 20000, out rxBufferRaw, IntPtr.Zero);

            // Set TX Error Injection rule(s) to apply
            if (rc == MAXT_SUCCESS)
            {
                errorInjectionTx.error = new MXF_A664_ERROR_INJ.Error[8];

                errorInjectionTx.port = MXF_A664_NETSELECT_ALL;
                errorInjectionTx.fragmentOffset = -1;
                // IP header, offset 0, Version-Length
                errorInjectionTx.error[0].id = MXF_A664_ERRORID_VL_FRAME_MASK_AND;
                errorInjectionTx.error[0].offset = MXF_A664_FRAME_HEADER_OFFSET_IP;
                errorInjectionTx.error[0].mask = 0x0f;
                rc = mxfA664ErrorInjectionSet(portTx, 0, ref errorInjectionTx);
            }

            // Define RX Error(s) detection conditions to trap; register the handler.
            if (rc == MAXT_SUCCESS)
                rc = mxfAsyncEventHandlerInit(server, asyncEventHandler, IntPtr.Zero, out asyncEvent);

            if (rc == MAXT_SUCCESS)
            {
                asyncEventInfoRx[0].condID = MXF_ASYNCEVENT_COND_RX_ERROR;
                asyncEventInfoRx[0].condition.rxErr.channel = portRx;
                rc = mxfAsyncEventConditionsSet(asyncEvent, VMXF_ENABLE, 1, asyncEventInfoRx);
            }

            // Set acquisition mode
            if (rc == MAXT_SUCCESS)
                rc = mxfRxAcqModeSet(rxBuffer, MXF_RXACQ_MODE_LINEAR);

            // Start acquisition, check status
            if (rc == MAXT_SUCCESS)
                rc = mxfRxAcqStart(rxBuffer, MXF_RXACQ_FLAG_DEFAULT, 0, 0);
            if (rc == MAXT_SUCCESS)
                rc = mxfRxAcqStart(rxBufferRaw, MXF_RXACQ_FLAG_DEFAULT, 0, 0);

            if (rc == MAXT_SUCCESS)
            {
                rc = mxfRxAcqBufferStatusGet(rxBuffer, out status, out msgCount, out usedBytes, out freeBytes);
                if (rc == MAXT_SUCCESS && (status & MXF_RXACQ_STATUS_RUNNING) > 0)
                    Console.Write("Acquisition Running\n\n");
            }

            recPtr = txRec;

            // Build the Transmit Records
            for (recordIdx = 0; recordIdx < maxTxRecords && rc == MAXT_SUCCESS; recordIdx++)
            {
                data = new MXF_A664_DATAREC();
                data.data = new byte[8192];

                data.control = (recordIdx % 2) > 0 ? 0 : MXF_A664_TX_REC_CTRL_ERROR_INJ;
                data.dataSize = TEST_DATASIZE;
                data.repeatCount = 1;
                for (dataIdx = 0; dataIdx < TEST_DATASIZE; dataIdx++)
                    data.data[dataIdx] = (byte)((dataIdx + ((recordIdx * TEST_DATASIZE) & 0xff)));

                Marshal.StructureToPtr(data, recPtr, false);

                rc = mxfA664NextDataRecordPtrGet(recPtr, out recPtr);
            }

            // Transmit the data
            if (rc == MAXT_SUCCESS)
            {
                rc = mxfA664TxAperiodicWrite(portTx, MXF_TXAPERIODIC_FLAG_DEFAULT, 0, maxTxRecords, txRec, out count);
                Console.Write("{0} frames transmitted\n\n", count);
                // Wait for complete transmission
                mxfSleep(500);
            }

            // Receive the data
            if (rc == MAXT_SUCCESS)
                rc = readAcquisitionData(rxBuffer, rxRec);

            if (rc == MAXT_SUCCESS)
                rc = readAcquisitionData(rxBufferRaw, rxRec);

            // All events should occurs before the end of the sleep
            mxfSleep(1000);

            // Terminate the handler
            if (rc == MAXT_SUCCESS)
                rc = mxfAsyncEventConditionsSet(asyncEvent, VMXF_DISABLE, 1, asyncEventInfoRx);

            if (rc == MAXT_SUCCESS)
                rc = mxfAsyncEventHandlerTerminate(asyncEvent);

            // Terminate Acquisition
            if (rc == MAXT_SUCCESS)
                rc = mxfRxAcqStop(rxBuffer);

            if (rc == MAXT_SUCCESS)
                rc = mxfRxAcqClear(rxBuffer);

            // Make sure the acquisition is stopped
            if (rc == MAXT_SUCCESS)
            {
                rc = mxfRxAcqBufferStatusGet(rxBuffer, out status, out msgCount, out usedBytes, out freeBytes);
                if (rc == MAXT_SUCCESS && (status & MXF_RXACQ_STATUS_STOPPED) > 0 )
                {
                    rc = mxfRxAcqStopTimeGet(rxBuffer, out acqStopTime);
                    if (rc == MAXT_SUCCESS)
                        Console.Write("\nAcquisition stopped at {0}\n", acqStopTime);
                }
            }

            if (rc == MAXT_SUCCESS)
                rc = mxfRxAcqBufferFree(rxBuffer);

            // Free COM ports
            if (rc == MAXT_SUCCESS)
                rc = mxfA664PortRelease(portTx);

            if (rc == MAXT_SUCCESS)
                rc = mxfA664PortRelease(portRx);

            // Free VL(s)
            if (rc == MAXT_SUCCESS)
                rc = mxfA664VlRelease(vlRx);

            if (rc == MAXT_SUCCESS)
                rc = mxfA664VlRelease(vlTx);

            // Free datarec buffers
            if (txRec != IntPtr.Zero)
                Marshal.FreeHGlobal(txRec);

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

            mxfSystemTerminate(server);
            mxfServerDisconnect(server);

            Console.Write("\n\nPress a key to terminate rc=0x{0:X8}\n", rc);
            Console.ReadKey();

            return;
        }


        private static UInt32 AsyncEventHandler(UInt64 asyncEvent, IntPtr pParam)
        {
            UInt64 handle;
            var pendingList = new MXF_ASYNCEVENT_PENDING_INFO[256];
            UInt64 status;
            UInt64 index, pendingCnt;
            UInt32 rc = MAXT_SUCCESS;

            //(void)param;

            rc = mxfAsyncEventPendingGet(asyncEvent, 256, out pendingCnt, pendingList);

            for (index = 0; index < pendingCnt && rc == MAXT_SUCCESS; index++)
            {
                switch (pendingList[index].condID)
                {
                    case MXF_ASYNCEVENT_COND_RX_ERROR:
                        {
                            status = pendingList[index].condition.rxErr.status;
                            Console.Write("RX ERR -> status (0x{0:X})\n", status);
                            handle = pendingList[index].condition.rxErr.channel;
                            Console.Write("          PORT Handle=0x{0:X}\n\n", handle);
                            break;
                        }

                    default:
                        Console.Write("Unexpected Event Condition received\n");
                        break;
                }
            }
            return rc;
        }

        private static UInt32 readAcquisitionData(UInt64 rxBuffer, IntPtr rec664)
        {
            IntPtr recPtr = rec664;
            var rxRec664 = new MXF_A664_DATAREC();
            UInt64 recordIdx, dataIdx;
            UInt64 status, msgsCount, bytesCount;
            UInt32 dataSize;
            UInt32 rc = 0;
       
            // Read and display records 
            rc = mxfA664RxAcqRead(rxBuffer, 0, DATARECS_BUFFER_SIZE_MAX, out status, out msgsCount, out bytesCount, rec664);
            if (rc == MAXT_SUCCESS)
                Console.Write("{0} records received\n\n", msgsCount);

            for (recordIdx = 0; recordIdx < msgsCount && rc == MAXT_SUCCESS; recordIdx++)
            {
                rxRec664 = (MXF_A664_DATAREC)Marshal.PtrToStructure(recPtr, typeof(MXF_A664_DATAREC));

                Console.Write("  {0:000}: timeTag={1:D12}, Size={2}", recordIdx, rxRec664.timeTag, rxRec664.dataSize);
                Console.Write("\n        data=");

                dataSize = rxRec664.dataSize;

                for (dataIdx = 0; dataIdx < dataSize; dataIdx++)
                {
                    Console.Write("{0:X2} ", rxRec664.data[dataIdx]);

                    if (((dataIdx + 1) % 8) == 0 && (dataIdx + 1 < rxRec664.dataSize))
                        Console.Write("\n             ");
                }
                Console.Write("\n\n");

                mxfA664NextDataRecordPtrGet(recPtr, out recPtr);
            }
            return rc;
        }
    }
}