ascb_bc.c

/*****************************************************************************
//
##    File:
##       ascb_bc.c
//
//       Copyright (c) MAX Technologies Inc. 1988-2016, All Rights Reserved.
//             CONFIDENTIAL AND PROPRIETARY INFORMATION WHICH IS THE
//                         PROPERTY OF MAX TECHNOLOGIES INC.
//
//      This example demonstrates the basic usage of a ASCB bus controller.
//      It can be run with ascb_user and ascb_bm at the same time.
//
//       Hardware requirements:
//          - MAXT 500 series carrier with IPM-ASCB
//
*****************************************************************************/

#include "example.h"

int main(void)
{
MXF_ASCB_TXPERIODIC_MJRFRAME_MSG minorFrame[16];
MXF_ASCB_DATAREC rec;
HMXF_SERVER server;
HMXF_DEVICE device;
HMXF_MODULE module=0;
HMXF_CHANNEL channel=0;
HMXF_BUFFER bcCtrlBuf=0, bcNoBuf=0;
uint32   rc;
uint32   frameIndex;
uint32   recCount;
uint32   rate;
int doInit=1;

   // Connects to services and initialize environment
   rc = mxfServerConnect("0.0.0.0", "", "", FALSE, &server);
   if (rc != MAXT_SUCCESS)
   {
      printf("Failed to connect; rc=0x%08x", rc);
      getchar();
      return 0;
   }

   // Initializes MX Foundation library
   printf("Starting ...\n");
   if (!rc)
   {
      rc = mxfSystemInit(server);
      if (rc == MAXT_ERROR_ANOTHER_PROCESS_RUNNING)
      {
         // if another MX Foundation application is running, only load MX-Foundation library, otherwise reset cards first
         rc = mxfSystemResourcesInit(server, 0);
         doInit = 0;
      }
   }

   // Get handle of first ASCB BC channel
   if(!rc)
      rc = mxfChannelGet(server, MXF_CLASS_ASCB, MXF_SCLASS_BC_CHANNEL, MXF_MODULE_ALL, 0, &channel);

   if(!rc)
      rc = mxfSystemTimeBaseSet(server, MXF_TIMEBASE_DEVICE_USEC);

   if (!rc)
      rc = mxfChannelInfoGet(channel, &device, &module);

   // setup BC to use version B
   if (!rc && doInit)
      rc = mxfAttributeUint64Set(module, KMXF_ASCB_MODULE_CLOCK_MODE, VMXF_DISABLE);
   if (!rc)
      rc = mxfAttributeUint64Set(channel, KMXF_ASCB_BC_AUTO_MODE, VMXF_DISABLE);
   if (!rc)
      rc = mxfAttributeUint64Set(channel, KMXF_ASCB_BC_SYNC_GEN_ENABLE, VMXF_DISABLE);
   if (!rc)
      rc = mxfAttributeUint64Set(channel, KMXF_ASCB_BC_ID, 1);
   if (!rc)
      rc = mxfAttributeUint64Set(channel, KMXF_ASCB_BC_MSG_PHASE, 0);

   // allocate buffers
   if (!rc)
   {
      rc = mxfTxPeriodicUpdateMsgBufferAlloc(channel, 0x81, 4096, &bcCtrlBuf, NULL);
      if(rc == MAXT_ERROR_BUFFER_ALLOCATED)
         rc = mxfTxPeriodicUpdateMsgBufferGet(channel, 0x81, &bcCtrlBuf);
   }

   if (!rc)
   {
      rc = mxfTxPeriodicUpdateMsgBufferAlloc(channel, 0, 0, &bcNoBuf, NULL);
      if (rc == MAXT_ERROR_BUFFER_ALLOCATED)
         rc = mxfTxPeriodicUpdateMsgBufferGet(channel, 0, &bcNoBuf);
   }

   //Clear the major frame
   if(!rc)
      rc = mxfTxPeriodicMajorFrameClear(channel, 0);

   //--- Set the minor frame #0 with 1 message --//
   if(!rc)
   {
      //Message #0 : Address 0x80 (START)
      minorFrame[0].buffer = bcNoBuf;
      minorFrame[0].address = 0x80;
      minorFrame[0].type = MXF_ASCB_TXPERIODIC_MJRFRAME_MSG_TYPE_FRAME_START;
      minorFrame[0].busSelect = MXF_ASCB_TXPERIODIC_MJRFRAME_MSG_BUS_P1 | MXF_ASCB_TXPERIODIC_MJRFRAME_MSG_BUS_P2;
      minorFrame[0].totalBusTime = 224;

      //Message #1 : Address 0x81 (CONTROL)
      minorFrame[1].buffer = bcCtrlBuf;
      minorFrame[1].address = 0x81;
      minorFrame[1].type = MXF_ASCB_TXPERIODIC_MJRFRAME_MSG_TYPE_FRAME_CTRL;
      minorFrame[1].busSelect = MXF_ASCB_TXPERIODIC_MJRFRAME_MSG_BUS_P1 | MXF_ASCB_TXPERIODIC_MJRFRAME_MSG_BUS_P2;
      minorFrame[1].totalBusTime = 239;

      //Message #2 : Address 0x9B (FTIU)
      minorFrame[2].buffer = bcNoBuf;
      minorFrame[2].address = 0x9B;
      minorFrame[2].type = MXF_ASCB_TXPERIODIC_MJRFRAME_MSG_TYPE_USER_REQ;
      minorFrame[2].busSelect = MXF_ASCB_TXPERIODIC_MJRFRAME_MSG_BUS_P1;
      minorFrame[2].totalBusTime = 970;

      //Message #3 : Address 0xB0 (AFCS,L)
      minorFrame[3].buffer = bcNoBuf;
      minorFrame[3].address = 0xB0;
      minorFrame[3].type = MXF_ASCB_TXPERIODIC_MJRFRAME_MSG_TYPE_USER_REQ;
      minorFrame[3].busSelect = MXF_ASCB_TXPERIODIC_MJRFRAME_MSG_BUS_P1;
      minorFrame[3].totalBusTime = 1662;

      //Message #4 : Address 0x86 (DADC,L)
      minorFrame[4].buffer = bcNoBuf;
      minorFrame[4].address = 0x86;
      minorFrame[4].type = MXF_ASCB_TXPERIODIC_MJRFRAME_MSG_TYPE_USER_REQ;
      minorFrame[4].busSelect = MXF_ASCB_TXPERIODIC_MJRFRAME_MSG_BUS_P1;
      minorFrame[4].totalBusTime = 1230;

      //Message #5 : PAD
      minorFrame[5].buffer = bcNoBuf;
      minorFrame[5].address = 0;
      minorFrame[5].type = MXF_ASCB_TXPERIODIC_MJRFRAME_MSG_TYPE_PAD_FIXED;
      minorFrame[5].busSelect = 0;
      minorFrame[5].totalBusTime = 540;

      //Message #6 : Address 0x82 (SENSOR,L)
      minorFrame[6].buffer = bcNoBuf;
      minorFrame[6].address = 0x82;
      minorFrame[6].type = MXF_ASCB_TXPERIODIC_MJRFRAME_MSG_TYPE_USER_REQ;
      minorFrame[6].busSelect = MXF_ASCB_TXPERIODIC_MJRFRAME_MSG_BUS_P1;
      minorFrame[6].totalBusTime = 1518;

      //Message #7 : Address 0x83 (SENSOR,R)
      minorFrame[7].buffer = bcNoBuf;
      minorFrame[7].address = 0x83;
      minorFrame[7].type = MXF_ASCB_TXPERIODIC_MJRFRAME_MSG_TYPE_USER_REQ;
      minorFrame[7].busSelect = MXF_ASCB_TXPERIODIC_MJRFRAME_MSG_BUS_P2;
      minorFrame[7].totalBusTime = 1518;

      //Message #8 : Address 0xF0 (DAU,1A)
      minorFrame[8].buffer = bcNoBuf;
      minorFrame[8].address = 0xF0;
      minorFrame[8].type = MXF_ASCB_TXPERIODIC_MJRFRAME_MSG_TYPE_USER_REQ;
      minorFrame[8].busSelect = MXF_ASCB_TXPERIODIC_MJRFRAME_MSG_BUS_P1;
      minorFrame[8].totalBusTime = 1546;

      //Message #9 : Address 0xF2 (DAU,2A)
      minorFrame[9].buffer = bcNoBuf;
      minorFrame[9].address = 0xF2;
      minorFrame[9].type = MXF_ASCB_TXPERIODIC_MJRFRAME_MSG_TYPE_USER_REQ;
      minorFrame[9].busSelect = MXF_ASCB_TXPERIODIC_MJRFRAME_MSG_BUS_P1;
      minorFrame[9].totalBusTime = 1546;

      //Message #10 : Address 0xAB (DC,L)
      minorFrame[10].buffer = bcNoBuf;
      minorFrame[10].address = 0xAB;
      minorFrame[10].type = MXF_ASCB_TXPERIODIC_MJRFRAME_MSG_TYPE_USER_REQ;
      minorFrame[10].busSelect = MXF_ASCB_TXPERIODIC_MJRFRAME_MSG_BUS_P1;
      minorFrame[10].totalBusTime = 1287;

      //Message #11 : Address 0xA3 (FWC,L)
      minorFrame[11].buffer = bcNoBuf;
      minorFrame[11].address = 0xA3;
      minorFrame[11].type = MXF_ASCB_TXPERIODIC_MJRFRAME_MSG_TYPE_USER_REQ;
      minorFrame[11].busSelect = MXF_ASCB_TXPERIODIC_MJRFRAME_MSG_BUS_P1;
      minorFrame[11].totalBusTime = 3879;

      //Message #12 : Address 0x92 (FMCS,L)
      minorFrame[12].buffer = bcNoBuf;
      minorFrame[12].address = 0x92;
      minorFrame[12].type = MXF_ASCB_TXPERIODIC_MJRFRAME_MSG_TYPE_USER_REQ;
      minorFrame[12].busSelect = MXF_ASCB_TXPERIODIC_MJRFRAME_MSG_BUS_P1;
      minorFrame[12].totalBusTime = 2698;

      //Message #13 : Address 0x9A (PMC-P,L)
      minorFrame[13].buffer = bcNoBuf;
      minorFrame[13].address = 0x9A;
      minorFrame[13].type = MXF_ASCB_TXPERIODIC_MJRFRAME_MSG_TYPE_USER_REQ;
      minorFrame[13].busSelect = MXF_ASCB_TXPERIODIC_MJRFRAME_MSG_BUS_P1;
      minorFrame[13].totalBusTime = 1892;

      //Message #14 : Address 0xC6 (NAV REM,L)
      minorFrame[14].buffer = bcNoBuf;
      minorFrame[14].address = 0xC6;
      minorFrame[14].type = MXF_ASCB_TXPERIODIC_MJRFRAME_MSG_TYPE_USER_REQ;
      minorFrame[14].busSelect = MXF_ASCB_TXPERIODIC_MJRFRAME_MSG_BUS_P1;
      minorFrame[14].totalBusTime = 1316;

      //Message #15 : Address 0xC7 (NAV REM,R)
      minorFrame[15].buffer = bcNoBuf;
      minorFrame[15].address = 0xC7;
      minorFrame[15].type = MXF_ASCB_TXPERIODIC_MJRFRAME_MSG_TYPE_USER_REQ;
      minorFrame[15].busSelect = MXF_ASCB_TXPERIODIC_MJRFRAME_MSG_BUS_P2;
      minorFrame[15].totalBusTime = 1316;

      frameIndex=0;
      recCount=16;

      rc = mxfASCBTxPeriodicMajorFrameSet(channel, frameIndex, recCount, minorFrame);
   }

   // Setup 7 other minor frames here...

   //--- Set default data on address 0x81 ---//
   if (!rc)
   {
      rec.timeTag = 0;
      rec.msgPhase = 0;
      rec.control = 0;
      rec.repeatCount = 1;
      rec.dataSize = 4;
      rec.data[0] = 0x0081;
      rec.data[1] = 0x0000;

      rc = mxfASCBTxPeriodicUpdateMsgWrite(bcCtrlBuf, 1, &rec);
   }

   // enable Control Frame Number
   if (!rc)
   {
   MXF_ASCB_FC fc;
      fc.position = 0;
      fc.mask = 0x0700;
      fc.enable = TRUE;
      rc = mxfASCBMsgFreshnessCounterSet(channel, 0x81, &fc);
   }

   // disable Control checksum
   if (!rc)
      rc = mxfASCBMsgChecksumEnableSet(channel, 0x81, FALSE);

   // disable Control software CRC
   if (!rc)
      rc = mxfASCBMsgCrcEnableSet(channel, 0x81, FALSE);

   //Start the major frame
   if(!rc)
   {
      rate = 25000; //Frame rate of 25000 micro-seconds
      rc = mxfTxPeriodicMajorFrameStart(channel, 0, rate, 0);
   }

   //Waiting 10 seconds. Allow to major frame to running a little bit.
   if(!rc)
      mxfSleep(10000);

   //Stop the major frame
   if(!rc)
      rc = mxfTxPeriodicMajorFrameStop(channel, 0, 0);

   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");

   if (bcCtrlBuf)
      mxfTxPeriodicUpdateMsgBufferFree(bcCtrlBuf);

   if (bcNoBuf)
      mxfTxPeriodicUpdateMsgBufferFree(bcNoBuf);

   // Unloads MX Foundation library
   rc = mxfSystemTerminate(server);
   if(rc == MAXT_ERROR_ANOTHER_PROCESS_RUNNING)
      mxfSystemResourcesRelease(server, 0);

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

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

return rc;
}