Sync BasicOps
Edit this on GitLab
Sync BasicOps Sample Application (SSK 2.x)
Overview
The Sync BasicOps sample application demonstrates how to synchronize AD and DA module operations using the NAI Software Support Kit (SSK 2.x). It configures clock synchronization and FIFO trigger synchronization across multiple modules on the same board, enabling simultaneous sampling and output.
The sync framework provides two levels of coordination:
-
Clock synchronization — one module (the master) supplies its clock to other modules (slaves).
-
Trigger synchronization — one module’s FIFO trigger signal is routed to other modules.
Supported modules: AD1-AD6, ADE, ADF, ADG, DA1-DA5, and combination modules CME, CMF, CMG.
For the SSK 1.x version, see Sync BasicOps (SSK 1.x). For detailed register-level information, consult the CME-CMF Manual.
Prerequisites
-
An NAI board with at least two supported AD and/or DA modules.
-
SSK 2.x installed and sample applications built. Refer to the SSK 2.x Software Development Guide.
-
Appropriate analog signal sources and/or loads.
Board Connection and Module Selection
|
Note
|
For details on board connection configuration, see the SSK 2.x Software Development Guide. |
On VxWorks, the entry point is Sync_BasicOps(). Unlike other samples, this application works with all modules on the board simultaneously.
Program Structure
Clock Synchronization
| Mode | Description |
|---|---|
|
Independent internal clock |
|
Supplies clock to slaves |
|
Syncs to user external clock |
|
Receives clock from master |
|
Receives off-board clock |
naibrd_AD_SetModuleSyncMode(cardIndex, modNum, NAIBRD_SYNC_CONFIG_CLOCK,
mode, masterModNum);
naibrd_DA_SetModuleSyncMode(cardIndex, modNum, NAIBRD_SYNC_CONFIG_CLOCK,
mode, masterModNum);FIFO Trigger Synchronization
naibrd_AD_SetModuleSyncMode(cardIndex, modNum, NAIBRD_SYNC_CONFIG_TRIGGER,
mode, masterModNum);
naibrd_AD_SetFIFOTrigCtrl(cardIndex, modNum, channel, trigCtrl);Triggering and Data Collection
/* Software trigger */
naibrd_AD_SoftwareTrigger(cardIndex, masterModNum);
/* Read AD FIFO */
naibrd_AD_ReadFIFO(cardIndex, modNum, channel, numSamples, fifoData, &read);
/* Write DA FIFO */
naibrd_DA_SetFIFO32(cardIndex, modNum, channel, 1, &data, &written);Data is saved to sync_data.txt.
Troubleshooting Reference
| Symptom | Possible Cause and Resolution |
|---|---|
Module does not support sync |
Only specific AD, DA, and CM modules. |
No data collected |
Ensure FIFO trigger enable bit is set. |
Slave not syncing |
Verify master module number. |
Data file not created |
Check write permissions. |
FIFO overflow |
Default size is 100 samples. |
Full Source
Full Source — sync_basic_ops.c (SSK 2.x)
/* nailib include files */
#include "nai_libs/nailib/include/naitypes.h"
#include "nai_libs/nailib/include/nailib.h"
#include "nai_libs/nailib/include/nailib_utils.h"
/* naibrd include files */
#include "nai_libs/naibrd/include/naibrd.h"
#include "nai_libs/naibrd/include/functions/naibrd_ad.h"
#include "nai_libs/naibrd/include/functions/naibrd_da.h"
/* naiif include files */
#include "nai_libs/naiif/include/naiif_stdio.h"
/* Common Sample Program include files */
#include "nai_sample_apps/naiapp_common/include/naiapp_boardaccess_menu.h"
#include "nai_sample_apps/naiapp_common/include/naiapp_boardaccess_query.h"
#include "nai_sample_apps/naiapp_common/include/naiapp_boardaccess_access.h"
#include "nai_sample_apps/naiapp_common/include/naiapp_boardaccess_display.h"
#include "nai_sample_apps/naiapp_common/include/naiapp_boardaccess_utils.h"
/* AD Sample App include files */
#include "nai_sample_apps/naiapp_src/board_modules/ad/ad_common_utils/ad_common_utils.h"
static const int8_t *SAMPLE_PGM_NAME = (const int8_t *)"AD Module Basic Operation Program";
static const int8_t *CONFIG_FILE = (const int8_t *)"default_sync_basic_ops.txt";
static const char *DATA_FILE = (const char*)"sync_data.txt";
/* Module Type definitions. The Module type is the 16 msb of the module ID. So module ID's like AD1, AD2, AD3, etc are
all AD module types. The module ID of ANY AD module can give us the module type by masking out the
lower 16 bits and retaining the upper 16 bits. This is true for all NAI modules (AD, DA, CM, etc).
*/
#define SYNCOPS_MOD_TYPE_MASK 0xFFFF0000u
typedef uint32_t syncops_module_type_t;
#define SYNCOPS_MOD_TYPE_UNKNOWN (syncops_module_type_t)0u;
#define SYNCOPS_MOD_TYPE_AD (syncops_module_type_t)(NAIBRD_MODULE_ID_AD1 & SYNCOPS_MOD_TYPE_MASK)
#define SYNCOPS_MOD_TYPE_DA (syncops_module_type_t)(NAIBRD_MODULE_ID_DA1 & SYNCOPS_MOD_TYPE_MASK)
#define SYNCOPS_FIFO_TRIG_SOFT(t) ((uint32_t)(t == SYNCOPS_MOD_TYPE_AD ? NAIBRD_AD_FIFO_TRIG_SOFT : NAIBRD_DA_GEN5_FIFO_TRIG_SOFT))
#define SYNCOPS_FIFO_TRIG_POS_EDGE(t) ((uint32_t)(t == SYNCOPS_MOD_TYPE_AD ? NAIBRD_AD_FIFO_TRIG_POS_EDGE : NAIBRD_DA_GEN5_FIFO_TRIG_PSLOPE))
#define SYNCOPS_FIFO_TRIG_NEG_EDGE(t) ((uint32_t)(t == SYNCOPS_MOD_TYPE_AD ? NAIBRD_AD_FIFO_TRIG_NEG_EDGE : NAIBRD_DA_GEN5_FIFO_TRIG_NSLOPE))
#define SYNCOPS_FIFO_TRIG_EITHER_EDGE(t) ((uint32_t)(t == SYNCOPS_MOD_TYPE_AD ? NAIBRD_AD_FIFO_TRIG_EITHER_EDGE : NAIBRD_DA_GEN5_FIFO_TRIG_EITHER_SLOPE))
#define SYNCOPS_FIFO_TRIG_STOP(t) ((uint32_t)(t == SYNCOPS_MOD_TYPE_AD ? NAIBRD_AD_FIFO_TRIG_STOP : NAIBRD_DA_GEN5_FIFO_TRIG_STOP))
#define SYNCOPS_FIFO_TRIG_ENABLE(t) ((uint32_t)(t == SYNCOPS_MOD_TYPE_AD ? NAIBRD_AD_FIFO_TRIG_ENABLE : NAIBRD_DA_GEN5_FIFO_TRIG_ENABLE))
#define SYNCOPS_FIFO_TRIG_CONTINUOUS(t) ((uint32_t)(t == SYNCOPS_MOD_TYPE_AD ? NAIBRD_AD_FIFO_TRIG_CONTINUOUS : NAIBRD_DA_GEN5_FIFO_TRIG_CONTINUOUS))
/* Structure to hold sync info. */
typedef struct naiapp_syncInfo
{
int32_t cardIndex;
int32_t moduleCount;
uint32_t modId[NAI_MAX_MODULES];
syncops_module_type_t moduleType[NAI_MAX_MODULES];
int32_t triggerMasterModNum;
int32_t channel[NAI_MAX_MODULES]; /*1 channel per module. */
} naiapp_syncInfo_t;
#define SYNC_PARAM_COUNT 6
/* Function prototypes */
static bool_t SyncBasicOps_run(int32_t cardIndex, int32_t moduleCount);
static void SyncBasicOps_displayConfigurations(int32_t paramCount, naiapp_syncInfo_t *p_syncInfo);
/* AD Basic Ops Command Functions */
static nai_status_t SyncBasicOps_configClockSync(int32_t paramCount, int32_t* p_params);
static nai_status_t SyncBasicOps_configFifo(int32_t paramCount, int32_t* p_params);
static nai_status_t SyncBasicOps_clearFifo(int32_t paramCount, int32_t* p_params);
static nai_status_t SyncBasicOps_triggerMaster(int32_t paramCount, int32_t* p_params);
static nai_status_t SyncBasicOps_stopFifo(int32_t paramCount, int32_t* p_params);
static nai_status_t SyncBasicOps_collectData(int32_t paramCount, int32_t* p_params);
static nai_status_t SyncBasicOps_loadData(int32_t paramCount, int32_t* p_params);
/* Application Functions */
static bool_t SyncSupported(uint32_t modID);
static const char* SyncModeString(naibrd_module_sync_mode_type_t mode);
static bool_t GetMasterModule(naiapp_syncInfo_t *p_syncInfo, int32_t *p_masterModNum);
static syncops_module_type_t GetModuleType(uint32_t modID);
static nai_status_t ConfigFifoSync(naiapp_syncInfo_t *p_syncInfo, int32_t modNum, naibrd_module_sync_mode_type_t mode, uint32_t trigCtrl);
static nai_status_t SetFifoTriggers(naiapp_syncInfo_t *p_syncInfo, bool_t trigEnable);
static nai_status_t GetModuleSyncMode(naiapp_syncInfo_t syncInfo, int32_t modNum, naibrd_module_sync_config_type_t config,
naibrd_module_sync_mode_type_t *p_mode, int32_t *p_masterModNum);
static nai_status_t SetModuleSyncMode(naiapp_syncInfo_t syncInfo, int32_t modNum, naibrd_module_sync_config_type_t config,
naibrd_module_sync_mode_type_t mode, int32_t masterModNum);
static nai_status_t ReadFIFO32(naiapp_syncInfo_t syncInfo, int32_t modNum, uint32_t *p_outRead);
static nai_status_t SoftwareTrigger(naiapp_syncInfo_t syncInfo, int32_t modNum);
static nai_status_t GetFIFOSize(naiapp_syncInfo_t syncInfo, int32_t modNum, int32_t channel, uint32_t *p_fifoSize);
static nai_status_t GetFIFOCount(naiapp_syncInfo_t syncInfo, int32_t modNum, int32_t channel, uint32_t *p_fifoCount);
static nai_status_t GetModuleRate(naiapp_syncInfo_t syncInfo, int32_t modNum, uint32_t *p_rate);
#define DEFAULT_CHANNEL 1
#define SYNCOPS_NUM_FIFO_SAMPLES 100u
static float64_t fifoData[NAI_MAX_MODULES][SYNCOPS_NUM_FIFO_SAMPLES];
/****** Command Table *******/
/* Invariant: enumeration of cmd table starts from 0 and increments by 1 */
enum sync_basicOps_commands
{
SYNC_BASICOPS_CMD_CONFIG_CLOCK_SYNC, /* Configure Clock Sync */
SYNC_BASICOPS_CMD_CONFIG_FIFO, /* Configure FIFO */
SYNC_BASICOPS_CMD_CLEAR_FIFO, /* Clear FIFO */
SYNC_BASICOPS_CMD_LOAD_FIFO_DATA, /* Load the DA FIFO's with data. */
SYNC_BASICOPS_CMD_SEND_FIFO_TRIGGER, /* Trigger to start fifo i/o. */
SYNC_BASICOPS_CMD_STOP_FIFO, /* Stop fifo i/o. */
SYNC_BASICOPS_CMD_COLLECT_FIFO_DATA, /* Read the AD FIFO's and store the data to a file. */
SYNC_BASICOPS_CMD_COUNT
};
naiapp_cmdtbl_params_t Sync_BasicOpsCmds[] =
{
{"CS", "Configure Clock Sync", SYNC_BASICOPS_CMD_CONFIG_CLOCK_SYNC, SyncBasicOps_configClockSync },
{"CF", "Configure FIFO", SYNC_BASICOPS_CMD_CONFIG_FIFO, SyncBasicOps_configFifo },
{"CLF", "Clear FIFO contents", SYNC_BASICOPS_CMD_CLEAR_FIFO, SyncBasicOps_clearFifo },
{"LOAD", "Load the DA FIFO's with data.", SYNC_BASICOPS_CMD_LOAD_FIFO_DATA, SyncBasicOps_loadData },
{"TRIG", "Trigger Master to start FIFOs on the Master and Slave.", SYNC_BASICOPS_CMD_SEND_FIFO_TRIGGER, SyncBasicOps_triggerMaster },
{"STOP", "Stop fifo i/o", SYNC_BASICOPS_CMD_STOP_FIFO, SyncBasicOps_stopFifo },
{"COLLECT", "Read the AD FIFO's and store the data to a file. ", SYNC_BASICOPS_CMD_COLLECT_FIFO_DATA, SyncBasicOps_collectData }
};
/*****************************************************************************/
/**
* <summary>
* The purpose of the AD_BasicOps is to illustrate the methods to call in the
* naibrd library to perform basic operations with the AD modules for
* configuration setup and reading the channels.
*
* The following system configuration routines from the nai_sys_cfg.c file are
* called to assist with the configuration setup for this program prior to
* calling the naibrd AD routines.
* - ConfigDevice
* - DisplayDeviceCfg
* - GetBoardSNModCfg
* - CheckModule
* </summary>
*/
/*****************************************************************************/
#if defined (__VXWORKS__)
int32_t Sync_BasicOps(void)
#else
int32_t main(void)
#endif
{
bool_t bQuit = NAI_FALSE;
int32_t cardIndex = -1;
int32_t moduleCount;
int8_t inputBuffer[80];
int32_t inputResponseCnt;
if (naiapp_RunBoardMenu(CONFIG_FILE) == NAI_TRUE)
{
while (!bQuit)
{
naiapp_query_CardIndex(naiapp_GetBoardCnt(), 0, &cardIndex);
naibrd_GetModuleCount(cardIndex, &moduleCount);
bQuit = SyncBasicOps_run(cardIndex, moduleCount);
}
naiif_printf("Type the Enter key to exit the program: ");
bQuit = naiapp_query_ForQuitResponse(sizeof(inputBuffer), NAI_QUIT_CHAR, inputBuffer, &inputResponseCnt);
}
naiapp_access_CloseAllOpenCards();
return 0;
}
/*****************************************************************************/
/**
* <summary>
* SyncBasicOps_run illustrates the channel configuration and prepares the menu
* which will handle user command requests. Returns NAI_TRUE if the user enters
* the Quit Command at any point within its scope.
* </summary>
*/
/*****************************************************************************/
static bool_t SyncBasicOps_run(int32_t cardIndex, int32_t moduleCount)
{
bool_t bQuit = NAI_FALSE;
bool_t bCmdFound = NAI_FALSE;
int32_t cmd;
naiapp_syncInfo_t syncInfo;
int32_t moduleIndex = 0;
naibrd_module_sync_mode_type_t syncMode;
int32_t triggerMasterModNum = 0;
int8_t inputBuffer[80];
int32_t inputResponseCnt;
int32_t channel = 0;
syncInfo.cardIndex = cardIndex;
syncInfo.moduleCount = moduleCount;
syncInfo.triggerMasterModNum = 0;
for(moduleIndex = 0; moduleIndex < moduleCount; moduleIndex++)
{
syncInfo.channel[moduleIndex] = DEFAULT_CHANNEL;
naibrd_GetModuleName(cardIndex, moduleIndex + 1, &(syncInfo.modId[moduleIndex]));
syncInfo.moduleType[moduleIndex] = GetModuleType(syncInfo.modId[moduleIndex]);
if (NAI_FALSE != SyncSupported(syncInfo.modId[moduleIndex]))
{
GetModuleSyncMode(syncInfo, moduleIndex + 1, NAIBRD_SYNC_CONFIG_TRIGGER, &syncMode, &triggerMasterModNum);
if (NAI_GEN5_MODULE_SYNC_MODE_MASTER == syncMode)
{
syncInfo.triggerMasterModNum = triggerMasterModNum;
}
/* Configure the AD and DA. */
switch(syncInfo.moduleType[moduleIndex])
{
case SYNCOPS_MOD_TYPE_AD:
for (channel = 1; channel <= naibrd_AD_GetChannelCount(syncInfo.modId[moduleIndex]); channel++)
{
check_status(naibrd_AD_SetFIFOSize(syncInfo.cardIndex, moduleIndex + 1, channel, SYNCOPS_NUM_FIFO_SAMPLES));
}
break;
case SYNCOPS_MOD_TYPE_DA:
for (channel = 1; channel <= naibrd_DA_GetChannelCount(syncInfo.modId[moduleIndex]); channel++)
{
check_status(naibrd_DA_SetFIFOSize(syncInfo.cardIndex, moduleIndex + 1, channel, SYNCOPS_NUM_FIFO_SAMPLES));
}
break;
default:
naiif_printf("SyncBasicOps_run-> ERROR! Unsupported Module Type %u\r\n", syncInfo.moduleType[moduleIndex]);
break;
}
}
}
do
{
naiapp_utils_LoadParamMenuCommands(SYNC_BASICOPS_CMD_COUNT, Sync_BasicOpsCmds);
SyncBasicOps_displayConfigurations(SYNC_PARAM_COUNT, &syncInfo);
naiapp_display_ParamMenuCommands((int8_t*)SAMPLE_PGM_NAME);
naiif_printf("\r\n\r\nPlease enter a command or 'q' to quit:");
bQuit = naiapp_query_ForQuitResponse(sizeof(inputBuffer), NAI_QUIT_CHAR, inputBuffer, &inputResponseCnt);
if (!bQuit)
{
if (inputResponseCnt > 0)
{
bCmdFound = naiapp_utils_GetParamMenuCmdNum(inputResponseCnt, inputBuffer, &cmd);
if (bCmdFound)
{
Sync_BasicOpsCmds[cmd].func(SYNC_PARAM_COUNT, (int32_t*)&syncInfo);
}
else
{
naiif_printf("Invalid command entered\r\n");
}
}
}
} while (!bQuit);
return bQuit;
}
/*****************************************************************************/
/**
* <summary>
* ADBasicOps_displayConfigurations illustrates the methods to call in the naibrd library
* to retrieve the basic operation configuration states and status states
* as well as the current voltage reading for all channels.
* </summary>
*/
/*****************************************************************************/
static void SyncBasicOps_displayConfigurations(int32_t paramCount, naiapp_syncInfo_t* p_syncInfo)
{
int32_t modNum = 0;
naibrd_module_sync_mode_type_t clockMode = NAI_GEN5_MODULE_SYNC_MODE_DISABLED;
int32_t clockMasterModNum = 0;
naibrd_module_sync_mode_type_t triggerMode = NAI_GEN5_MODULE_SYNC_MODE_DISABLED;
int32_t triggerMasterModNum = 0;
uint32_t numSamplesPerTrigger = 0u;
uint32_t fifoCount = 0;
uint32_t rate = 0;
char szModID[] = "/0/0/0/0";
if (SYNC_PARAM_COUNT == paramCount)
{
naiif_printf("\r\n\r\n\r\n");
naiif_printf("------Module Info------ --------SyncClockConfig--------- --------SyncTriggerConfig------- --------------FIFO Setup--------------\r\n");
naiif_printf(" ModNum ID SyncSupport Mode MasterModNum Mode MasterModNum Rate Channel NumSamples FifoCount\r\n");
naiif_printf("-----------------------------------------------------------------------------------------------------------------------------------------\r\n");
for (modNum = 1; modNum <= p_syncInfo->moduleCount; modNum++)
{
naiapp_utils_ConvertModIdToAscii(p_syncInfo->modId[modNum-1], szModID);
if (NAI_FALSE != SyncSupported(p_syncInfo->modId[modNum-1]))
{
GetModuleRate(*p_syncInfo, modNum, &rate);
GetModuleSyncMode(*p_syncInfo, modNum, NAIBRD_SYNC_CONFIG_CLOCK, &clockMode, &clockMasterModNum);
GetModuleSyncMode(*p_syncInfo, modNum, NAIBRD_SYNC_CONFIG_TRIGGER, &triggerMode, &triggerMasterModNum);
GetFIFOSize(*p_syncInfo, modNum, p_syncInfo->channel[modNum-1], &numSamplesPerTrigger);
GetFIFOCount(*p_syncInfo, modNum, p_syncInfo->channel[modNum-1], &fifoCount);
naiif_printf(" %d %s YES %-25s %d %-25s %d %-9d %-2d %3u %u\r\n", modNum, szModID,
SyncModeString(clockMode), clockMasterModNum, SyncModeString(triggerMode), triggerMasterModNum, rate, p_syncInfo->channel[modNum-1],
numSamplesPerTrigger, fifoCount);
}
else
{
naiif_printf(" %d %s NO --- --- --- --- --- --- --- ---\r\n",
modNum, szModID);
}
}
}
}
/*****************************************************************************/
/**
* <summary>
* ADBasicOps_setRangePolarity handles the user request to set the configuration states
* of Range and Polarity for the selected channel.
* </summary>
*/
/*****************************************************************************/
nai_status_t SyncBasicOps_configClockSync(int32_t paramCount, int32_t* p_params)
{
nai_status_t status = NAI_ERROR_UNKNOWN;
naiapp_syncInfo_t* p_syncInfo = (naiapp_syncInfo_t*)p_params;
int32_t modNum = 0;
int32_t masterModNum = 0;
bool_t bContinue = NAI_TRUE;
bool_t bQuit = NAI_FALSE;
int32_t modeSelect = 0;
int8_t inputBuffer[80];
int32_t inputResponseCnt;
if (SYNC_PARAM_COUNT == paramCount)
{
while (bContinue)
{
naiif_printf("Select module to configure (1-%d): ", p_syncInfo->moduleCount);
bQuit = naiapp_query_ForQuitResponse(sizeof(inputBuffer), NAI_QUIT_CHAR, inputBuffer, &inputResponseCnt);
if (!bQuit)
{
if (inputResponseCnt >= 0)
{
modNum = (int32_t)atol((const char*)inputBuffer);
}
if ((modNum <= 0) || (modNum > p_syncInfo->moduleCount))
{
naiif_printf("ERROR: Invalid module value.\r\n\r\n");
}
else
{
bContinue = NAI_FALSE;
}
}
else
{
bContinue = NAI_FALSE;
}
}
if (!bQuit)
{
bContinue = NAI_TRUE;
while(bContinue)
{
naiif_printf("\r\n\r\nPlease select Clock Sync Mode for this module:\r\n");
naiif_printf(" 0) DISABLED: This module uses its internal clock and does not sync with other modules.\r\n");
naiif_printf(" 1) MASTER: This module supplies the clock to other slave modules.\r\n");
naiif_printf(" 2) SLAVE- USER CLOCK: This module syncs with a user supplied clock and supplies it to other slave modules.\r\n");
naiif_printf(" 3) SLAVE- INTERNAL CLOCK: This module receives the clock from a MASTER/USER CLOCK module.\r\n");
naiif_printf(" 4) SLAVE- EXTERNAL BOARD CLOCK: This module receives the clock that is supplied by an off-board master.\r\n");
naiif_printf("\r\n\r\nPlease enter your selection: ");
bQuit = naiapp_query_ForQuitResponse(sizeof(inputBuffer), NAI_QUIT_CHAR, inputBuffer, &inputResponseCnt);
if (!bQuit)
{
if (inputResponseCnt > 0)
{
modeSelect = (int32_t)atol((const char*)inputBuffer);
bContinue = NAI_FALSE;
switch (modeSelect)
{
case 0:
masterModNum = 0; /* 0 disables. */
status = SetModuleSyncMode(*p_syncInfo, modNum, NAIBRD_SYNC_CONFIG_CLOCK, NAI_GEN5_MODULE_SYNC_MODE_DISABLED, masterModNum);
break;
case 1:
masterModNum = modNum; /* Master gets the clock from itself. */
status = SetModuleSyncMode(*p_syncInfo, modNum, NAIBRD_SYNC_CONFIG_CLOCK, NAI_GEN5_MODULE_SYNC_MODE_MASTER, masterModNum);
break;
case 2:
masterModNum = 0; /* 0 disables. */
status = SetModuleSyncMode(*p_syncInfo, modNum, NAIBRD_SYNC_CONFIG_CLOCK, NAI_GEN5_MODULE_SYNC_MODE_SLAVE_USER_CLOCK, masterModNum);
break;
case 3:
bQuit = GetMasterModule(p_syncInfo, &masterModNum);
status = SetModuleSyncMode(*p_syncInfo, modNum, NAIBRD_SYNC_CONFIG_CLOCK, NAI_GEN5_MODULE_SYNC_MODE_SLAVE_INTERNAL, masterModNum);
break;
case 4:
bQuit = GetMasterModule(p_syncInfo, &masterModNum);
status = SetModuleSyncMode(*p_syncInfo, modNum, NAIBRD_SYNC_CONFIG_CLOCK, NAI_GEN5_MODULE_SYNC_MODE_SLAVE_BOARD_CLOCK, masterModNum);
break;
default:
naiif_printf("ERROR: Invalid module value.\r\n\r\n");
bContinue = NAI_TRUE;
break;
}
}
else
{
naiif_printf("ERROR: Invalid module value.\r\n\r\n");
bContinue = NAI_TRUE;
}
}
else
{
bContinue = NAI_FALSE;
}
}
}
}
return status;
}
nai_status_t SyncBasicOps_configFifo(int32_t paramCount, int32_t* p_params)
{
nai_status_t status = NAI_ERROR_UNKNOWN;
naiapp_syncInfo_t* p_syncInfo = (naiapp_syncInfo_t*)p_params;
int32_t modNum = 0;
bool_t bContinue = NAI_TRUE;
bool_t bQuit = NAI_FALSE;
int32_t modeSelect = 0;
int8_t inputBuffer[80];
int32_t inputResponseCnt;
if (SYNC_PARAM_COUNT == paramCount)
{
while (bContinue)
{
naiif_printf("Select module to configure (1-%d): ", p_syncInfo->moduleCount);
bQuit = naiapp_query_ForQuitResponse(sizeof(inputBuffer), NAI_QUIT_CHAR, inputBuffer, &inputResponseCnt);
if (!bQuit)
{
if (inputResponseCnt >= 0)
{
modNum = (int32_t)atol((const char*)inputBuffer);
}
if ((modNum <= 0) || (modNum > p_syncInfo->moduleCount))
{
naiif_printf("ERROR: Invalid module value.\r\n\r\n");
}
else
{
bContinue = NAI_FALSE;
}
}
else
{
bContinue = NAI_FALSE;
}
}
if (!bQuit)
{
bContinue = NAI_TRUE;
while(bContinue)
{
naiif_printf("\r\n\r\nPlease select FIFO Trigger Sync Mode for this module:\r\n");
naiif_printf(" 0) DISABLED: This module uses its internal FIFO Trigger and does not sync with other modules.\r\n");
naiif_printf(" 1) MASTER: This module supplies the FIFO Trigger to other slave modules.\r\n");
naiif_printf(" 2) SLAVE- USER TRIGGER: This module's FIFO is triggered externally and triggers the FIFOs on slave modules.\r\n");
naiif_printf(" 3) SLAVE- INTERNAL TRIGGER: This module's FIFO is triggered from a MASTER/USER TRIGGER module.\r\n");
/*naiif_printf(" 4) SLAVE- EXTERNAL BOARD TRIGGER: This module's FIFO is triggered by an off-board master.\r\n");*/
naiif_printf("\r\n\r\nPlease enter your selection: ");
bQuit = naiapp_query_ForQuitResponse(sizeof(inputBuffer), NAI_QUIT_CHAR, inputBuffer, &inputResponseCnt);
if (!bQuit)
{
if (inputResponseCnt > 0)
{
modeSelect = (int32_t)atol((const char*)inputBuffer);
bContinue = NAI_FALSE;
switch (modeSelect)
{
case 0:
p_syncInfo->triggerMasterModNum = 0; /* 0 disables. */
status = ConfigFifoSync(p_syncInfo, modNum, NAI_GEN5_MODULE_SYNC_MODE_DISABLED, SYNCOPS_FIFO_TRIG_STOP(p_syncInfo->moduleType[modNum]));
break;
case 1:
p_syncInfo->triggerMasterModNum = modNum; /* Master gets the clock from itself. */
status = ConfigFifoSync(p_syncInfo, modNum, NAI_GEN5_MODULE_SYNC_MODE_MASTER,
SYNCOPS_FIFO_TRIG_SOFT(p_syncInfo->moduleType[modNum]) | SYNCOPS_FIFO_TRIG_CONTINUOUS(p_syncInfo->moduleType[modNum]));
break;
case 2:
p_syncInfo->triggerMasterModNum = 0; /* 0 disables. */
status = ConfigFifoSync(p_syncInfo, modNum, NAI_GEN5_MODULE_SYNC_MODE_SLAVE_USER_TRIG,
SYNCOPS_FIFO_TRIG_POS_EDGE(p_syncInfo->moduleType[modNum]) | SYNCOPS_FIFO_TRIG_CONTINUOUS(p_syncInfo->moduleType[modNum]));
break;
case 3:
bQuit = GetMasterModule(p_syncInfo, &(p_syncInfo->triggerMasterModNum));
status = ConfigFifoSync(p_syncInfo, modNum, NAI_GEN5_MODULE_SYNC_MODE_SLAVE_INTERNAL,
SYNCOPS_FIFO_TRIG_POS_EDGE(p_syncInfo->moduleType[modNum]) | SYNCOPS_FIFO_TRIG_CONTINUOUS(p_syncInfo->moduleType[modNum]));
break;
/*
case 4:
bQuit = GetMasterModule(p_syncInfo, &(p_syncInfo->triggerMasterModNum));
status = ConfigFifoSync(p_syncInfo, modNum, NAI_GEN5_MODULE_SYNC_MODE_SLAVE_BOARD_CLOCK,
(uint32_t)(NAIBRD_AD_FIFO_TRIG_POS_EDGE | NAIBRD_AD_FIFO_TRIG_CONTINUOUS));
break;
*/
default:
naiif_printf("ERROR: Invalid module value.\r\n\r\n");
bContinue = NAI_TRUE;
break;
}
naiapp_query_ChannelNumber(p_syncInfo->moduleCount, DEFAULT_CHANNEL, &(p_syncInfo->channel[modNum-1]));
}
else
{
naiif_printf("ERROR: Invalid module value.\r\n\r\n");
bContinue = NAI_TRUE;
}
}
else
{
bContinue = NAI_FALSE;
}
}
}
}
return status;
}
static nai_status_t SyncBasicOps_clearFifo(int32_t paramCount, int32_t* p_params)
{
naiapp_syncInfo_t *p_syncInfo = (naiapp_syncInfo_t*)p_params;
nai_status_t status = NAI_ERROR_UNKNOWN;
bool_t bQuit = NAI_FALSE;
int32_t startMod = 0;
int32_t endMod = 0;
int32_t modNum = 0;
bool_t bContinue = NAI_TRUE;
int8_t inputBuffer[80];
int32_t inputResponseCnt;
uint32_t modId = 0;
if (SYNC_PARAM_COUNT == paramCount)
{
while(bContinue)
{
naiif_printf("Please enter the module number of the FIFO to clear, or 'A' to clear all FIFOs [1-%d,A]:", p_syncInfo->moduleCount);
bQuit = naiapp_query_ForQuitResponse(sizeof(inputBuffer), NAI_QUIT_CHAR, inputBuffer, &inputResponseCnt);
if (!bQuit)
{
if (inputResponseCnt > 0)
{
if (inputBuffer[0] == 'A' || inputBuffer[0] == 'a')
{
startMod = 1;
endMod = p_syncInfo->moduleCount;
bContinue = NAI_FALSE;
}
else
{
naibrd_GetModuleName(p_syncInfo->cardIndex, endMod, &modId);
startMod = endMod = (int32_t)atol((const char*)inputBuffer);
if ((endMod <= 0) || (endMod > p_syncInfo->moduleCount)
|| !SyncSupported(modId))
{
naiif_printf("ERROR: Invalid module value.\r\n\r\n");
}
else
{
bContinue = NAI_FALSE;
}
}
}
else
{
naiif_printf("ERROR: Invalid module value.\r\n\r\n");
}
}
}
if (!bQuit)
{
for(modNum = startMod; modNum <= endMod; modNum++)
{
switch(p_syncInfo->moduleType[modNum-1])
{
case SYNCOPS_MOD_TYPE_AD:
status = check_status(naibrd_AD_ClearFIFO(p_syncInfo->cardIndex, modNum, p_syncInfo->channel[modNum-1]));
break;
case SYNCOPS_MOD_TYPE_DA:
status = check_status(naibrd_DA_ClearFIFO(p_syncInfo->cardIndex, modNum, p_syncInfo->channel[modNum-1]));
break;
default:
break;
}
}
}
}
return status;
}
nai_status_t SyncBasicOps_triggerMaster(int32_t paramCount, int32_t* p_params)
{
naiapp_syncInfo_t *p_syncInfo = (naiapp_syncInfo_t*)p_params;
nai_status_t status = NAI_ERROR_UNKNOWN;
uint32_t fifoCount = 0u;
uint32_t samplesToCollect = 0u;
if (SYNC_PARAM_COUNT == paramCount)
{
/* Enable the fifo's to collect data. Once enabled, fifo's will continue to collect until they reach FIFOSize. If data is
removed from the fifo while it's enabled, the fifo will begin collecting again until it reaches FIFOSize. The fifo needs
to be disabled after the collection in order to access the data without collecting more. */
SetFifoTriggers(p_syncInfo, NAI_TRUE);
if (0 != p_syncInfo->triggerMasterModNum)
{
naiif_printf("Triggering FIFO on MASTER module %d (all slaves will trigger as well)...", p_syncInfo->triggerMasterModNum);
status = SoftwareTrigger(*p_syncInfo, p_syncInfo->triggerMasterModNum);
naiif_printf("Trigger Complete. FIFO is collecting data.\r\n");
naiif_printf("Waiting for FIFO I/O to complete...");
GetFIFOSize(*p_syncInfo, p_syncInfo->triggerMasterModNum, p_syncInfo->channel[p_syncInfo->triggerMasterModNum - 1], &samplesToCollect);
/* Keep checking the fifo count of the master until it is equal to FifoSize(numSamplesPerTrigger). All slave fifos will collect
data at the same rate, so only check one module (in this case the master) to see when data collection is complete. */
}
else
{
naiif_printf("Waiting for external trigger..\r\n");
}
}
return status;
}
static nai_status_t SyncBasicOps_stopFifo(int32_t paramCount, int32_t* p_params)
{
return SetFifoTriggers((naiapp_syncInfo_t*)p_params, NAI_FALSE);
}
static nai_status_t SyncBasicOps_loadData(int32_t paramCount, int32_t* p_params)
{
naiapp_syncInfo_t *p_syncInfo = (naiapp_syncInfo_t*)p_params;
int32_t modNum = 0;
naibrd_module_sync_mode_type_t mode;
int32_t masterModNum = 0;
nai_status_t status = NAI_ERROR_UNKNOWN;
int32_t dataIndex = 0;
float64_t data[] = {0.0, 5.0};
uint32_t udata[] = {0, 0x7FFFu};
uint32_t written = 0;
naibrd_da_fifo_trig_t trigCtrl = (naibrd_da_fifo_trig_t)0;
if (SYNC_PARAM_COUNT == paramCount)
{
for (modNum = 1; modNum <= p_syncInfo->moduleCount; modNum++)
{
if (SYNCOPS_MOD_TYPE_DA == p_syncInfo->moduleType[modNum-1])
{
status = GetModuleSyncMode(*p_syncInfo, modNum, NAIBRD_SYNC_CONFIG_TRIGGER, &mode, &masterModNum);
if (NAI_GEN5_MODULE_SYNC_MODE_DISABLED != mode)
{
/* Disable the fifo to stop it from sending data. */
status = check_status(naibrd_DA_GetFIFOTrigCtrl(p_syncInfo->cardIndex, modNum, p_syncInfo->channel[modNum-1], &trigCtrl));
trigCtrl &= ~NAIBRD_DA_GEN5_FIFO_TRIG_ENABLE;
status = check_status(naibrd_DA_SetFIFOTrigCtrl(p_syncInfo->cardIndex, modNum, p_syncInfo->channel[modNum-1],trigCtrl));
/* Load the fifo with data. */
for (dataIndex = 0; (dataIndex < SYNCOPS_NUM_FIFO_SAMPLES) && (status == NAI_SUCCESS); dataIndex++)
{
status = check_status(naibrd_DA_SetFIFO32(p_syncInfo->cardIndex, modNum, p_syncInfo->channel[modNum-1], 1, &(data[dataIndex%(sizeof(data) / sizeof(data[0]))]), &written));
}
}
else
{
naiif_printf("Sync mode is disabled for this module.\r\n");
}
}
}
}
return status;
}
nai_status_t SyncBasicOps_collectData(int32_t paramCount, int32_t* p_params)
{
naiapp_syncInfo_t *p_syncInfo = (naiapp_syncInfo_t*)p_params;
int32_t modNum = 0;
naibrd_module_sync_mode_type_t mode;
int32_t masterModNum = 0;
nai_status_t status = NAI_ERROR_UNKNOWN;
int32_t dataIndex = 0;
char line[500];
char tmpString[50];
uint32_t read[NAI_MAX_MODULES];
FILE *dataFile = naiif_fopen(DATA_FILE, "w");
naibrd_ad_fifo_trig_t trigCtrl = (naibrd_ad_fifo_trig_t)0;
if (SYNC_PARAM_COUNT == paramCount)
{
if (NULL == dataFile)
{
naiif_printf("Can not open file %s\r\n", DATA_FILE);
}
else
{
memset(read, 0, sizeof(read));
/* loop through all modules and save the fifo data on the modules that are not disabled (some mode of sync enabled). */
sprintf(line, "%s", "Index ");
for (modNum = 1; modNum <= p_syncInfo->moduleCount; modNum++)
{
if (SYNCOPS_MOD_TYPE_AD == p_syncInfo->moduleType[modNum-1])
{
status = GetModuleSyncMode(*p_syncInfo, modNum, NAIBRD_SYNC_CONFIG_TRIGGER, &mode, &masterModNum);
if (NAI_GEN5_MODULE_SYNC_MODE_DISABLED != mode)
{
/* Disable the fifo to stop it from collecting data. */
status = check_status(naibrd_AD_GetFIFOTrigCtrl(p_syncInfo->cardIndex, modNum, p_syncInfo->channel[modNum-1], &trigCtrl));
trigCtrl &= ~NAIBRD_AD_FIFO_TRIG_ENABLE;
status = check_status(naibrd_AD_SetFIFOTrigCtrl(p_syncInfo->cardIndex, modNum, p_syncInfo->channel[modNum-1], trigCtrl));
/* read the data that is in the A/D fifo. */
status = ReadFIFO32(*p_syncInfo, modNum, &(read[modNum-1]));
if (NAI_SUCCESS == status)
{
sprintf(tmpString, "Module%-6d", modNum);
strcat(line, tmpString);
}
}
}
}
naiif_fprintf(dataFile, "%s\r\n", line);
for(dataIndex = 0; dataIndex < SYNCOPS_NUM_FIFO_SAMPLES; dataIndex++)
{
sprintf(line, "%3u ", dataIndex);
for (modNum = 1; modNum < NAI_MAX_MODULES; modNum++)
{
if (read[modNum-1] > 0)
{
sprintf(tmpString, "%12.3f", fifoData[modNum-1][dataIndex]);
strcat(line, tmpString);
}
}
naiif_fprintf(dataFile, "%s\n", line);
line[0] = '\0';
}
naiif_fclose(dataFile);
naiif_printf("Data saved to %s\r\n", DATA_FILE);
}
}
return status;
}
const char* SyncModeString(naibrd_module_sync_mode_type_t mode)
{
const char* retVal = NULL;
switch(mode)
{
case NAI_GEN5_MODULE_SYNC_MODE_DISABLED:
retVal = "DISABLED";
break;
case NAI_GEN5_MODULE_SYNC_MODE_SLAVE_INTERNAL:
retVal = "SLAVE (INTERNAL BOARD)";
break;
case NAI_GEN5_MODULE_SYNC_MODE_SLAVE_BOARD_CLOCK:
retVal = "SLAVE (EXT BOARD SOURCE)";
break;
case NAI_GEN5_MODULE_SYNC_MODE_SLAVE_USER_CLOCK:
retVal = "SLAVE (EXT I/O SOURCE)";
break;
case NAI_GEN5_MODULE_SYNC_MODE_MASTER:
retVal = "MASTER";
break;
default:
retVal = "ERROR!";
break;
}
return retVal;
}
static bool_t SyncSupported(uint32_t modID)
{
bool_t retVal = NAI_FALSE;
switch(modID)
{
case NAIBRD_MODULE_ID_AD1:
case NAIBRD_MODULE_ID_AD2:
case NAIBRD_MODULE_ID_AD3:
case NAIBRD_MODULE_ID_AD4:
case NAIBRD_MODULE_ID_AD5:
case NAIBRD_MODULE_ID_AD6:
case NAIBRD_MODULE_ID_ADE:
case NAIBRD_MODULE_ID_ADF:
case NAIBRD_MODULE_ID_ADG:
case NAIBRD_MODULE_ID_CME:
case NAIBRD_MODULE_ID_CMF:
case NAIBRD_MODULE_ID_CMG:
case NAIBRD_MODULE_ID_DA1:
case NAIBRD_MODULE_ID_DA2:
case NAIBRD_MODULE_ID_DA3:
case NAIBRD_MODULE_ID_DA4:
case NAIBRD_MODULE_ID_DA5:
retVal = NAI_TRUE;
break;
default:
retVal = NAI_FALSE;
break;
}
return retVal;
}
static syncops_module_type_t GetModuleType(uint32_t modID)
{
return (syncops_module_type_t)(modID & SYNCOPS_MOD_TYPE_MASK);
}
static bool_t GetMasterModule(naiapp_syncInfo_t *p_syncInfo, int32_t *p_masterModNum)
{
bool_t bQuit = NAI_FALSE;
bool_t bContinue = NAI_TRUE;
int8_t inputBuffer[80];
int32_t inputResponseCnt;
uint32_t modId = 0;
while(bContinue)
{
naiif_printf("Enter the module to sync to (master module) [1-%d]\r\n", p_syncInfo->moduleCount);
bQuit = naiapp_query_ForQuitResponse(sizeof(inputBuffer), NAI_QUIT_CHAR, inputBuffer, &inputResponseCnt);
if (!bQuit)
{
if (inputResponseCnt > 0)
{
*p_masterModNum = (int32_t)atol((const char*)inputBuffer);
naibrd_GetModuleName(p_syncInfo->cardIndex, *p_masterModNum, & modId);
if ((*p_masterModNum <= 0) || (*p_masterModNum > p_syncInfo->moduleCount)
|| !SyncSupported(modId))
{
naiif_printf("ERROR: Invalid module value.\r\n\r\n");
}
else
bContinue = NAI_FALSE;
}
else
{
naiif_printf("ERROR: Invalid module value.\r\n\r\n");
}
}
}
return bQuit;
}
static nai_status_t ConfigFifoSync(naiapp_syncInfo_t *p_syncInfo, int32_t modNum, naibrd_module_sync_mode_type_t mode, uint32_t trigCtrl)
{
nai_status_t status = SetModuleSyncMode(*p_syncInfo, modNum, NAIBRD_SYNC_CONFIG_TRIGGER, mode, p_syncInfo->triggerMasterModNum);
switch(p_syncInfo->moduleType[modNum-1])
{
case SYNCOPS_MOD_TYPE_AD:
status = check_status(naibrd_AD_SetFIFOTrigCtrl(p_syncInfo->cardIndex, modNum, p_syncInfo->channel[modNum-1],
(naibrd_ad_fifo_trig_t)trigCtrl));
break;
case SYNCOPS_MOD_TYPE_DA:
status = check_status(naibrd_DA_SetFIFOTrigCtrl(p_syncInfo->cardIndex, modNum, p_syncInfo->channel[modNum-1],
(naibrd_da_fifo_trig_t)trigCtrl));
/* This API does not apply to all DA's, and may return NAAI_ERROR_NOT_SUPPORTED. This is ok because this setting is not needed by
the modules that do not support it. */
naibrd_DA_SetFIFOCtrl(p_syncInfo->cardIndex, modNum, p_syncInfo->channel[modNum-1],
NAIBRD_DA_GEN5_FIFO_CTRL_REPEAT_MODE | NAIBRD_DA_GEN5_FIFO_CTRL_ENABLE);
break;
default:
status = NAI_ERROR_INVALID_MODULE;
break;
}
return status;
}
static nai_status_t SetFifoTriggers(naiapp_syncInfo_t *p_syncInfo, bool_t trigEnable)
{
int32_t modIndex = 0;
nai_status_t status = NAI_ERROR_UNKNOWN;
uint32_t trigCtrl = 0u;
for(modIndex = 0; modIndex < p_syncInfo->moduleCount; modIndex++)
{
switch(p_syncInfo->moduleType[modIndex])
{
case SYNCOPS_MOD_TYPE_AD:
status = check_status(naibrd_AD_GetFIFOTrigCtrl(p_syncInfo->cardIndex, modIndex + 1, p_syncInfo->channel[modIndex],
(naibrd_ad_fifo_trig_t*)(&trigCtrl)));
if (NAI_FALSE != trigEnable)
{
trigCtrl |= (uint32_t)NAIBRD_AD_FIFO_TRIG_ENABLE;
}
else
{
trigCtrl &= (uint32_t)~NAIBRD_AD_FIFO_TRIG_ENABLE;
}
status = check_status(naibrd_AD_SetFIFOTrigCtrl(p_syncInfo->cardIndex, modIndex + 1, p_syncInfo->channel[modIndex],
(naibrd_ad_fifo_trig_t)(trigCtrl)));
break;
case SYNCOPS_MOD_TYPE_DA:
status = check_status(naibrd_DA_GetFIFOTrigCtrl(p_syncInfo->cardIndex, modIndex + 1, p_syncInfo->channel[modIndex],
(naibrd_da_fifo_trig_t*)(&trigCtrl)));
if (NAI_FALSE != trigEnable)
{
trigCtrl |= (uint32_t)NAIBRD_DA_GEN5_FIFO_TRIG_ENABLE;
}
else
{
trigCtrl &= (uint32_t)~NAIBRD_DA_GEN5_FIFO_TRIG_ENABLE;
}
status = check_status(naibrd_DA_SetFIFOTrigCtrl(p_syncInfo->cardIndex, modIndex + 1, p_syncInfo->channel[modIndex],
(naibrd_da_fifo_trig_t)(trigCtrl)));
break;
default:
break;
}
}
return status;
}
static nai_status_t GetModuleSyncMode(naiapp_syncInfo_t syncInfo, int32_t modNum, naibrd_module_sync_config_type_t config,
naibrd_module_sync_mode_type_t *p_mode, int32_t *p_masterModNum)
{
nai_status_t status = NAI_ERROR_UNKNOWN;
switch(syncInfo.moduleType[modNum-1])
{
case SYNCOPS_MOD_TYPE_AD:
status = check_status(naibrd_AD_GetModuleSyncMode(syncInfo.cardIndex, modNum, config, p_mode, p_masterModNum));
break;
case SYNCOPS_MOD_TYPE_DA:
status = check_status(naibrd_DA_GetModuleSyncMode(syncInfo.cardIndex, modNum, config, p_mode, p_masterModNum));
break;
default:
status = NAI_ERROR_NOT_SUPPORTED;
break;
}
return status;
}
static nai_status_t SetModuleSyncMode(naiapp_syncInfo_t syncInfo, int32_t modNum, naibrd_module_sync_config_type_t config,
naibrd_module_sync_mode_type_t mode, int32_t masterModNum)
{
nai_status_t status = NAI_ERROR_UNKNOWN;
switch(syncInfo.moduleType[modNum-1])
{
case SYNCOPS_MOD_TYPE_AD:
status = check_status(naibrd_AD_SetModuleSyncMode(syncInfo.cardIndex, modNum, config, mode, masterModNum));
break;
case SYNCOPS_MOD_TYPE_DA:
status = check_status(naibrd_DA_SetModuleSyncMode(syncInfo.cardIndex, modNum, config, mode, masterModNum));
break;
default:
status = NAI_ERROR_NOT_SUPPORTED;
break;
}
return status;
}
static nai_status_t ReadFIFO32(naiapp_syncInfo_t syncInfo, int32_t modNum, uint32_t *p_outRead)
{
nai_status_t status = NAI_ERROR_UNKNOWN;
switch(syncInfo.moduleType[modNum-1])
{
case SYNCOPS_MOD_TYPE_AD:
status = check_status(naibrd_AD_ReadFIFO(syncInfo.cardIndex, modNum, syncInfo.channel[modNum-1], SYNCOPS_NUM_FIFO_SAMPLES,
fifoData[modNum-1], p_outRead));
break;
default:
status = NAI_ERROR_INVALID_MODULE;
*p_outRead = 0;
break;
}
return status;
}
static nai_status_t SoftwareTrigger(naiapp_syncInfo_t syncInfo, int32_t modNum)
{
nai_status_t status = NAI_ERROR_UNKNOWN;
switch(syncInfo.moduleType[modNum-1])
{
case SYNCOPS_MOD_TYPE_AD:
status = check_status(naibrd_AD_SoftwareTrigger(syncInfo.cardIndex, modNum));
break;
case SYNCOPS_MOD_TYPE_DA:
status = check_status(naibrd_DA_SoftwareTrigger(syncInfo.cardIndex, modNum));
break;
default:
status = NAI_ERROR_INVALID_MODULE;
break;
}
return status;
}
static nai_status_t GetFIFOSize(naiapp_syncInfo_t syncInfo, int32_t modNum, int32_t channel, uint32_t *p_fifoSize)
{
nai_status_t status = NAI_ERROR_UNKNOWN;
switch(syncInfo.moduleType[modNum-1])
{
case SYNCOPS_MOD_TYPE_AD:
status = check_status(naibrd_AD_GetFIFOSize(syncInfo.cardIndex, modNum, channel, p_fifoSize));
break;
case SYNCOPS_MOD_TYPE_DA:
status = check_status(naibrd_DA_GetFIFOSize(syncInfo.cardIndex, modNum, channel, p_fifoSize));
break;
default:
status = NAI_ERROR_INVALID_MODULE;
break;
}
return status;
}
static nai_status_t GetFIFOCount(naiapp_syncInfo_t syncInfo, int32_t modNum, int32_t channel, uint32_t *p_fifoCount)
{
nai_status_t status = NAI_ERROR_UNKNOWN;
switch(syncInfo.moduleType[modNum-1])
{
case SYNCOPS_MOD_TYPE_AD:
status = check_status(naibrd_AD_GetFIFOCount(syncInfo.cardIndex, modNum, channel, p_fifoCount));
break;
case SYNCOPS_MOD_TYPE_DA:
status = check_status(naibrd_DA_GetFIFOCount(syncInfo.cardIndex, modNum, channel, p_fifoCount));
break;
default:
status = NAI_ERROR_INVALID_MODULE;
break;
}
return status;
}
static nai_status_t GetModuleRate(naiapp_syncInfo_t syncInfo, int32_t modNum, uint32_t *p_rate)
{
nai_status_t status = NAI_ERROR_UNKNOWN;
switch(syncInfo.moduleType[modNum-1])
{
case SYNCOPS_MOD_TYPE_AD:
status = check_status(naibrd_AD_GetSampleRate(syncInfo.cardIndex, modNum, p_rate));
break;
case SYNCOPS_MOD_TYPE_DA:
status = check_status(naibrd_DA_GetUpdateRate(syncInfo.cardIndex, modNum, p_rate));
break;
default:
status = NAI_ERROR_INVALID_MODULE;
break;
}
return status;
}