MX Foundation 4
write_read_async.cs
/*****************************************************************************
//
// File:
// write_read_async.cs
//
// Copyright (c) MAX Technologies Inc. 1988-2019, All Rights Reserved.
// CONFIDENTIAL AND PROPRIETARY INFORMATION WHICH IS THE
// PROPERTY OF MAX TECHNOLOGIES INC.
//
// This example demonstrates the basic usage of the functions mxfRxAcqReadAsync
// and mxfTxAperiodicWriteAsync.
//
// Hardware requirements:
// - FlexMulti-1553.
//
*****************************************************************************/
#define LOOPBACK
//#define LOCAL
using System;
using static MAXT.MXFoundation.mxf;
using System.Runtime.InteropServices;
using System.Text;
namespace multi_example
{
class write_read_async
{
const int MAX_TX_RECORDS_TO_TRANSMIT = 8;
const int MAX_TX_SUBFRAMES_TO_TRANSMIT = 4; //minimum 4 to have at least one full frame.
public struct ASYNC_CALLBACK_INFO
{
public UInt64 server;
public IntPtr HostBufferHDLC;
public IntPtr HostBufferA717;
public UInt64 protocol; //Protocol number meaning : 0 means HDLC, 1 means ARINC 717
public UInt32 processed;
public UInt32 rc;
}
/***************************************************************************************************************/
// Main
/***************************************************************************************************************/
static void Main(string[] args)
{
UInt32 rc;
UInt64 server = 0;
UInt64 rxChannelHDLC = 0;
UInt64 rxChannelA717 = 0;
UInt64 txChannelHDLC = 0;
UInt64 txChannelA717 = 0;
UInt64 rxBufferHDLC = 0;
UInt64 txBufferHDLC = 0;
UInt64 rxBufferA717 = 0;
UInt64 txBufferA717 = 0;
MXF_HDLC_DATAREC recHDLC = new MXF_HDLC_DATAREC();
recHDLC.data = new UInt16[2048];
MXF_A717_DATAREC recA717 = new MXF_A717_DATAREC();
recA717.data = new UInt16[8192];
IntPtr recPtr = IntPtr.Zero;
UInt64 txBufferSize = 0;
UInt64 rxBufferSize = 0;
IntPtr rxHostBufferHDLC = IntPtr.Zero;
IntPtr txHostBufferHDLC = IntPtr.Zero;
IntPtr rxHostBufferA717 = IntPtr.Zero;
IntPtr txHostBufferA717 = IntPtr.Zero;
UInt64 rxAcqStatus = 0;
UInt64 msgCount = 0;
UInt64 byteCount = 0;
UInt64 data, word, subframeSize;
UInt64 freebytes;
ASYNC_CALLBACK_INFO asyncInfoHDLC = new ASYNC_CALLBACK_INFO();
asyncInfoHDLC.HostBufferA717 = IntPtr.Zero;
asyncInfoHDLC.HostBufferHDLC = IntPtr.Zero;
asyncInfoHDLC.processed = 0;
asyncInfoHDLC.protocol = 0;
asyncInfoHDLC.rc = 0;
asyncInfoHDLC.server = 0;
ASYNC_CALLBACK_INFO asyncInfoA717 = new ASYNC_CALLBACK_INFO();
asyncInfoA717.HostBufferA717 = IntPtr.Zero;
asyncInfoA717.HostBufferHDLC = IntPtr.Zero;
asyncInfoA717.processed = 0;
asyncInfoA717.protocol = 0;
asyncInfoA717.rc = 0;
asyncInfoA717.server = 0;
IntPtr asyncInfoHDLCPtr = IntPtr.Zero;
IntPtr asyncInfo717Ptr = IntPtr.Zero;
// Connect to MX Foundation library
#if LOCAL
rc = mxfServerConnect("0.0.0.0", "", "", FALSE, out server);
#else
rc = mxfServerConnect("192.168.0.1", "admin", "admin", 0, out server);
#endif
//Configuration of the Multi port in HDLC
if (rc == MAXT_SUCCESS)
rc = mxfSystemInitAttributeUint64CallbackHandler(server, initHandler);
// Initializes MX Foundation library
if (rc == MAXT_SUCCESS)
{
Console.Write("Starting ...\n");
rc = mxfSystemInit(server);
}
// Gets handle of first HDLC RX channel
if (rc == MAXT_SUCCESS)
rc = mxfChannelGet(server, MXF_CLASS_HDLC, MXF_SCLASS_RX_CHANNEL, MXF_MODULE_MULTI_EH, 0, out rxChannelHDLC);
// Gets handle of first HDLC TX channel
if (rc == MAXT_SUCCESS)
rc = mxfChannelGet(server, MXF_CLASS_HDLC, MXF_SCLASS_TX_CHANNEL, MXF_MODULE_MULTI_EH, 0, out txChannelHDLC);
// Gets handle of first ARINC 717 RX channel
if (rc == MAXT_SUCCESS)
rc = mxfChannelGet(server, MXF_CLASS_A717, MXF_SCLASS_RX_CHANNEL, MXF_MODULE_MULTI_EH, 0, out rxChannelA717);
// Gets handle of first ARINC 717 TX channel
if (rc == MAXT_SUCCESS)
rc = mxfChannelGet(server, MXF_CLASS_A717, MXF_SCLASS_TX_CHANNEL, MXF_MODULE_MULTI_EH, 0, out txChannelA717);
// Sets frame size and internal clock frequency
if (rc == MAXT_SUCCESS)
rc = mxfAttributeUint64Set(rxChannelHDLC, KMXF_HDLC_FRAME_SIZE_ENABLE, VMXF_ENABLE);
if (rc == MAXT_SUCCESS)
rc = mxfAttributeUint64Set(txChannelHDLC, KMXF_HDLC_FRAME_SIZE_ENABLE, VMXF_ENABLE);
if (rc == MAXT_SUCCESS)
rc = mxfAttributeUint64Set(txChannelHDLC, KMXF_HDLC_CLOCK_SOURCE, VMXF_HDLC_CLOCK_SOURCE_INTERNAL);
if (rc == MAXT_SUCCESS)
rc = mxfAttributeUint64Set(txChannelHDLC, KMXF_HDLC_INTERNAL_CLOCK_FREQ, 100000);
// Sets RX & TX channels subframe size to 128 words
subframeSize = 128;
if (rc == MAXT_SUCCESS)
rc = mxfAttributeUint64Set(rxChannelA717, KMXF_A717_SUBFRAME_SIZE, subframeSize);
if (rc == MAXT_SUCCESS)
rc = mxfAttributeUint64Set(txChannelA717, KMXF_A717_SUBFRAME_SIZE, subframeSize);
// Sets RX & TX channels bit encoding to harvard
if (rc == MAXT_SUCCESS)
rc = mxfAttributeUint64Set(rxChannelA717, KMXF_A717_BIT_ENCODING, VMXF_A717_BIT_ENCODING_HARVARDBIPHASE);
if (rc == MAXT_SUCCESS)
rc = mxfAttributeUint64Set(txChannelA717, KMXF_A717_BIT_ENCODING, VMXF_A717_BIT_ENCODING_HARVARDBIPHASE);
// Sets RX & TX channels electrical selection to default
if (rc == MAXT_SUCCESS)
rc = mxfAttributeUint64Set(rxChannelA717, KMXF_A717_ELECTRICAL_SELECTION, VMXF_A717_ELECTRICAL_SELECT_DEFAULT);
if (rc == MAXT_SUCCESS)
rc = mxfAttributeUint64Set(txChannelA717, KMXF_A717_ELECTRICAL_SELECTION, VMXF_A717_ELECTRICAL_SELECT_DEFAULT);
// Enables loopback
# if LOOPBACK
if (rc == MAXT_SUCCESS)
rc = mxfAttributeUint64Set(rxChannelHDLC, KMXF_HDLC_TX_RX_TEST_LB, VMXF_ENABLE);
if (rc == MAXT_SUCCESS)
rc = mxfAttributeUint64Set(rxChannelA717, KMXF_A717_TX_RX_TEST_LB, VMXF_ENABLE);
#endif
// Allocates 4 KB buffer for tx HDLC data
if (rc == MAXT_SUCCESS)
{
txBufferSize = 40 * 1024;
// Allocates TX Aperiodic static buffer for HIGH priority queue
rc = mxfTxAperiodicBufferAlloc(txChannelHDLC, MXF_TXAPERIODIC_PRIORITY_HIGH, txBufferSize, out txBufferHDLC, IntPtr.Zero);
// Host buffer allocation
if (rc == MAXT_SUCCESS)
{
try
{
txHostBufferHDLC = Marshal.AllocHGlobal((int)txBufferSize);
}
catch (OutOfMemoryException)
{
rc = MAXT_ERROR_MEM;
}
}
}
// Allocates 4 KB buffer for RX HDLC data
if (rc == MAXT_SUCCESS)
{
rxBufferSize = 40 * 1024;
// Allocates RX acquisition static buffer
rc = mxfRxAcqBufferAlloc(rxChannelHDLC, rxBufferSize, out rxBufferHDLC, IntPtr.Zero);
// Host buffer allocation
if (rc == MAXT_SUCCESS)
{
try
{
rxHostBufferHDLC = Marshal.AllocHGlobal((int)rxBufferSize);
}
catch (OutOfMemoryException)
{
rc = MAXT_ERROR_MEM;
}
}
}
//Allocate to hold ASYNC_CALLBACK_INFO to pass to mxfTxAperiodicWriteAsync and mxfRxAcqReadAsync
try
{
asyncInfoHDLCPtr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(ASYNC_CALLBACK_INFO)));
asyncInfo717Ptr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(ASYNC_CALLBACK_INFO)));
}
catch (OutOfMemoryException)
{
rc = MAXT_ERROR_MEM;
}
asyncInfoHDLC.HostBufferHDLC = rxHostBufferHDLC;
asyncInfoHDLC.protocol = 0;
asyncInfoHDLC.processed = 0;
asyncInfoHDLC.rc = 0;
// Allocates buffer for tx ARINC 717 data
if (rc == MAXT_SUCCESS)
{
txBufferSize = 2*MAX_TX_SUBFRAMES_TO_TRANSMIT * (UInt64)Marshal.SizeOf(typeof(MXF_A717_DATAREC));
// Allocates TX Aperiodic static buffer for HIGH priority queue
rc = mxfTxAperiodicBufferAlloc(txChannelA717, MXF_TXAPERIODIC_PRIORITY_HIGH, txBufferSize, out txBufferA717, IntPtr.Zero);
// Host buffer allocation
if (rc == MAXT_SUCCESS)
{
try
{
txHostBufferA717 = Marshal.AllocHGlobal((int)txBufferSize);
}
catch (OutOfMemoryException)
{
rc = MAXT_ERROR_MEM;
}
}
}
// Allocates buffer for rx ARINC 717 data
if (rc == MAXT_SUCCESS)
{
rxBufferSize = 2*MAX_TX_SUBFRAMES_TO_TRANSMIT * (UInt64)Marshal.SizeOf(typeof(MXF_A717_DATAREC));
// Allocates RX acquisition static buffer
rc = mxfRxAcqBufferAlloc(rxChannelA717, rxBufferSize, out rxBufferA717, IntPtr.Zero);
// Host buffer allocation
if (rc == MAXT_SUCCESS)
{
try
{
rxHostBufferA717 = Marshal.AllocHGlobal((int)rxBufferSize);
}
catch (OutOfMemoryException)
{
rc = MAXT_ERROR_MEM;
}
}
}
asyncInfoA717.HostBufferA717 = rxHostBufferA717;
asyncInfoA717.protocol = 1;
asyncInfoA717.processed = 0;
asyncInfoA717.rc = 0;
// Sets timebase to RTC nsec
if (rc == MAXT_SUCCESS)
rc = mxfSystemTimeBaseSet(server, MXF_TIMEBASE_DEVICE_NSEC);
// Starts acquisition
if (rc == MAXT_SUCCESS)
rc = mxfRxAcqStart(rxBufferHDLC, MXF_RXACQ_FLAG_DEFAULT, 0, 0);
if (rc == MAXT_SUCCESS)
rc = mxfRxAcqStart(rxBufferA717, MXF_RXACQ_FLAG_DEFAULT, 0, 0);
if (rc == MAXT_SUCCESS)
{
recPtr = txHostBufferHDLC;
//Prepares an HDLC record to send
for (data = 0; data < MAX_TX_RECORDS_TO_TRANSMIT; data++)
{
recHDLC.timeTag = 0;
recHDLC.control = 0;
recHDLC.repeatCount = 1;
recHDLC.dataSize = 8;
recHDLC.reserved = 0;
for (word = 0; word < recHDLC.dataSize / 2; word++)
{
recHDLC.data[word] = (UInt16)(0x0101 * data);
}
Marshal.StructureToPtr(recHDLC, recPtr, true);
rc = mxfHDLCNextDataRecordPtrGet(recPtr, out recPtr);
}
}
Marshal.StructureToPtr(asyncInfoHDLC, asyncInfoHDLCPtr, true);
if (rc == MAXT_SUCCESS)
rc = mxfTxAperiodicWriteAsync(txBufferHDLC, MXF_TXAPERIODIC_FLAG_DEFAULT, 0, MAX_TX_RECORDS_TO_TRANSMIT, txHostBufferHDLC, writeCompletion, asyncInfoHDLCPtr);
if (rc == MAXT_SUCCESS)
{
// Prepares an ARINC 717 string array
recPtr = txHostBufferA717;
for (data = 0; data < MAX_TX_SUBFRAMES_TO_TRANSMIT; data++)
{
recA717.timeTag = 0;
recA717.control = 0;
recA717.dataSize = 2 * (UInt32)subframeSize; // 16 bits per word in subframe
recA717.repeatCount = 1;
recA717.reserved = 0;
for (word = 0; word < subframeSize; word++)
{
if (word == 0)
{
//1st word of each subframe has to be a sync word
// sync words are:
// - 0x247 for subframe #0
// - 0x5B8 for subframe #1
// - 0xA47 for subframe #2
// - 0xDB8 for subframe #3
switch (data % 4)
{
case 0:
recA717.data[word] = 0x247;
break;
case 1:
recA717.data[word] = 0x5B8;
break;
case 2:
recA717.data[word] = 0xA47;
break;
case 3:
recA717.data[word] = 0xDB8;
break;
default:
break;
}
}
else
recA717.data[word] = (UInt16)(0x11 * word);
}
Marshal.StructureToPtr(recA717, recPtr, true);
rc = mxfA717NextDataRecordPtrGet(recPtr, out recPtr);
}
}
Marshal.StructureToPtr(asyncInfoA717, asyncInfo717Ptr, true);
if (rc == MAXT_SUCCESS)
rc = mxfTxAperiodicWriteAsync(txBufferA717, MXF_TXAPERIODIC_FLAG_DEFAULT, 0, MAX_TX_SUBFRAMES_TO_TRANSMIT, txHostBufferA717, writeCompletion, asyncInfo717Ptr);
// Do something while the tx data are sent to the device
// Simply wait until all HDLC and A717 records are received on the interface
if (rc == MAXT_SUCCESS)
{
do
{
asyncInfoHDLC = (ASYNC_CALLBACK_INFO)Marshal.PtrToStructure(asyncInfoHDLCPtr, typeof(ASYNC_CALLBACK_INFO));
asyncInfoA717 = (ASYNC_CALLBACK_INFO)Marshal.PtrToStructure(asyncInfo717Ptr, typeof(ASYNC_CALLBACK_INFO));
mxfSleep(1);
} while (asyncInfoHDLC.processed == 0 || asyncInfoA717.processed == 0);
if (asyncInfoHDLC.rc > 0)
rc = asyncInfoHDLC.rc;
else if (asyncInfoA717.rc > 0)
rc = asyncInfoA717.rc;
if (rc == MAXT_SUCCESS)
{
UInt64 msgCountA717 = 0;
do
{
mxfSleep(100);
rc = mxfRxAcqBufferStatusGet(rxBufferHDLC, out rxAcqStatus, out msgCount, out byteCount, out freebytes);
if (rc == MAXT_SUCCESS)
rc = mxfRxAcqBufferStatusGet(rxBufferA717, out rxAcqStatus, out msgCountA717, out byteCount, out freebytes);
} while (rc == MAXT_SUCCESS && ((msgCount != MAX_TX_RECORDS_TO_TRANSMIT) || (msgCountA717 != MAX_TX_SUBFRAMES_TO_TRANSMIT)));
}
}
if (rc == MAXT_SUCCESS)
{
Console.Write("Receiving ...\n\n");
// Reads rx buffer
asyncInfoHDLC = (ASYNC_CALLBACK_INFO)Marshal.PtrToStructure(asyncInfoHDLCPtr, typeof(ASYNC_CALLBACK_INFO));
asyncInfoHDLC.processed = 0;
Marshal.StructureToPtr(asyncInfoHDLC, asyncInfoHDLCPtr, false);
rc = mxfRxAcqReadAsync(rxBufferHDLC, 0, 40 * 1024, asyncInfoHDLC.HostBufferHDLC, readCompletion, asyncInfoHDLCPtr);
if (rc == MAXT_SUCCESS)
{
asyncInfoA717 = (ASYNC_CALLBACK_INFO)Marshal.PtrToStructure(asyncInfo717Ptr, typeof(ASYNC_CALLBACK_INFO));
asyncInfoA717.processed = 0;
Marshal.StructureToPtr(asyncInfoA717, asyncInfo717Ptr, false);
rc = mxfRxAcqReadAsync(rxBufferA717, 0, 2 * MAX_TX_SUBFRAMES_TO_TRANSMIT * (UInt64)Marshal.SizeOf(typeof(MXF_A717_DATAREC)), asyncInfoA717.HostBufferA717, readCompletion, asyncInfo717Ptr);
}
}
// Do something while the rx data are received from the device
// Simply wait until all HDLC and A717 records are read from the interface
if (rc == MAXT_SUCCESS)
{
do
{
asyncInfoHDLC = (ASYNC_CALLBACK_INFO)Marshal.PtrToStructure(asyncInfoHDLCPtr, typeof(ASYNC_CALLBACK_INFO));
asyncInfoA717 = (ASYNC_CALLBACK_INFO)Marshal.PtrToStructure(asyncInfo717Ptr, typeof(ASYNC_CALLBACK_INFO));
mxfSleep(1);
} while (asyncInfoHDLC.processed == 0 || asyncInfoA717.processed == 0);
}
// Stops acquisition
if (rc == MAXT_SUCCESS)
rc = mxfRxAcqStop(rxBufferHDLC);
if (rc == MAXT_SUCCESS)
rc = mxfRxAcqStop(rxBufferA717);
// Frees device and host buffers
mxfTxAperiodicBufferFree(txBufferHDLC);
mxfTxAperiodicBufferFree(txBufferA717);
mxfRxAcqBufferFree(rxBufferHDLC);
mxfRxAcqBufferFree(rxBufferA717);
if (txHostBufferHDLC != IntPtr.Zero)
Marshal.FreeHGlobal(txHostBufferHDLC);
if (txHostBufferA717 != IntPtr.Zero)
Marshal.FreeHGlobal(txHostBufferA717);
if (rxHostBufferHDLC != IntPtr.Zero)
Marshal.FreeHGlobal(rxHostBufferHDLC);
if (rxHostBufferA717 != IntPtr.Zero)
Marshal.FreeHGlobal(rxHostBufferA717);
if (asyncInfo717Ptr != IntPtr.Zero)
Marshal.FreeHGlobal(asyncInfo717Ptr);
if (asyncInfoHDLCPtr != IntPtr.Zero)
Marshal.FreeHGlobal(asyncInfoHDLCPtr);
if (rc != MAXT_SUCCESS)
{
StringBuilder errorString = new StringBuilder(256);
rc = mxfSystemErrorStringGet(server, rc, (UInt32)errorString.Length, errorString);
Console.Write(errorString + "\n");
}
Console.Write("Terminating ...\n");
// Unloads MX Foundation library
mxfSystemTerminate(server);
// Disconnects from MX Foundation library
mxfServerDisconnect(server);
Console.Write("\nPress a key to terminate\n");
Console.ReadKey();
return;
}
public static UInt32 initHandler(UInt64 server, UInt64 deviceIndex, UInt64 moduleIndex, UInt64 channelIndex, UInt64 attrib, ref UInt64 value)
{
MXF_DEVICE_INFO info = new MXF_DEVICE_INFO();
UInt64 device = 0;
UInt32 rc = 0;
UInt64 i = 0;
Int64 modulePosition = 999;
//Get the 1st module multi position on the device
rc = mxfSystemDeviceGet(server, 0, out device);
if (rc == MAXT_SUCCESS)
rc = mxfDeviceInfoGet(device, out info);
for (i = 0; i < info.moduleCount && rc == MAXT_SUCCESS; i++)
{
if (info.modules[i].type == MXF_MODULE_MULTI_EH)
{
modulePosition = info.modules[i].position;
break;
}
}
// Sets IPM-MULTI-EH first TX and RX channel to HDLC
if (attrib == KMXF_CHANNEL_CLASS)
{
if ((deviceIndex == 0) && (moduleIndex == (UInt64)modulePosition) && ((channelIndex == 0) || (channelIndex == 8)))
{
value = MXF_CLASS_HDLC;
return Convert.ToUInt32(true);
}
//Sets the TX and RX channel clock
else if ((deviceIndex == 0) && (moduleIndex == (UInt64)modulePosition) && ((channelIndex == 4) || (channelIndex == 12)))
{
value = MXF_CLASS_CLOCK;
return Convert.ToUInt32(true);
}
//Sets IMP-MULTI-EH second TX and RX channel to ARINC 717
if ((deviceIndex == 0) && (moduleIndex == (UInt64)modulePosition) && ((channelIndex == 1) || (channelIndex == 9)))
{
value = MXF_CLASS_A717;
return Convert.ToUInt32(true);
}
}
return Convert.ToUInt32(false);
}
public static void writeCompletion(UInt64 bufferHandle, UInt32 result, IntPtr context, UInt64[] output)
{
//UInt64 output = (UInt64)Marshal.PtrToStructure(outputPtr, typeof(UInt64));
ASYNC_CALLBACK_INFO info = new ASYNC_CALLBACK_INFO();
info = (ASYNC_CALLBACK_INFO)Marshal.PtrToStructure(context, typeof(ASYNC_CALLBACK_INFO));
if (result == 0)
{
if (info.protocol == 0)
{
Console.Write("{0} HDLC records have been successfully transmitted.\n\n", output[0]);
}
else
{
Console.Write("{0} ARINC 717 records have been successfully transmitted.\n\n", output[0]);
}
}
else
{
StringBuilder errorString = new StringBuilder(256);
if(mxfSystemErrorStringGet(info.server, result, (UInt32)errorString.Length, errorString) == MAXT_SUCCESS)
Console.Write(errorString + " ERROR # 0x{1:X}", result.ToString());
Console.Write(errorString + "\n\r");
}
info.rc = result;
info.processed = 1;
Marshal.StructureToPtr(info, context, true);
}
public static void readCompletion(UInt64 bufferHandle, UInt32 result, IntPtr context, UInt64[] output)
{
ASYNC_CALLBACK_INFO info = new ASYNC_CALLBACK_INFO();
info = (ASYNC_CALLBACK_INFO)Marshal.PtrToStructure(context, typeof(ASYNC_CALLBACK_INFO));
if (result == 0)
{
if (info.protocol == 0)
{
Console.Write("HDLC string received count = {0} \n", output[1]);
DisplayDataArrayHDLC(output[1], info.HostBufferHDLC);
Console.Write("\n");
}
else
{
Console.Write("ARINC 717 string received count = {0} \n", output[1]);
DisplayDataArrayA717(output[1], info.HostBufferA717);
Console.Write("\n");
}
info.rc = result;
info.processed = 1;
Marshal.StructureToPtr(info, context, true);
}
else
{
StringBuilder errorString = new StringBuilder(256);
if (mxfSystemErrorStringGet(info.server, result, (UInt32)errorString.Length, errorString) == MAXT_SUCCESS)
Console.Write(errorString + " ERROR # 0x{1:X}", result.ToString());
Console.Write(errorString + "\n\r");
}
}
public static void DisplayDataArrayHDLC(UInt64 recNum, IntPtr recPtr)
{
UInt64 iRec,
iData;
IntPtr tempPtr = recPtr;
Console.Write("\n");
for (iRec = 0; iRec < recNum; iRec++)
{
MXF_HDLC_DATAREC rec = new MXF_HDLC_DATAREC();
rec = (MXF_HDLC_DATAREC)Marshal.PtrToStructure(tempPtr, typeof(MXF_HDLC_DATAREC));
Console.Write("{0:000} {1} 0x{2:x8} {3} ", iRec, rec.timeTag, rec.control, rec.dataSize);
for (iData = 0; iData < rec.dataSize / 2; iData++)
{
Console.Write("{0:x4} ", rec.data[iData]);
if (((iData + 1) % 8)== 0 && (iData + 1 < rec.dataSize / 2))
Console.Write("\n ");
}
Console.Write("\n");
mxfHDLCNextDataRecordPtrGet(tempPtr, out tempPtr);
}
}
public static void DisplayDataArrayA717(UInt64 recNum, IntPtr recPtr)
{
UInt64 iRec,
iData;
IntPtr tempPtr = recPtr;
Console.Write("\n");
for (iRec = 0; iRec < recNum; iRec++)
{
MXF_HDLC_DATAREC rec = new MXF_HDLC_DATAREC();
rec = (MXF_HDLC_DATAREC)Marshal.PtrToStructure(tempPtr, typeof(MXF_HDLC_DATAREC));
Console.Write("{0:000} {1} 0x{2:x8} {3} ", iRec, rec.timeTag, rec.control, rec.dataSize);
for (iData = 0; iData < (rec.dataSize) / 2; iData++)
{
Console.Write("{0:x3}", rec.data[iData]);
if ((((iData + 1) % 16) == 0) && (iData + 1 < rec.dataSize))
Console.Write("\n ");
}
Console.Write("\n");
mxfA717NextDataRecordPtrGet(tempPtr, out tempPtr);
}
}
}
}
Updated 10/23/2023