async_flexsmp_rs232.cs

/*****************************************************************************
//
//     File:
//        async_flexsmp_rs232.cs
//
//       Copyright (c) MAX Technologies Inc. 1988-2023, All Rights Reserved.
//             CONFIDENTIAL AND PROPRIETARY INFORMATION WHICH IS THE
//                         PROPERTY OF MAX TECHNOLOGIES INC.
//
//      This example demonstrates the basic usage of ASYNC enhanced channel class
//      for transmission and reception on FlexSMP Module with RS-232 Electrical Interface.
//
//       Hardware requirements:
//          - MAXT FlexMax Device with FMX-SMP-040804 Module
//
*****************************************************************************/

//#define LOCAL
//#define LOOPBACK

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

namespace async_flexsmp_rs232_example {
    class async_flexsmp_rs232 {
        static void Main(string[] args) {

            UInt32 rc = MAXT_SUCCESS;

            UInt64 server = 0;
            var device = new UInt64[1];
            var module = new UInt64[1];
            UInt64 rxChannel = 0, txChannel = 0;


            UInt64 bufferSize = 0, mxfRxBuffer = 0, mxfTxBuffer = 0;
            UInt64 rxAcqStatus = 0;
            UInt64 deviceCount = 0, moduleCount = 0, msgCount = 0, byteCount = 0;

            //Get Server Handle
#if (LOCAL)
            rc = mxfServerConnect("0.0.0.0", "", "", Convert.ToUInt64(false), out server);
#else
            rc = mxfServerConnect("192.168.0.1", "admin", "admin", Convert.ToUInt64(false), out server);
#endif

            // Initialize MX Foundation library
            if (rc == MAXT_SUCCESS) {
                Console.WriteLine("Initializing ...");
                rc = mxfSystemInit(server);
            }

            //Get Device handle 
            if (rc == MAXT_SUCCESS) {
                rc = mxfSystemDeviceAllGet(server, MXF_DEVICE_FLEXMAX, 1, out deviceCount, device);
            }

            //Get Module handle 
            if (rc == MAXT_SUCCESS && deviceCount == 1) {
                rc = mxfDeviceModuleAllGet(device[0], MXF_MODULE_FLEXSMP, 1, out moduleCount, module);
            }

            if (rc == MAXT_SUCCESS && moduleCount == 0) {
                rc = MAXT_ERROR_NOT_FOUND;
            }

            // Get Receiver(Rx) Channel Handle
            if (rc == MAXT_SUCCESS) {
                rc = mxfModuleChannelGet(module[0], 28, out rxChannel);
            }

            // Get Transmiter(Tx) Channel Handle
            if(rc == MAXT_SUCCESS) {
                rc = mxfModuleChannelGet(module[0], 8, out txChannel);
            }

            // Set Channel Class to Async
            if (rc == MAXT_SUCCESS) {
                rc = mxfAttributeUint64Set(rxChannel, KMXF_CHANNEL_CLASS, MXF_CLASS_ASYNC_ENHANCED);
            }

            if (rc == MAXT_SUCCESS) {
                rc = mxfAttributeUint64Set(txChannel, KMXF_CHANNEL_CLASS, MXF_CLASS_ASYNC_ENHANCED);
            }

            // Set Electrical Termination to None
            if (rc == MAXT_SUCCESS) {
                rc = mxfAttributeUint64Set(rxChannel, KMXF_ASYNCEH_TERMINATION, VMXF_ASYNCEH_TERMINATION_NONE);
            }

            if (rc == MAXT_SUCCESS) {
                rc = mxfAttributeUint64Set(txChannel, KMXF_ASYNCEH_TERMINATION, VMXF_ASYNCEH_TERMINATION_NONE);
            }

            // Set Channel Speed to 115.2 Kbps
            if (rc == MAXT_SUCCESS) {
                rc = mxfAttributeUint64Set(rxChannel, KMXF_ASYNCEH_SPEED, 115200);
            }

            if (rc == MAXT_SUCCESS) {
                rc = mxfAttributeUint64Set(txChannel, KMXF_ASYNCEH_SPEED, 115200);
            }

            // Set Parity to Odd
            if (rc == MAXT_SUCCESS) {
                rc = mxfAttributeUint64Set(rxChannel, KMXF_ASYNCEH_PARITY, VMXF_ASYNCEH_PARITY_ODD);
            }

            if (rc == MAXT_SUCCESS) {
                rc = mxfAttributeUint64Set(txChannel, KMXF_ASYNCEH_PARITY, VMXF_ASYNCEH_PARITY_ODD);
            }

            // Set Rx Channel string gap to 4
            if (rc == MAXT_SUCCESS) {
                rc = mxfAttributeUint64Set(rxChannel, KMXF_ASYNCEH_RX_STRING_GAP, 4);
            }

#if (LOOPBACK)
            // Set Rx Channel loopback
            if (rc == MAXT_SUCCESS) {
                rc = mxfAttributeUint64Set(rxChannel, KMXF_ASYNCEH_TX_RX_TEST_LB, VMXF_ENABLE);
            }
#endif

            bufferSize = (UInt64)Marshal.SizeOf(typeof(MXF_ASYNCEH_DATAREC));

            // Allocate acquisition static buffer
            if (rc == MAXT_SUCCESS) {
                rc = mxfRxAcqBufferAlloc(rxChannel, bufferSize, out mxfRxBuffer, IntPtr.Zero);
            }

            //Start acquisition service
            if (rc == MAXT_SUCCESS) {
                rc = mxfRxAcqStart(mxfRxBuffer, MXF_RXACQ_FLAG_DEFAULT, 0, 0);
            }

            // Allocate TX Aperiodic static buffer with HIGH priority queue
            if (rc == MAXT_SUCCESS) {
                rc = mxfTxAperiodicBufferAlloc(txChannel, MXF_TXAPERIODIC_PRIORITY_HIGH, bufferSize, out mxfTxBuffer, IntPtr.Zero);
            }

            // Transmit One Record
            if (rc == MAXT_SUCCESS) {

                string dataString = "Hello, World!\0";
                byte[] dataByte = Encoding.UTF8.GetBytes(dataString);

                var txRec = new MXF_ASYNCEH_DATAREC() {
                    reserved = 0,
                    timeTag = 0,
                    control = 0,
                    repeatCount = 1,
                    dataSize = (UInt32)dataByte.Length,
                    data = new byte[256],
                };

                Array.Copy(dataByte, txRec.data, dataByte.Length);

                IntPtr recPtr = Marshal.AllocHGlobal((int)bufferSize + 256);
                Marshal.StructureToPtr(txRec, recPtr, false);

                Console.WriteLine("Transmitting ...\n");
                rc = mxfASYNCEHTxAperiodicWrite(mxfTxBuffer, MXF_TXAPERIODIC_FLAG_DEFAULT, 0, 1, recPtr);
                Marshal.FreeHGlobal(recPtr);
            }

            //Wait
            if (rc == MAXT_SUCCESS) {
                mxfSleep(1000);
            }

            // Acquisition
            if (rc == MAXT_SUCCESS) {

                MXF_ASYNCEH_DATAREC rxRec = new MXF_ASYNCEH_DATAREC() { data = new byte[256] };

                IntPtr recPtr = Marshal.AllocHGlobal((int)bufferSize);
                if (recPtr == IntPtr.Zero) {
                    rc = MAXT_ERROR_MEM;
                }

                // Read received record
                if (rc == MAXT_SUCCESS) {
                    Console.WriteLine("Receiving ...");
                    rc = mxfASYNCEHRxAcqRead(mxfRxBuffer, 1, bufferSize, out rxAcqStatus, out msgCount, out byteCount, recPtr);

                    if (rc == MAXT_SUCCESS && msgCount == 1) {
                        rxRec = Marshal.PtrToStructure<MXF_ASYNCEH_DATAREC>(recPtr);
                        Console.WriteLine("   Timetag: {0}  Size: {1}", rxRec.timeTag, rxRec.dataSize);
                        Console.WriteLine("   String: {0}", Encoding.UTF8.GetString(rxRec.data, 0, (int)rxRec.dataSize));
                    }
                }

                if (recPtr != IntPtr.Zero) {
                    Marshal.FreeHGlobal(recPtr);
                }
            }

            // Stop acquisition
            if (rc == MAXT_SUCCESS) {
                rc = mxfRxAcqStop(mxfRxBuffer);
            }

            // Display Return Error Codes
            if (rc != MAXT_SUCCESS) {
                StringBuilder buffer = new StringBuilder(256);

                if (mxfSystemErrorStringGet(server, rc, 256, buffer) != MAXT_SUCCESS) {
                    buffer.Append(string.Format("ERROR # 0x{0:x8}", rc));
                }

                Console.WriteLine(buffer);
            }

            Console.WriteLine();
            Console.WriteLine("Terminating...");

            // Free mxf buffers
            if (mxfRxBuffer != 0) {
                mxfRxAcqBufferFree(mxfRxBuffer);
            }
            if (mxfTxBuffer != 0) {
                mxfTxAperiodicBufferFree(mxfTxBuffer);
            }

            // Unload MX Foundation library
            mxfSystemTerminate(server);

            // Disconnect from MX Foundation library
            mxfServerDisconnect(server);

            Console.WriteLine();
            Console.WriteLine("Press enter to exit");
            Console.Read();

            return;
        }
    }
}