csdb_flexsmp.c

/*****************************************************************************
//
//     File:
//        csdb_flexSMP.c
//
//       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 CSDB channel class
//      for transmission and reception on FlexSMP Module.
//
//       Hardware requirements:
//          - MAXT FlexSMP Module with configurable CSDB channels
//
*****************************************************************************/

#include "example.h"

//#define LOCAL
//#define LOOPBACK

#define BLOCK_COUNT     8

int main(void) {

    uint32                  rc = MAXT_SUCCESS;

    HMXF_SERVER             server = 0;
    HMXF_CHANNEL            rxChannel = 0;
    HMXF_CHANNEL            txChannel = 0;

    size_t                  bufferSize = 0;
    HMXF_BUFFER             mxfRxBuffer = 0;
    HMXF_BUFFER             mxfTxBuffer = 0;

    MXF_CSDB_DATAREC        txRec[2];
    MXF_CSDB_DATAREC        rxRec[2];

    uint64                  rxAcqStatus = 0;
    uint64                  msgCount = 0, byteCount = 0;
    uint64                  i = 0, iByte = 0;

    //Get Server Handle
#ifdef LOCAL
    rc = mxfConnectPCIE(&server);
#else
    rc = mxfConnectEthernet("192.168.0.1", "admin", "admin", FALSE, &server);
#endif

    // Initialize MX Foundation library
    if (!rc) {
        printf("Initializing ...\n");
        rc = mxfSystemInit(server);
    }

    //Get Receiver (Rx) Channel Handle
    if (!rc) {
        rc = mxfChannelGet(server, MXF_CLASS_ALL, MXF_SCLASS_RX_CHANNEL, MXF_MODULE_FLEXSMP, 0, &rxChannel);
    }

    //Get Transmiter(Tx) Channel Handle
    if (!rc) {
        rc = mxfChannelGet(server, MXF_CLASS_ALL, MXF_SCLASS_TX_CHANNEL, MXF_MODULE_FLEXSMP, 0, &txChannel);
    }

    //Set Channel Class
    if (!rc) {
        rc = mxfAttributeUint64Set(rxChannel, KMXF_CHANNEL_CLASS, MXF_CLASS_CSDB);
    }
    if (!rc) {
        rc = mxfAttributeUint64Set(txChannel, KMXF_CHANNEL_CLASS, MXF_CLASS_CSDB);
    }

    //Set speed to 50 Kbps
    if (!rc) {
        rc = mxfAttributeUint64Set(rxChannel, KMXF_CSDB_SPEED, 50000);
    }
    if (!rc) {
        rc = mxfAttributeUint64Set(txChannel, KMXF_CSDB_SPEED, 50000);
    }

    //Set Parity to odd
    if (!rc) {
        rc = mxfAttributeUint64Set(rxChannel, KMXF_CSDB_PARITY, VMXF_CSDB_PARITY_ODD);
    }
    if (!rc) {
        rc = mxfAttributeUint64Set(txChannel, KMXF_CSDB_PARITY, VMXF_CSDB_PARITY_ODD);
    }

    //Set Stop bit size to 1
    if (!rc) {
        rc = mxfAttributeUint64Set(rxChannel, KMXF_CSDB_STOPBITSIZE, 1);
    }
    if (!rc) {
        rc = mxfAttributeUint64Set(txChannel, KMXF_CSDB_STOPBITSIZE, 1);
    }

    //Set BLock Count
    if (!rc) {
        rc = mxfAttributeUint64Set(rxChannel, KMXF_CSDB_BLOCKCOUNT, BLOCK_COUNT);
    }
    if (!rc) {
        rc = mxfAttributeUint64Set(txChannel, KMXF_CSDB_BLOCKCOUNT, BLOCK_COUNT);
    }

    //Set Termination to 120 Ohm
    if (!rc) {
        rc = mxfAttributeUint64Set(rxChannel, KMXF_CSDB_TERMINATION, VMXF_CSDB_TERMINATION_120OHM);
    }
    if (!rc) {
        rc = mxfAttributeUint64Set(txChannel, KMXF_CSDB_TERMINATION, VMXF_CSDB_TERMINATION_120OHM);
    }

#ifdef LOOPBACK
    //Set Channel loopback
    if (!rc) {
        rc = mxfAttributeUint64Set(rxChannel, KMXF_CSDB_TX_RX_TEST_LB, VMXF_ENABLE);
    }
#endif

    //Set buffer size
    bufferSize = (uint64)2 * sizeof(MXF_CSDB_DATAREC);

    // Allocate acquisition static buffer
    if (!rc) {
        rc = mxfRxAcqBufferAlloc(rxChannel, bufferSize, &mxfRxBuffer, NULL);
    }

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

    // Allocate TX Aperiodic static buffer
    if (!rc) {
        rc = mxfTxAperiodicBufferAlloc(txChannel, MXF_TXAPERIODIC_PRIORITY_HIGH, bufferSize, &mxfTxBuffer, NULL);
    }

    // Transmit one Label
    if (!rc) {

        printf("Transmitting ...\n");

        //Sync Block
        txRec[0].reserved = 0;
        txRec[0].timeTag = 0;
        txRec[0].control = 0;
        txRec[0].repeatCount = 1;
        for (iByte = 0; iByte < BLOCK_COUNT; iByte++) {
            txRec[0].data[iByte] = 0xA5;
        }

        // Label = 6, SI = 2
        txRec[1].reserved = 0;
        txRec[1].timeTag = 0;
        txRec[1].control = 0;
        txRec[1].repeatCount = 1;
        txRec[1].data[0] = 6;
        txRec[1].data[1] = 2;
        for (iByte = 2; iByte < BLOCK_COUNT; iByte++) {
            txRec[1].data[iByte] = (uint8)(0x11 * iByte);
        }
        rc = mxfCSDBTxAperiodicWrite(mxfTxBuffer, MXF_TXAPERIODIC_FLAG_DEFAULT, 0, 2, txRec);
    }

    //Wait
    if (!rc) {
        mxfSleep(1000);
    }

    // Read received records
    if (!rc) {
        printf("Receiving ...\n");
        rc = mxfCSDBRxAcqRead(mxfRxBuffer, 2, bufferSize, &rxAcqStatus, &msgCount, &byteCount, rxRec);
        if (!rc) {
            printf("Frame received count = %"PRIu64, msgCount);
            if (msgCount == 0) {
                printf("\n");
            }
        }
    }

    // Display received records
    for (i = 0; i < msgCount && !rc; i++) {
        printf("\n   Record #%"PRIu64, i);
        printf("   Timetag: %012"PRIu64", Size:L %u\n", rxRec[i].timeTag, BLOCK_COUNT);
        printf("   Data:");
        for (iByte = 0; iByte < BLOCK_COUNT; iByte++) {
            printf(" 0x%02X", rxRec[i].data[iByte]);
        }
        printf("\n");
    }


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

    // Display Return Error Codes
    if (rc) {
        char errorString[200];

        if (mxfSystemErrorStringGet(server, rc, sizeof(errorString), errorString)) {
            sprintf(errorString, "ERROR # 0x%X", rc);
        }

        printf("%s\n\r", errorString);
    }

    printf("Terminating ...\n");

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

    // Unload MX Foundation library
    mxfSystemTerminate(server);

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

    printf("\nPress a key to exit\n");
    getchar();

    return 0;
}