mil1553_ebr.c

/*****************************************************************************
//
##    File:
##       mil1553_ebr.c
//
//       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 configuration of MIL-STD-1553 channel
//      for EBR operation, the usage of NO-OP, command update and repeat
//      count functionality. Acquisition mode is set to linear.
//
//       Hardware requirements:
//          - MAXT Flex1553-PCIe or FlexMulti-1553 (FM1553-4).
//
*****************************************************************************/

#include "example.h"

#define BUF_SA3_RX 0
#define BUF_SA3_TX 1
#define BUF_SA3_MC 2
#define BUF_SA5_RX 3

#define RT_ADRS 0

#define M_ADDRESS      5
#define M_SUBADDR      3
#define LOCAL
//#define LOOPBACK

int main(void)
{
   uint32 rc;
   uint64 deviceCount = 0;
   uint64 moduleCount = 0;
   uint64 channelCount = 0;
   HMXF_SERVER server;
   HMXF_DEVICE device = 0;
   HMXF_MODULE module[2];
   HMXF_CHANNEL bc = 0;
   HMXF_CHANNEL rt = 0;
   HMXF_CHANNEL bm = 0;
   HMXF_BUFFER bcBufferTx[4]={ 0 };
   HMXF_BUFFER bcBufferRx = 0;
   HMXF_BUFFER rtBuffer[4]={ 0 };

   MXF_MSGID_MIL1553 bcMsgID[4] = { {MXF_MIL1553_MSGTYPE_RX,RT_ADRS,3,0},{MXF_MIL1553_MSGTYPE_TX,RT_ADRS,3,0},{MXF_MIL1553_MSGTYPE_MODECODE,RT_ADRS,16,0},{MXF_MIL1553_MSGTYPE_RX,RT_ADRS,5,0} };
   MXF_MSGID_MIL1553 rtMsgID[4] = { {MXF_MIL1553_MSGTYPE_RX,0,3,0},{MXF_MIL1553_MSGTYPE_TX,0,3,0},{MXF_MIL1553_MSGTYPE_MODECODE,0,16,0},{MXF_MIL1553_MSGTYPE_RX,0,5,0} };

   uint32 txBufferSize = 0;
   MXF_MIL1553_DATAREC* txBuffer = NULL;
   MXF_MIL1553_DATAREC* txRec1553;

   uint32 rxBufferSize = 0;
   MXF_MIL1553_DATAREC* rxBuffer = NULL;
   MXF_MIL1553_DATAREC* rxRec1553;

   MXF_MIL1553_TXPERIODIC_MJRFRAME_MSG minorFrame[3];
   MXF_MIL1553_TXPERIODIC_MJRFRAME_MINOR_PROPERTIES mfProp;

   uint64   bus = MXF_MIL1553_BUS_A | MXF_MIL1553_BUS_B;
   uint64   rxAcqStatus = 0;
   uint64   msgCount = 0;
   uint64   byteCount = 0;
   uint64   rxRec;
   uint32   loop = 0;
   uint64   address, subAddress, dir, wordCount, indexBuffer;
   uint32   data;
   uint32   msg;
   MXF_MIL1553_MSGINFO msgInfo;
   MXF_MIL1553_ERROR_INJ err;
   char     errorString[200];

#ifdef LOCAL
   rc = mxfServerConnect("0.0.0.0", "", "", FALSE, &server);
#else
   rc = mxfServerConnect("192.168.0.1", "admin", "admin", FALSE, &server);
#endif

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

   //Get a FM1553-4 or FX1553-4 device handle
   if (!rc)
      rc = mxfSystemDeviceAllGet(server, MXF_DEVICE_FLEXMULTI_1553, 1, &deviceCount, &device);
   if (!rc && !deviceCount)
      rc = mxfSystemDeviceAllGet(server, MXF_DEVICE_FLEX1553_PCIE, 1, &deviceCount, &device);

   // Get a MIL1553 module handle
   if (!rc && deviceCount)
   {
      rc = mxfDeviceModuleAllGet(device, MXF_MODULE_MIL1553MRT_EH, 2, &moduleCount, module);
      //If not a FM1553-4 or FX1553-4 , return an error
      if (moduleCount != 2)
      {
         printf("This example only works for FM1553-4 or FX1553-4\n");
         rc = MAXT_ERROR_MODEL;
      }
   }
   //If no device found, return an error
   else if (!rc && !deviceCount)
      rc = MAXT_ERROR_MODEL;

   if (!rc && moduleCount)
      rc = mxfModuleChannelAllGet(module[0], MXF_CLASS_MIL1553, MXF_SCLASS_BC_CHANNEL, 1, &channelCount, &bc);

   if (!rc && !channelCount)
      rc = MAXT_ERROR_NOT_FOUND;

   // Get handle of first Flex MIL-STD-1553 remote terminal channel
   if (!rc)
      rc = mxfModuleChannelGet(module[0], 2 + RT_ADRS, &rt);

   if (!rc)
      rc = mxfModuleChannelGet(module[0], 0, &bm);

#ifdef LOOPBACK
   if (!rc)
      rc = mxfAttributeUint64Set(bc, KMXF_MIL1553_TX_RX_TEST_LB, VMXF_ENABLE);
#endif

   // Allocate 1KB buffer for tx data
   if (!rc)
   {
      txBufferSize = 1024;

      // Flex allocation
      for (msg = 0; msg < 4 && !rc; msg++)
      {
         rc = mxfTxPeriodicUpdateMsgBufferAlloc(bc, msg, txBufferSize, &bcBufferTx[msg], NULL);
         if (!rc)
            rc = mxfTxPeriodicUpdateMsgBufferAlloc(rt, msg, txBufferSize, &rtBuffer[msg], NULL);
         if (!rc)
            rc = mxfMIL1553RtSubsystemEnableSet(rt, rtMsgID[msg].type, rtMsgID[msg].subAddress, bus, rtBuffer[msg]);
      }

      // Host allocation5
      if (!rc)
      {
         txBuffer = (MXF_MIL1553_DATAREC*)malloc(txBufferSize);
         if (!txBuffer)
            rc = MAXT_ERROR_MEM;
      }
   }

   // Allocate 10KB buffer for rx data
   if (!rc)
   {
      rxBufferSize = 1 * 1024;

      // Flex allocation
      rc = mxfRxAcqBufferAlloc(bc, rxBufferSize, &bcBufferRx, NULL);
      if (!rc)
         rc = mxfRxAcqBufferStatusGet(bcBufferRx, NULL, NULL, NULL, &msgCount);

      // Host allocation
      if (!rc)
      {
         rxBuffer = (MXF_MIL1553_DATAREC*)malloc(rxBufferSize);
         if (!rxBuffer)
            rc = MAXT_ERROR_MEM;
      }
   }

   // Configure to EBR
   if (!rc)
      rc = mxfAttributeUint64Set(bm, KMXF_MIL1553_INTERFACE, VMXF_MIL1553_INTERFACE_RS485);

   // Set Timebase to RTC nsec
   if (!rc)
      rc = mxfSystemTimeBaseSet(server, MXF_TIMEBASE_DEVICE_NSEC);

   // Configure NO-OP error injection
   if (!rc)
   {
      memset(&err, 0, sizeof(err));
      err.errors[0] = MXF_MIL1553_ERRORID_NOOP;
      rc = mxfMIL1553ErrorInjectionSet(bc, 0, &err);
   }

   // Set the minor frame #0 using 3 Commands
   if (!rc)
   {
      memset(minorFrame, 0, sizeof(minorFrame));

      // Command #0 : Address 0, Subaddress 3, RX, 16 words
      rc = mxfMIL1553CommandCompose(bcMsgID[BUF_SA3_RX].address, bcMsgID[BUF_SA3_RX].subAddress, bcMsgID[BUF_SA3_RX].type, 16, &minorFrame[0].command);
      minorFrame[0].modulo = 1;
      minorFrame[0].buffer = bcBufferTx[BUF_SA3_RX];

      // Command #1 : Address 0, Subaddress 3, TX, 16 words
      if (!rc)
      {
         rc = mxfMIL1553CommandCompose(bcMsgID[BUF_SA3_TX].address, bcMsgID[BUF_SA3_TX].subAddress, bcMsgID[BUF_SA3_TX].type, 16, &minorFrame[1].command);
         minorFrame[1].modulo = 1;
         minorFrame[1].buffer = bcBufferTx[BUF_SA3_TX];
      }

      // Command #2 : Address 0, Mode Command 16, TX
      if (!rc)
      {
         rc = mxfMIL1553CommandCompose(bcMsgID[BUF_SA3_MC].address, 0, MXF_MIL1553_MSGTYPE_TX, bcMsgID[BUF_SA3_MC].subAddress, &minorFrame[2].command);
         minorFrame[2].modulo = 1;
         minorFrame[2].buffer = bcBufferTx[BUF_SA3_MC];
      }

      if (!rc)
         rc = mxfMIL1553TxPeriodicMajorFrameSet(bc, 0, 0, 3, minorFrame, NULL);
   }

   // Set the minor frame #1 using 1 Command, Repeat count of 2
   if (!rc)
   {
      memset(minorFrame, 0, sizeof(minorFrame));
      memset(&mfProp, 0, sizeof(mfProp));

      mfProp.modulo = 1;
      mfProp.repeatCount = 2;

      // Command #0 : Address 0, Subaddress 5, RX, 4 words
      rc = mxfMIL1553CommandCompose(bcMsgID[BUF_SA5_RX].address, bcMsgID[BUF_SA5_RX].subAddress, bcMsgID[BUF_SA5_RX].type, 4, &minorFrame[0].command);
      minorFrame[0].modulo = 1;
      minorFrame[0].buffer = bcBufferTx[BUF_SA5_RX];

      if (!rc)
         rc = mxfMIL1553TxPeriodicMajorFrameSet(bc, 0, 1, 1, minorFrame, &mfProp);
   }

   // Set BC data for address 0, subaddress 3, RX
   if (!rc)
   {
      txRec1553 = (MXF_MIL1553_DATAREC*)txBuffer;
      memset(txRec1553, 0, sizeof(MXF_MIL1553_DATAREC));
      txRec1553->repeatCount = 2;   // repeat count of 2
      txRec1553->dataSize = 34;  // 34 bytes (command + 16 words)
      txRec1553->data[0] = 0x0000; // Not used
      txRec1553->data[1] = 0x0000;
      txRec1553->data[2] = 0x1111;
      txRec1553->data[3] = 0x2222;
      txRec1553->data[4] = 0x3333;
      txRec1553->data[5] = 0x4444;
      txRec1553->data[6] = 0x5555;

      txRec1553->data[7] = 0x6666;
      txRec1553->data[8] = 0x7777;
      txRec1553->data[9] = 0x8888;
      txRec1553->data[10] = 0x9999;
      txRec1553->data[11] = 0xAAAA;
      txRec1553->data[12] = 0xBBBB;
      txRec1553->data[13] = 0xCCCC;
      txRec1553->data[14] = 0xDDDD;
      txRec1553->data[15] = 0xEEEE;
      txRec1553->data[16] = 0xFFFF;

      mxfMIL1553NextDataRecordPtrGet(txRec1553, &txRec1553);

      txRec1553->repeatCount = 1;
      txRec1553->dataSize = 34;  // 34 bytes (command + 16 words)
      txRec1553->data[0] = 0x0000; // Not used
      txRec1553->data[1] = 0xFFFF;
      txRec1553->data[2] = 0xEEEE;
      txRec1553->data[3] = 0xDDDD;
      txRec1553->data[4] = 0xCCCC;
      txRec1553->data[5] = 0xBBBB;
      txRec1553->data[6] = 0xAAAA;
      txRec1553->data[7] = 0x9999;
      txRec1553->data[8] = 0x8888;
      txRec1553->data[9] = 0x7777;
      txRec1553->data[10] = 0x6666;
      txRec1553->data[11] = 0x5555;
      txRec1553->data[12] = 0x4444;
      txRec1553->data[13] = 0x3333;
      txRec1553->data[14] = 0x2222;
      txRec1553->data[15] = 0x1111;
      txRec1553->data[16] = 0x0000;

      rc = mxfMIL1553TxPeriodicUpdateMsgWrite(bcBufferTx[BUF_SA3_RX], 2, txBuffer);
   }

   // Set BC data for address 0, subaddress 3, TX
   if (!rc)
   {
      txRec1553 = (MXF_MIL1553_DATAREC*)txBuffer;
      memset(txRec1553, 0, sizeof(MXF_MIL1553_DATAREC));
      txRec1553->repeatCount = 1;

      mxfMIL1553NextDataRecordPtrGet(txRec1553, &txRec1553);

      txRec1553->repeatCount = 1;
      txRec1553->control = MXF_MIL1553_TXPERIODIC_REC_CTRL_ERROR_INJ;
      txRec1553->service.txPeriodicUpdateMsg.errorIndex = 0; // NO-OP

      rc = mxfMIL1553TxPeriodicUpdateMsgWrite(bcBufferTx[BUF_SA3_TX], 2, txBuffer);
   }

   // Set BC data for address 0, MC 16, TX
   if (!rc)
   {
      txRec1553 = (MXF_MIL1553_DATAREC*)txBuffer;
      memset(txRec1553, 0, sizeof(MXF_MIL1553_DATAREC));
      txRec1553->repeatCount = 1;

      // Update command to address 5, MC 18, TX. RT will not respond because this address is not enabled
      mxfMIL1553NextDataRecordPtrGet(txRec1553, &txRec1553);

      txRec1553->repeatCount = 1;
      txRec1553->control = MXF_MIL1553_TXPERIODIC_REC_CTRL_UPDATE_COMMAND;
      mxfMIL1553CommandCompose(5, 0, MXF_MIL1553_MSGTYPE_TX, 18, &txRec1553->data[0]);

      rc = mxfMIL1553TxPeriodicUpdateMsgWrite(bcBufferTx[BUF_SA3_MC], 2, txBuffer);
   }

   // Set BC data for address 0, subaddress 5, RX
   if (!rc)
   {
      txRec1553 = (MXF_MIL1553_DATAREC*)txBuffer;
      memset(txRec1553, 0, sizeof(MXF_MIL1553_DATAREC));
      txRec1553->repeatCount = 2; // repeat count of 2
      txRec1553->dataSize = 34; //10 bytes (command + 4 words)
      txRec1553->data[0] = 0x0000; //Not used
      txRec1553->data[1] = 0x1234;
      txRec1553->data[2] = 0x5678;
      txRec1553->data[3] = 0x9ABC;
      txRec1553->data[4] = 0xDEF0;

      rc = mxfMIL1553TxPeriodicUpdateMsgWrite(bcBufferTx[BUF_SA5_RX], 1, txBuffer);
   }

   // Start messages queues
   if (!rc)
   {
      printf("Starting BC and RT\n\r");
      rc = mxfMIL1553RtEnableSet(rt, TRUE);
   }

   // Start BC acquisition
   if (!rc)
      rc = mxfRxAcqStart(bcBufferRx, MXF_RXACQ_FLAG_DEFAULT, 0, 0);

   // Start the major frame with 250 msec rate
   if (!rc)
      rc = mxfTxPeriodicMajorFrameStart(bc, 0, 250000000, NULL);

   // Read and display received messages
   if (!rc)
   {
      do
      {
         rc = mxfMIL1553RxAcqRead(bcBufferRx, 0, rxBufferSize, &rxAcqStatus, &msgCount, &byteCount, rxBuffer);

         rxRec1553 = (MXF_MIL1553_DATAREC*)rxBuffer;
         for (rxRec = 0; rxRec < msgCount && !rc; rxRec++)
         {
            rc = mxfMIL1553DataRecordDecompose(bc, 1, rxRec1553, &msgInfo);
            if (!rc)
            {
               rc = mxfMIL1553CommandDecompose(rxRec1553->data[0], &address, &subAddress, &dir, &wordCount);
               if (!rc)
               {
                  printf("\n\r%llu:\t", rxRec1553->timeTag);
                  switch (msgInfo.msgType)
                  {
                  case MXF_MIL1553_MSGINFO_TYPE_BCRT:
                     printf("BC to RT%llu SA%llu WC%llu (0x%04x)\n\r", address, subAddress, wordCount, rxRec1553->data[0]);
                     printf("\t\tRT status: 0x%04x\n\r", rxRec1553->data[msgInfo.statusIndex[0]]);
                     break;

                  case MXF_MIL1553_MSGINFO_TYPE_RTBC:
                     printf("RT%llu SA%llu WC%llu to BC (0x%04x)\n\r", address, subAddress, wordCount, rxRec1553->data[0]);
                     printf("\t\tRT status: 0x%04x\n\r", rxRec1553->data[msgInfo.statusIndex[0]]);
                     printf("\t\tRT data:");
                     for (data = 0; data < msgInfo.dataWordCount; data++)
                     {
                        if (data && !(data % 4))
                           printf("\n\r\t\t\t");

                        printf(" 0x%04x", rxRec1553->data[msgInfo.dataIndex + data]);
                     }
                     printf("\n\r");
                     break;

                  case MXF_MIL1553_MSGINFO_TYPE_MODECODE_TXDATA:
                     printf("BC Mode Command %llu to RT%llu SA%llu (0x%04x)\n\r", wordCount, address, subAddress, rxRec1553->data[0]);
                     if (msgInfo.statusIndex[0] != 0xffff)
                     {
                        printf("\t\tRT status: 0x%04x\n\r", rxRec1553->data[msgInfo.statusIndex[0]]);
                        printf("\t\tRT data: 0x%04x\n\r", rxRec1553->data[msgInfo.dataIndex]);
                     }
                     break;
                  }
               }
            }
            // Get next msg
            rc = mxfMIL1553NextDataRecordPtrGet(rxRec1553, &rxRec1553);
         }
         mxfSleep(500);
         loop++;
      } while (loop < 5);
   }

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

   // Stop the major frame
   if (!rc)
   {
      printf("Stopping BC and RT\n\r");
      rc = mxfTxPeriodicMajorFrameStop(bc, 0, 0);
   }
   if (!rc)
      rc = mxfMIL1553RtEnableSet(rt, FALSE);

   printf("Terminating\n\r");

   // free buffers
   if (txBuffer)
      free(txBuffer);

   if (rxBuffer)
      free(rxBuffer);

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

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

   // Free all buffers and terminate 
   for (indexBuffer = 0; indexBuffer < 4; indexBuffer++)
   {
      if (bcBufferTx[indexBuffer])
      {
         rc = mxfTxPeriodicUpdateMsgBufferFree(bcBufferTx[indexBuffer]);
         if (rc)
            printf("Free buffer failed !\n\r");
      }
   }
   for (indexBuffer = 0; indexBuffer < 4; indexBuffer++)
   {
      if (rtBuffer[indexBuffer])
      {
         rc = mxfTxPeriodicUpdateMsgBufferFree(rtBuffer[indexBuffer]);
         if (rc)
            printf("Free buffer failed !\n\r");
      }
   }
   if (bcBufferRx)
   {
      rc = mxfRxAcqBufferFree(bcBufferRx);
      if (rc)
         printf("Free buffer failed !\n\r");
   }

   // Unload MX Foundation library
   mxfSystemTerminate(server);
   mxfServerDisconnect(server);

   printf("\n\rPress enter to terminate\n\r");
   getchar();

   return 0;
}