DIF PatternGenerator
Edit this on GitLab
DIF PatternGenerator
Explanation
About the Sample C Code for NAI DIF Pattern Generator
This C program from North Atlantic Industries (NAI) is designed to interact with NAI’s embedded function modules through the SSK (System Solution Kit). It specifically demonstrates how to configure and operate a Digital Input/Output (DIO) module in pattern generator mode. Below is a detailed walkthrough of the code and its functionality.
Header Files
-
Standard Libraries: These include
stdio.h,stdlib.h,string.h,time.h, andctype.h, which are used for basic C functionalities like input/output operations, memory management, string manipulation, time functions, and character type checking. -
NAI Specific Includes:
-
"include/naiapp_boardaccess_menu.h" -
"include/naiapp_boardaccess_query.h" -
"include/naiapp_boardaccess_access.h" -
"include/naiapp_boardaccess_display.h" -
"include/naiapp_boardaccess_utils.h"These headers likely provide functions and definitions for accessing board-specific operations, querying user inputs, accessing and displaying module configurations, and utility functions.
-
NAI Board Libraries:
-
"nai.h" -
"naibrd.h" -
"functions/naibrd_dif.h" -
"advanced/nai_ether_adv.h"These libraries provide core functionalities and advanced operations for interacting with the NAI hardware and DIF module.
Constants and Global Variables
-
CONFIG_FILE: A configuration file name for the DIF Pattern Generator. -
DEF_DIF_CHANNEL: Default channel set to 1. -
MAX_DIF_PATTERN_GENERATOR_ENTRIES: Maximum number of entries for the pattern generator, set to 4092.
Function Prototypes
Function prototypes for various functionalities including running the pattern generator, configuring channels, displaying configurations, and specific configuration actions (e.g., setting start address, end address, period, burst count, etc.).
Enumeration and Command Tables
-
enum dif_patterngen_commands: Enumerates all possible commands for the pattern generator. -
DIF_PatternGen_MenuCmds: This is a command table defining mappings between command names, descriptions, enumerated command values, and their corresponding handler functions.
Main Function
The entry point of the application, either named main or DIF_PatternGenerator based on the defined platform (non-VxWorks or VxWorks respectively):
-
Initialize and Load Configuration: Attempts to run a configuration menu using
naiapp_RunBoardMenu. -
Main Loop: Prompts user for card index and module selection.
-
Run Pattern Generator: Calls
Run_DIF_PatternGeneratorbased on user input. -
Quit or Restart: Prompts user to quit or restart the application.
-
Cleanup: Closes all open cards before exiting.
Function Definitions
Run_DIF_PatternGenerator and Cfg_DIF_PatternGen_Channel
-
Run_DIF_PatternGenerator: Validates the module and callsCfg_DIF_PatternGen_Channelfor further configuration. -
Cfg_DIF_PatternGen_Channel: Handles user commands to configure the selected channel, updates the pattern generator configuration, and displays updated settings.
Display and Configure Functions
-
Display_DIF_PatternGen_ChannelCfg: Displays the current configuration of the selected DIF channel. -
Different static configuration functions handle specific settings such as the start address, end address, period, burst count, control enable, and pause/play control.
-
Load_DIF_PatternGenArray: Loads a pattern array from a file and sets it for the DIF module. -
Display_DIF_PatternGen_Configuration: Displays current pattern generator configuration settings. -
Configure_DIF_ControlEnableandConfigure_DIF_ControlPause: Handle enabling/disabling and pausing/resuming the pattern generator.
Additional Notes
-
Error Handling: The functions use a
check_statusmacro/function to validate operations against possible errors. -
User Input: Utilizes functions like
naiapp_query_CardIndex,naiapp_query_ModuleNumber, andnaiapp_query_ForQuitResponseto interactively configure the DIF module.
This code effectively demonstrates how to set up and control a pattern generator using NAI’s hardware and software libraries, offering abundant user interaction for flexible configuration changes.
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <ctype.h>
/* Common Sample Program include files */
#include "include/naiapp_boardaccess_menu.h"
#include "include/naiapp_boardaccess_query.h"
#include "include/naiapp_boardaccess_access.h"
#include "include/naiapp_boardaccess_display.h"
#include "include/naiapp_boardaccess_utils.h"
/* naibrd include files */
#include "nai.h"
#include "naibrd.h"
#include "functions/naibrd_dif.h"
#include "advanced/nai_ether_adv.h"
static const int8_t *CONFIG_FILE = (int8_t *)"default_DIF_PatternGenerator.txt";
/* Function prototypes */
void Run_DIF_PatternGenerator(int32_t cardIndex, int32_t module, int32_t ModuleID);
void Cfg_DIF_PatternGen_Channel(int32_t cardIndex, int32_t module, uint32_t ModuleID, int32_t MaxChannel);
void Display_DIF_PatternGen_ChannelCfg(int32_t cardIndex, int32_t module, int32_t chan, uint32_t ModuleID);
static nai_status_t Configure_DIF_PatternGen_StartAddr(int32_t paramCount, int32_t* p_params);
static nai_status_t Configure_DIF_PatternGen_EndAddr(int32_t paramCount, int32_t* p_params);
static nai_status_t Configure_DIF_PatternGen_Period(int32_t paramCount, int32_t* p_params);
static nai_status_t Configure_DIF_PatternGen_Burstcount(int32_t paramCount, int32_t* p_params);
static nai_status_t Configure_DIF_PatternGen_Mode(int32_t paramCount, int32_t* p_params);
static nai_status_t Load_DIF_PatternGenArray(int32_t paramCount, int32_t* p_params);
static nai_status_t Configure_DIF_ControlEnable(int32_t paramCount, int32_t* p_params);
static nai_status_t Configure_DIF_ControlPause(int32_t paramCount, int32_t* p_params);
static nai_status_t Display_DIF_PatternGen_Configuration(int32_t paramCount, int32_t* p_params);
static nai_status_t Display_DIF_Status(int32_t paramCount, int32_t* p_params);
static const int32_t DEF_DIF_CHANNEL = 1;
#define MAX_DIF_PATTERN_GENERATOR_ENTRIES 4092
/****** Command Table *******/
enum dif_patterngen_commands
{
DIF_PATTERNGEN_CMD_MODE,
DIF_PATTERNGEN_CMD_STARTADDR,
DIF_PATTERNGEN_CMD_ENDADDR,
DIF_PATTERNGEN_CMD_PERIOD,
DIF_PATTERNGEN_CMD_BURSTCOUNT,
DIF_PATTERNGEN_CMD_LOAD_DATA,
DIF_PATTERNGEN_CMD_ENABLE,
DIF_PATTERNGEN_CMD_PAUSE_DATA,
DIF_PATTERNGEN_CMD_RESETMODE,
DIF_PATTERNGEN_CMD_RESETALL,
DIF_PATTERNGEN_CMD_SETALL,
DIF_PATTERNGEN_CMD_DISP,
DIF_PATTERNGEN_CMD_STATUS,
DIF_PATTERNGEN_CMD_LAST
};
/****** Command Tables *******/
naiapp_cmdtbl_params_t DIF_PatternGen_MenuCmds[] = {
{"Mode", "DIF Select Pattern Mode", DIF_PATTERNGEN_CMD_MODE, Configure_DIF_PatternGen_Mode},
{"StartAddr", "DIF Set Start Address", DIF_PATTERNGEN_CMD_STARTADDR, Configure_DIF_PatternGen_StartAddr},
{"EndAddr", "DIF Set End Address", DIF_PATTERNGEN_CMD_ENDADDR, Configure_DIF_PatternGen_EndAddr},
{"Period", "DIF Pattern Generator Period", DIF_PATTERNGEN_CMD_PERIOD, Configure_DIF_PatternGen_Period},
{"Count", "DIF Pattern Generator Burst count", DIF_PATTERNGEN_CMD_BURSTCOUNT, Configure_DIF_PatternGen_Burstcount},
{"Load", "DIF Load Pattern Generator Data", DIF_PATTERNGEN_CMD_LOAD_DATA, Load_DIF_PatternGenArray},
{"CONtrol", "DIF Enable or Disable Pattern Generator Output", DIF_PATTERNGEN_CMD_ENABLE, Configure_DIF_ControlEnable},
{"Pause/Play", "DIF Pause or Resume Pattern Gen Output", DIF_PATTERNGEN_CMD_PAUSE_DATA, Configure_DIF_ControlPause},
{"Reset", "DIF Reset Chan Mode, Input", DIF_PATTERNGEN_CMD_RESETMODE, NULL},
{"RAll", "DIF Reset All Channels, Input", DIF_PATTERNGEN_CMD_RESETALL, NULL},
{"SEtall", "DIF Set All Channels to Pattern Gen", DIF_PATTERNGEN_CMD_SETALL, NULL},
{"Display", "DIF Display channel Pattern Generator Info", DIF_PATTERNGEN_CMD_DISP, Display_DIF_PatternGen_Configuration},
{"Stat", "DIF Display Status", DIF_PATTERNGEN_CMD_STATUS, Display_DIF_Status},
};
/**************************************************************************************************************/
/**
<summary>
The purpose of the DIF_PatternGenerator is to illustrate the methods to call in the naibrd library to perform configuration
setup for output in Pattern Generator operation mode. Pattern generator period setting is configurable.
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 DIF routines.
- ClearDeviceCfg
- QuerySystemCfg
- DisplayDeviceCfg
- GetBoardSNModCfg
- SaveDeviceCfg
</summary>
*/
/**************************************************************************************************************/
#if defined (__VXWORKS__)
int32_t DIF_PatternGenerator(void)
#else
int32_t main(void)
#endif
{
bool_t stop = FALSE;
int32_t cardIndex;
int32_t moduleCnt;
int32_t module;
uint32_t moduleID = 0;
int8_t inputBuffer[80];
int32_t inputResponseCnt;
if (naiapp_RunBoardMenu(CONFIG_FILE) == TRUE)
{
while (stop != TRUE)
{
/* Query the user for the card index */
stop = naiapp_query_CardIndex(naiapp_GetBoardCnt(), 0, &cardIndex);
if (stop != TRUE)
{
check_status(naibrd_GetModuleCount(cardIndex, &moduleCnt));
/* Query the user for the module number */
stop = naiapp_query_ModuleNumber(moduleCnt, 1, &module);
if (stop != TRUE)
{
moduleID = naibrd_GetModuleID(cardIndex, module);
if ((moduleID != 0))
{
Run_DIF_PatternGenerator(cardIndex, module, moduleID);
}
}
}
printf("\nType Q to quit or Enter key to restart application:\n");
stop = naiapp_query_ForQuitResponse(sizeof(inputBuffer), NAI_QUIT_CHAR, inputBuffer, &inputResponseCnt);
}
}
printf("\nType the Enter key to exit the program: ");
naiapp_query_ForQuitResponse(sizeof(inputBuffer), NAI_QUIT_CHAR, inputBuffer, &inputResponseCnt);
naiapp_access_CloseAllOpenCards();
return 0;
}
/**************************************************************************************************************/
/**
<summary>
Run_DIF_PatternGenerator prompts the user for the card, module and channel to use for the application and calls
Cfg_DIF_PatternGen_Channel if the card, module, channel is valid for as a TLL module.
</summary>
*/
/**************************************************************************************************************/
void Run_DIF_PatternGenerator(int32_t cardIndex, int32_t module, int32_t ModuleID)
{
int32_t MaxChannel;
MaxChannel = naibrd_DIF_GetChannelCount(ModuleID);
if (MaxChannel == 0)
{
printf(" *** Module selection not recognized as DIF module. ***\n\n");
}
else
{
Cfg_DIF_PatternGen_Channel(cardIndex, module, ModuleID, MaxChannel);
}
}
/**************************************************************************************************************/
/**
<summary>
Cfg_DIF_PatternGen_Channel handles calling the Display_DIF_PatternGen_ChannelCfg routine to display the DIF
channel configuration and calling the routines associated with the user's menu commands.
</summary>
*/
/**************************************************************************************************************/
void Cfg_DIF_PatternGen_Channel(int32_t cardIndex, int32_t module, uint32_t ModuleID, int32_t MaxChannel)
{
bool_t bQuit = FALSE;
bool_t bContinue = TRUE;
bool_t bCmdFound = FALSE;
int32_t chan, defaultchan = 1;
int32_t cmd;
int32_t ch_loop;
int32_t status = 0;
int8_t inputBuffer[80];
int32_t inputResponseCnt;
naiapp_AppParameters_t dif_params;
p_naiapp_AppParameters_t dif_patgen_params = &dif_params;
dif_patgen_params->cardIndex = cardIndex;
dif_patgen_params->module = module;
dif_patgen_params->modId = ModuleID;
dif_patgen_params->maxChannels = MaxChannel;
while (bContinue)
{
printf(" \r\n\r\n");
printf("Channel selection \r\n");
printf("================= \r\n");
defaultchan = DEF_DIF_CHANNEL;
bQuit = naiapp_query_ChannelNumber(MaxChannel, defaultchan, &chan);
dif_patgen_params->channel = chan;
/* Configure the selected channel for Pattern Generator Mode and output mode */
check_status(naibrd_DIF_SetOpMode(cardIndex, module, chan, NAI_DIF_MODE_OUTPUT_PATTERN_RAM));
check_status(naibrd_DIF_SetIOFormat(cardIndex, module, chan, NAI_DIF_GEN5_IOFORMAT_OUTPUT));
naiapp_utils_LoadParamMenuCommands(DIF_PATTERNGEN_CMD_LAST, DIF_PatternGen_MenuCmds);
while (bContinue)
{
Display_DIF_PatternGen_ChannelCfg(cardIndex, module, chan, ModuleID);
naiapp_display_ParamMenuCommands((int8_t *)"DIF Pattern Generator Operation Menu");
printf("\nType DIF command or %c to quit : ", NAI_QUIT_CHAR);
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)
{
switch (cmd)
{
case DIF_PATTERNGEN_CMD_LOAD_DATA:
case DIF_PATTERNGEN_CMD_PERIOD:
case DIF_PATTERNGEN_CMD_STARTADDR:
case DIF_PATTERNGEN_CMD_ENDADDR:
case DIF_PATTERNGEN_CMD_BURSTCOUNT:
case DIF_PATTERNGEN_CMD_MODE:
case DIF_PATTERNGEN_CMD_ENABLE:
case DIF_PATTERNGEN_CMD_PAUSE_DATA:
case DIF_PATTERNGEN_CMD_DISP:
case DIF_PATTERNGEN_CMD_STATUS:
DIF_PatternGen_MenuCmds[cmd].func(APP_PARAM_COUNT, (int32_t*)dif_patgen_params);
break;
case DIF_PATTERNGEN_CMD_RESETMODE:
{
status |= check_status(naibrd_DIF_SetEnhanceTriggerEnable(cardIndex, module, chan, NAI_DIF_ENHANCE_OP_DISABLE));
status |= check_status(naibrd_DIF_SetOpMode(cardIndex, module, chan, NAI_DIF_MODE_STD_INPUT_OUTPUT));
status |= check_status(naibrd_DIF_SetPatternGenCtrl(cardIndex,module, NAI_DIF_PATTERN_RAM_CONTROL_ENABLE,NAI_DIF_ENHANCE_OP_DISABLE));
status |= check_status(naibrd_DIF_SetPatternGenCtrl(cardIndex,module, NAI_DIF_PATTERN_RAM_CONTROL_BURST, NAI_DIF_ENHANCE_OP_DISABLE));
status |= check_status(naibrd_DIF_SetPatternGenCtrl(cardIndex,module, NAI_DIF_PATTERN_RAM_CONTROL_PAUSE, NAI_DIF_ENHANCE_OP_DISABLE));
if (status == NAI_SUCCESS)
printf("Reset completed \n");
else
printf("Error %2X on set \n", status);
}
break;
case DIF_PATTERNGEN_CMD_RESETALL:
{
status = NAI_SUCCESS;
for (ch_loop=1; ch_loop<=MaxChannel; ch_loop++)
{
status |= check_status(naibrd_DIF_SetEnhanceTriggerEnable(cardIndex, module, ch_loop, NAI_DIF_ENHANCE_OP_DISABLE));
status |= check_status(naibrd_DIF_SetOpMode(cardIndex, module, ch_loop, NAI_DIF_MODE_STD_INPUT_OUTPUT));
status |= check_status(naibrd_DIF_SetPatternGenCtrl(cardIndex,module, NAI_DIF_PATTERN_RAM_CONTROL_ENABLE, NAI_DIF_ENHANCE_OP_DISABLE));
status |= check_status(naibrd_DIF_SetPatternGenCtrl(cardIndex,module, NAI_DIF_PATTERN_RAM_CONTROL_BURST, NAI_DIF_ENHANCE_OP_DISABLE));
status |= check_status(naibrd_DIF_SetPatternGenCtrl(cardIndex,module, NAI_DIF_PATTERN_RAM_CONTROL_PAUSE, NAI_DIF_ENHANCE_OP_DISABLE));
status |= check_status(naibrd_DIF_Reset(cardIndex, module, ch_loop, NAI_DIF_RESET_TIMER_ONLY));
}
if (status == NAI_SUCCESS)
printf("Reset All completed \n");
else
printf("Error %2X on set \n", status);
}
break;
case DIF_PATTERNGEN_CMD_SETALL:
{
status = NAI_SUCCESS;
for (ch_loop=1; ch_loop<=MaxChannel; ch_loop++)
{
status |= check_status(naibrd_DIF_SetOutputState(cardIndex, module, ch_loop, NAI_DIF_STATE_LO));
status |= check_status(naibrd_DIF_SetIOFormat(cardIndex, module, ch_loop, NAI_DIF_GEN5_IOFORMAT_OUTPUT));
status |= check_status(naibrd_DIF_SetOpMode(cardIndex, module, ch_loop, NAI_DIF_MODE_OUTPUT_PATTERN_RAM));
}
if (status == NAI_SUCCESS)
printf("Set on all channels completed \n");
else
printf("Error %2X on set \n", status);
}
break;
default:
printf("Invalid command entered\n");
break;
}
}
else
printf("Invalid command entered\n");
}
}
else
bContinue = FALSE;
}
}
}
/**************************************************************************************************************/
/**
<summary>
Display_DIF_PatternGen_ChannelCfg illustrate the methods to call in the naibrd library to retrieve the configuration states
for basic operation.
</summary>
*/
/**************************************************************************************************************/
void Display_DIF_PatternGen_ChannelCfg(int32_t cardIndex, int32_t module, int32_t chan, uint32_t ModuleID)
{
uint32_t ioformat = 0;
nai_dif_state_t outputstate = 0;
nai_dif_state_t inputstate = 0;
nai_dif_enhanced_mode_t opmode = 0;
nai_dif_enable_t enablebit=0;
nai_dif_enable_t burstbit=0;
nai_dif_enable_t pausebit=0;
uint32_t ModuleVer;
uint32_t ModuleRev;
uint32_t ModInfo_Special;
naibrd_GetModuleInfo(cardIndex, module, &ModuleID, &ModuleVer, &ModuleRev, &ModInfo_Special);
check_status(naibrd_DIF_GetIOFormat(cardIndex, module, chan, &ioformat));
check_status(naibrd_DIF_GetOutputState(cardIndex, module, chan, &outputstate));
check_status(naibrd_DIF_GetInputState(cardIndex, module, chan, &inputstate));
check_status(naibrd_DIF_GetOpMode(cardIndex, module, chan, &opmode));
check_status(naibrd_DIF_GetPatternGenCtrl(cardIndex,module, NAI_DIF_PATTERN_RAM_CONTROL_ENABLE, &enablebit));
check_status(naibrd_DIF_GetPatternGenCtrl(cardIndex,module, NAI_DIF_PATTERN_RAM_CONTROL_BURST, &burstbit));
check_status(naibrd_DIF_GetPatternGenCtrl(cardIndex,module, NAI_DIF_PATTERN_RAM_CONTROL_PAUSE, &pausebit));
printf("\n === Channel %d ===\n\n", chan);
/*read PWM configuration values here, Period, Pulsewidth, Continuous/Burst Mode, */
{
printf(" I/O Output Input \n");
printf(" Format State State Enhanced Mode Selection \n");
printf(" -------- ------- ------- ------------------------- \n");
}
/*display configuration settings here- */
switch (ioformat)
{
case NAI_DIF_IOFORMAT_INPUT:
printf(" Input ");
break;
case NAI_DIF_GEN3_IOFORMAT_OUTPUT:
case NAI_DIF_GEN5_IOFORMAT_OUTPUT:
printf(" High-side"); /*may want add check for proper value depending on whether gen3 or gen5; for now, assume it correctly matches module*/
break;
default:
printf(" Unknown ");
break;
}
switch (outputstate)
{
case NAI_DIF_STATE_LO:
printf(" LOW ");
break;
case NAI_DIF_STATE_HI:
printf(" HIGH ");
break;
default:
printf(" Unknown ");
break;
}
switch (inputstate)
{
case NAI_DIF_STATE_LO:
printf(" LOW Input ");
break;
case NAI_DIF_STATE_HI:
printf("HIGH Input ");
break;
default:
printf("Unknown ");
break;
}
switch (opmode)
{
case NAI_DIF_MODE_STD_INPUT_OUTPUT:
printf("STD_INPUT_OUTPUT \n");
break;
case NAI_DIF_MODE_MEASURE_HIGH_TIME:
printf("NAI_DIF_MODE_MEASURE_HIGH_TIME \n");
break;
case NAI_DIF_MODE_MEASURE_LOW_TIME:
printf("NAI_DIF_MODE_MEASURE_LOW_TIME \n ");
break;
case NAI_DIF_MODE_TIMESTAMP_RISING_EDGES:
printf("NAI_DIF_MODE_TIMESTAMP_RISING_EDGES \n");
break;
case NAI_DIF_MODE_TIMESTAMP_FALLING_EDGES:
printf("NAI_DIF_MODE_TIMESTAMP_FALLING_EDGES \n");
break;
case NAI_DIF_MODE_TIMESTAMP_ALL_EDGES:
printf("NAI_DIF_MODE_TIMESTAMP_ALL_EDGES \n");
break;
case NAI_DIF_MODE_COUNT_RISING_EDGES:
printf("NAI_DIF_MODE_COUNT_RISING_EDGES \n");
break;
case NAI_DIF_MODE_COUNT_FALLING_EDGES:
printf("NAI_DIF_MODE_COUNT_FALLING_EDGES \n");
break;
case NAI_DIF_MODE_COUNT_ALL_EDGES:
printf("NAI_DIF_MODE_COUNT_ALL_EDGES \n");
break;
case NAI_DIF_MODE_MEASURE_PERIOD_FROM_RISING_EDGE:
printf("NAI_DIF_MODE_MEASURE_PERIOD_FROM_RISING_EDGE \n");
break;
case NAI_DIF_MODE_MEASURE_FREQUENCY:
printf("NAI_DIF_MODE_MEASURE_FREQUENCY \n");
break;
case NAI_DIF_MODE_OUTPUT_PWM_FOREVER:
printf("NAI_DIF_MODE_OUTPUT_PWM_FOREVER \n");
break;
case NAI_DIF_MODE_OUTPUT_PWM_CYCLE_NUM_TIMES:
printf("NAI_DIF_MODE_OUTPUT_PWM_CYCLE_NUM_TIMES \n");
break;
case NAI_DIF_MODE_OUTPUT_PATTERN_RAM:
printf("NAI_DIF_MODE_OUTPUT_PATTERN_RAM \n");
break;
default:
printf("Unknown ");
break;
}
printf(" \n\n");
printf(" Pattern Gen Mode \n");
printf(" --------------------------\n");
switch (enablebit)
{
case NAI_DIF_STATE_LO:
printf(" Disabled");
break;
case NAI_DIF_STATE_HI:
printf(" Enabled");
break;
/* undefined value read back */
default:
printf(" UNK ");
break;
}
switch (burstbit)
{
case NAI_DIF_STATE_LO:
printf(" Continuous Mode");
break;
case NAI_DIF_STATE_HI:
printf(" Burst Mode");
break;
/* undefined value read back */
default:
printf(" UNK ");
break;
}
switch (pausebit)
{
case NAI_DIF_STATE_LO:
break;
case NAI_DIF_STATE_HI:
printf(" PAUSED");
break;
/* undefined value read back */
default:
printf(" UNK ");
break;
}
}
/**************************************************************************************************************/
/**
<summary>
Configure_DIF_PatternGen_StartAddr handles the user request to configure the time values for period on the selected
channel and calls the method in the naibrd library to set the period.
</summary>
*/
/**************************************************************************************************************/
static nai_status_t Configure_DIF_PatternGen_StartAddr(int32_t paramCount, int32_t* p_params)
{
p_naiapp_AppParameters_t p_dif_params = (p_naiapp_AppParameters_t)p_params;
int32_t cardIndex = p_dif_params->cardIndex;
int32_t module = p_dif_params->module;
bool_t bQuit = FALSE;
uint32_t startAddr = 0;
uint32_t min = 0;
uint32_t max = 0;
uint32_t ModuleID;
uint32_t ModuleVer;
uint32_t ModuleRev;
uint32_t ModInfo_Special;
int8_t inputBuffer[80];
int32_t inputResponseCnt;
#if defined (WIN32)
UNREFERENCED_PARAMETER(paramCount);
#endif
printf("\nEnter the desired Start Address: 0x");
bQuit = naiapp_query_ForQuitResponse(sizeof(inputBuffer), NAI_QUIT_CHAR, inputBuffer, &inputResponseCnt);
if (!bQuit)
{
if (inputResponseCnt > 0)
{
naibrd_GetModuleInfo(cardIndex, module, &ModuleID, &ModuleVer, &ModuleRev, &ModInfo_Special);
startAddr = strtol(((const char *)inputBuffer),NULL,16);
switch (ModuleID)
{
case NAI_MODULE_ID_DF2:
min =naibrd_DIF_GetValidPatternGenStart(ModuleID);
max =naibrd_DIF_GetValidPatternGenEnd(ModuleID);
default:
break;
}
if (startAddr > max || startAddr < min)
printf(" Entry out of range. Range %08X to %08X \n", min, max);
else
{
check_status(naibrd_DIF_SetPatternGenStartAddr(cardIndex,module,startAddr));
}
}
}
return (bQuit) ? NAI_ERROR_UNKNOWN : NAI_SUCCESS;
}
/**************************************************************************************************************/
/**
<summary>
Configure_DIF_PatternGen_EndAddr handles the user request to configure the time values for period on the selected
channel and calls the method in the naibrd library to set the period.
</summary>
*/
/**************************************************************************************************************/
static nai_status_t Configure_DIF_PatternGen_EndAddr(int32_t paramCount, int32_t* p_params)
{
p_naiapp_AppParameters_t p_dif_params = (p_naiapp_AppParameters_t)p_params;
int32_t cardIndex = p_dif_params->cardIndex;
int32_t module = p_dif_params->module;
bool_t bQuit = FALSE;
uint32_t endAddr = 0;
uint32_t min = 0;
uint32_t max = 0;
uint32_t ModuleID;
uint32_t ModuleVer;
uint32_t ModuleRev;
uint32_t ModInfo_Special;
int8_t inputBuffer[80];
int32_t inputResponseCnt;
#if defined (WIN32)
UNREFERENCED_PARAMETER(paramCount);
#endif
printf("\nEnter the desired End Address: 0x");
bQuit = naiapp_query_ForQuitResponse(sizeof(inputBuffer), NAI_QUIT_CHAR, inputBuffer, &inputResponseCnt);
if (!bQuit)
{
if (inputResponseCnt > 0)
{
naibrd_GetModuleInfo(cardIndex, module, &ModuleID, &ModuleVer, &ModuleRev, &ModInfo_Special);
endAddr = strtol(((const char *)inputBuffer),NULL,16);;
switch (ModuleID)
{
case NAI_MODULE_ID_DF2:
min =naibrd_DIF_GetValidPatternGenStart(ModuleID);
max =naibrd_DIF_GetValidPatternGenEnd(ModuleID);
default:
break;
}
if (endAddr > max || endAddr < min)
printf(" Entry out of range. Range 0x%08X to 0x%08X \n", min, max);
else
{
check_status(naibrd_DIF_SetPatternGenEndAddr(cardIndex,module,endAddr));
}
}
}
return (bQuit) ? NAI_ERROR_UNKNOWN : NAI_SUCCESS;
}
/**************************************************************************************************************/
/**
<summary>
Configure_DIF_PatternGen_Period handles the user request to configure the time values for period on the selected
channel and calls the method in the naibrd library to set the period.
</summary>
*/
/**************************************************************************************************************/
nai_status_t Configure_DIF_PatternGen_Period(int32_t paramCount, int32_t* p_params)
{
p_naiapp_AppParameters_t p_dif_params = (p_naiapp_AppParameters_t)p_params;
int32_t cardIndex = p_dif_params->cardIndex;
int32_t module = p_dif_params->module;
bool_t bQuit = FALSE;
float64_t time = 0.0;
float64_t lsb = 0;
float64_t min = 1;
float64_t max = -1;
uint32_t ModuleID;
uint32_t ModuleVer;
uint32_t ModuleRev;
uint32_t ModInfo_Special;
int8_t inputBuffer[80];
int32_t inputResponseCnt;
#if defined (WIN32)
UNREFERENCED_PARAMETER(paramCount);
#endif
printf("\nEnter the desired period in ms: ");
bQuit = naiapp_query_ForQuitResponse(sizeof(inputBuffer), NAI_QUIT_CHAR, inputBuffer, &inputResponseCnt);
if (!bQuit)
{
if (inputResponseCnt > 0)
{
naibrd_GetModuleInfo(cardIndex, module, &ModuleID, &ModuleVer, &ModuleRev, &ModInfo_Special);
time = atof((const char *)inputBuffer); /*entry in milliseconds*/
lsb = naibrd_DIF_GetTimebaseLSB(ModuleID);
switch (ModuleID)
{
case NAI_MODULE_ID_DF2:
min =(float64_t)(0x2u * lsb);
max =(float64_t)(0xFFFFFFFF * lsb);
break;
default:
break;
}
if (time > max || time < min)
printf(" Entry out of range. Range %7.3f to %7.3f ms\n", min, max);
else
{
check_status(naibrd_DIF_SetPatternGenPeriod(cardIndex, module, time));
}
}
}
return (bQuit) ? NAI_ERROR_UNKNOWN : NAI_SUCCESS;
}
/**************************************************************************************************************/
/**
<summary>
Handles the user request to set the burst count value for the number of pulses to be issued upon trigger in
PWM burst mode operation on the selected channel, calling the method in the naibrd library to set the burst number.
</summary>
*/
/**************************************************************************************************************/
static nai_status_t Configure_DIF_PatternGen_Burstcount(int32_t paramCount, int32_t* p_params)
{
p_naiapp_AppParameters_t p_dif_params = (p_naiapp_AppParameters_t)p_params;
int32_t cardIndex = p_dif_params->cardIndex;
int32_t module = p_dif_params->module;
bool_t bQuit = FALSE;
uint32_t burstcount;
uint32_t ModuleID;
uint32_t ModuleVer;
uint32_t ModuleRev;
uint32_t ModInfo_Special;
int8_t inputBuffer[80];
int32_t inputResponseCnt;
#if defined (WIN32)
UNREFERENCED_PARAMETER(paramCount);
#endif
printf("\nEnter the desired burst count: ");
bQuit = naiapp_query_ForQuitResponse(sizeof(inputBuffer), NAI_QUIT_CHAR, inputBuffer, &inputResponseCnt);
if (!bQuit)
{
if (inputResponseCnt > 0)
{
naibrd_GetModuleInfo(cardIndex, module, &ModuleID, &ModuleVer, &ModuleRev, &ModInfo_Special);
burstcount = atoi((const char *)inputBuffer);
switch (ModuleID)
{
case NAI_MODULE_ID_DF2:
if (burstcount < 1)
{
burstcount = 1; /*minimum count is one*/
printf("Setting burstcount to minimum of 1.\n");
}
check_status(naibrd_DIF_SetPatternGen_BurstNum(cardIndex, module, burstcount));
break;
default:
printf("Unsupported function for this module.\n");
break;
}
}
}
return (bQuit) ? NAI_ERROR_UNKNOWN : NAI_SUCCESS;
}
/**************************************************************************************************************/
/**
<summary>
Configure_DIF_PatternGen_Mode handles the user request to select the PWM mode for the selected channel
and calls the method in the naibrd library to set the mode.
</summary>
*/
/**************************************************************************************************************/
static nai_status_t Configure_DIF_PatternGen_Mode(int32_t paramCount, int32_t* p_params)
{
p_naiapp_AppParameters_t p_dif_params = (p_naiapp_AppParameters_t)p_params;
int32_t cardIndex = p_dif_params->cardIndex;
int32_t module = p_dif_params->module;
int32_t chan = p_dif_params->channel;
bool_t bQuit = FALSE;
int8_t inputBuffer[80];
int32_t inputResponseCnt;
#if defined (WIN32)
UNREFERENCED_PARAMETER(paramCount);
#endif
printf("\n == Pattern Gen Mode Selection == \n C Continuous Pattern Gen mode \n Burst Burst Pattern Gen mode \n\n Type DIF command : ");
bQuit = naiapp_query_ForQuitResponse(sizeof(inputBuffer), NAI_QUIT_CHAR, inputBuffer, &inputResponseCnt);
if (!bQuit)
{
if (inputResponseCnt > 0)
{
if ((toupper(inputBuffer[0]) == 'C'))
{
check_status(naibrd_DIF_SetIOFormat(cardIndex, module, chan, NAI_DIF_GEN5_IOFORMAT_OUTPUT));
naibrd_DIF_SetPatternGenCtrl(cardIndex,module, NAI_DIF_PATTERN_RAM_CONTROL_BURST, NAI_DIF_ENHANCE_OP_DISABLE);
}
else if ((toupper(inputBuffer[0]) == 'B'))
{
check_status(naibrd_DIF_SetIOFormat(cardIndex, module, chan, NAI_DIF_GEN5_IOFORMAT_OUTPUT));
naibrd_DIF_SetPatternGenCtrl(cardIndex,module, NAI_DIF_PATTERN_RAM_CONTROL_BURST, NAI_DIF_ENHANCE_OP_ENABLE);
}
}
}
return (bQuit) ? NAI_ERROR_UNKNOWN : NAI_SUCCESS;
}
/**************************************************************************************************************/
/**
<summary>
Load_DIF_PatternGenArray loads the pattern from a file and illustrate the methods to call in the naibrd library to
set the pattern data. Channel independent, array covers all channels
</summary>
*/
/**************************************************************************************************************/
nai_status_t Load_DIF_PatternGenArray(int32_t paramCount, int32_t* p_params)
{
p_naiapp_AppParameters_t p_dif_params = (p_naiapp_AppParameters_t)p_params;
int32_t cardIndex = p_dif_params->cardIndex;
int32_t module = p_dif_params->module;
bool_t patternLoaded = FALSE;
uint32_t dataPattern[MAX_DIF_PATTERN_GENERATOR_ENTRIES];
int32_t i, j, len;
int32_t entryCnt = 0;
FILE* patternfile = NULL;
int8_t* filename = (int8_t*)"TestRAMPattern.txt";
int8_t buffer[256];
int8_t data[256];
#if defined (WIN32)
UNREFERENCED_PARAMETER(paramCount);
#endif
for (i = 0; i < MAX_DIF_PATTERN_GENERATOR_ENTRIES; i++)
dataPattern[i] = 0;
patternfile = fopen((const char *)filename,"r");
if (patternfile != NULL)
{
while (fgets((char*)buffer,sizeof(buffer),patternfile))
{
if (entryCnt > MAX_DIF_PATTERN_GENERATOR_ENTRIES)
break;
else
{
/* Entries in the RAMPattern.txt are expected to be data only in hex format, each data value is on a new line */
len = (int32_t)strlen((const char*)buffer);
i = 0;
j = 0;
/* read the addr entry */
while ((buffer[i] != '\n') && (i < len))
{
if (isdigit(buffer[i]) || isalpha(buffer[i]))
data[j++] = buffer[i];
i++;
}
data[j] = '\0';
if (strlen((const char*)data) > 0)
{
dataPattern[entryCnt] = naiapp_utils_HexStrToDecUInt32(data);
entryCnt++;
}
}
}
if (entryCnt > 0)
{
/* Load the pattern into memory */
check_status(naibrd_DIF_SetPatternGenBuf(cardIndex, module, entryCnt, &dataPattern[0]));
patternLoaded = TRUE;
}
else
{
printf("ERROR: No pattern data has been loaded from Pattern file: %s\n", filename);
}
fclose(patternfile);
}
else
printf("ERROR: Unable to open Pattern file: %s\n", filename);
return (patternLoaded) ? NAI_ERROR_UNKNOWN : NAI_SUCCESS;
}
/**************************************************************************************************************/
/**
<summary>
Configure_DIF_ControlEnable handles the user request to change the switch state for the selected
channel and calls the method in the naibrd library to set the state.
</summary>
*/
/**************************************************************************************************************/
static nai_status_t Configure_DIF_ControlEnable(int32_t paramCount, int32_t* p_params)
{
p_naiapp_AppParameters_t p_dif_params = (p_naiapp_AppParameters_t)p_params;
int32_t cardIndex = p_dif_params->cardIndex;
int32_t module = p_dif_params->module;
bool_t bQuit = FALSE;
bool_t bUpdateOutput = FALSE;
nai_dif_state_t enState = 0;
int8_t inputBuffer[80];
int32_t inputResponseCnt;
#if defined (WIN32)
UNREFERENCED_PARAMETER(paramCount);
#endif
/* Set the switch state (open or closed).
*/
printf("\n Type the desired Enable Bit Value, Enable or Disable \n ");
printf(" Enter Enable or Disable: ");
bQuit = naiapp_query_ForQuitResponse(sizeof(inputBuffer), NAI_QUIT_CHAR, inputBuffer, &inputResponseCnt);
if (!bQuit)
{
if (inputResponseCnt > 0)
{
switch (toupper(inputBuffer[0]))
{
case 'E':
enState = NAI_DIF_ENHANCE_OP_ENABLE;
bUpdateOutput = TRUE;
break;
case 'D':
enState= NAI_DIF_ENHANCE_OP_DISABLE;
bUpdateOutput = TRUE;
break;
default:
printf("ERROR: Invalid switch state selection\n");
break;
}
}
}
if (!bQuit)
{
if (bUpdateOutput)
check_status(naibrd_DIF_SetPatternGenCtrl(cardIndex,module, NAI_DIF_PATTERN_RAM_CONTROL_ENABLE, enState));
}
return (bQuit) ? NAI_ERROR_UNKNOWN : NAI_SUCCESS;
}
/**************************************************************************************************************/
/**
<summary>
Configure_DIF_ControlPause handles the user request to change the switch state for the selected
channel and calls the method in the naibrd library to set the state.
</summary>
*/
/**************************************************************************************************************/
static nai_status_t Configure_DIF_ControlPause(int32_t paramCount, int32_t* p_params)
{
p_naiapp_AppParameters_t p_dif_params = (p_naiapp_AppParameters_t)p_params;
int32_t cardIndex = p_dif_params->cardIndex;
int32_t module = p_dif_params->module;
bool_t bQuit = FALSE;
bool_t bUpdateOutput = FALSE;
nai_dif_state_t enState = 0;
int8_t inputBuffer[80];
int32_t inputResponseCnt;
#if defined (WIN32)
UNREFERENCED_PARAMETER(paramCount);
#endif
/* Set the switch state (open or closed).
*/
printf("\n Type PAUSE or RESUME to Control Pattern Generator Output\n ");
printf(" Enter PAUSE or RESUME: ");
bQuit = naiapp_query_ForQuitResponse(sizeof(inputBuffer), NAI_QUIT_CHAR, inputBuffer, &inputResponseCnt);
if (!bQuit)
{
if (inputResponseCnt > 0)
{
switch (toupper(inputBuffer[0]))
{
case 'P':
enState = NAI_DIF_ENHANCE_OP_ENABLE;
bUpdateOutput = TRUE;
break;
case 'R':
enState= NAI_DIF_ENHANCE_OP_DISABLE;
bUpdateOutput = TRUE;
break;
default:
printf("ERROR: Invalid switch state selection\n");
break;
}
}
}
if (!bQuit)
{
if (bUpdateOutput)
check_status(naibrd_DIF_SetPatternGenCtrl(cardIndex,module, NAI_DIF_PATTERN_RAM_CONTROL_PAUSE, enState));
}
return (bQuit) ? NAI_ERROR_UNKNOWN : NAI_SUCCESS;
}
/**************************************************************************************************************/
/**
<summary>
Display_DIF_PatternGen_Configuration illustrate the methods to call in the naibrd library to retrieve the PWM
configuration settings.
</summary>
*/
/**************************************************************************************************************/
static nai_status_t Display_DIF_PatternGen_Configuration(int32_t paramCount, int32_t* p_params)
{
p_naiapp_AppParameters_t p_dif_params = (p_naiapp_AppParameters_t)p_params;
int32_t cardIndex = p_dif_params->cardIndex;
int32_t module = p_dif_params->module;
float64_t period;
uint32_t burstnumber;
uint32_t startaddr;
uint32_t endaddr;
#if defined (WIN32)
UNREFERENCED_PARAMETER(paramCount);
#endif
printf("\n");
printf(" ----------PatternGen Configuration Settings-------------\n");
printf(" Period (ms) Burst Cnt StartAddr EndAddr \n");
printf(" ------------- ----------- ----------- ----------\n");
check_status(naibrd_DIF_GetPatternGenPeriod(cardIndex, module, &period));
printf(" %10.6f ", period);
check_status(naibrd_DIF_GetPatternGen_BurstNum(cardIndex, module, &burstnumber));
printf(" 0x%08X ", burstnumber);
check_status(naibrd_DIF_GetPatternGenStartAddr(cardIndex, module, &startaddr));
printf(" 0x%08X ", startaddr);
check_status(naibrd_DIF_GetPatternGenEndAddr(cardIndex, module, &endaddr));
printf(" 0x%08X ", endaddr);
printf("\n\n");
return NAI_ERROR_UNKNOWN;
}
/**************************************************************************************************************/
/**
<summary>
Display_DSW_Status illustrate the methods to call in the naibrd library to retrieve the status states.
</summary>
*/
/**************************************************************************************************************/
static nai_status_t Display_DIF_Status(int32_t paramCount, int32_t* p_params)
{
p_naiapp_AppParameters_t p_dif_params = (p_naiapp_AppParameters_t)p_params;
int32_t cardIndex = p_dif_params->cardIndex;
int32_t module = p_dif_params->module;
int32_t chan = p_dif_params->channel;
nai_status_bit_t status;
#if defined (WIN32)
UNREFERENCED_PARAMETER(paramCount);
#endif
/* Available status:
NAI_DIF_STATUS_BIT_LATCHED,
NAI_DIF_STATUS_OVERCURRENT_LATCHED,
NAI_DIF_STATUS_LO_HI_TRANS_LATCHED,
NAI_DIF_STATUS_HI_LO_TRANS_LATCHED,
*/
printf("\n");
printf(" ----------- Status -----------\n");
printf(" BIT OC Lo-Hi Hi-Lo \n");
printf(" ------- -------- ------ ------- \n");
check_status(naibrd_DIF_GetStatus(cardIndex, module, chan, NAI_DIF_STATUS_BIT_LATCHED, &status));
printf(" %3i ", status);
check_status(naibrd_DIF_GetStatus(cardIndex, module, chan, NAI_DIF_STATUS_OVERCURRENT_LATCHED, &status));
printf(" %3i ", status);
check_status(naibrd_DIF_GetStatus(cardIndex, module, chan, NAI_DIF_STATUS_LO_HI_TRANS_LATCHED, &status));
printf(" %3i ", status);
check_status(naibrd_DIF_GetStatus(cardIndex, module, chan, NAI_DIF_STATUS_HI_LO_TRANS_LATCHED, &status));
printf(" %3i ", status);
printf("\n\n");
return NAI_ERROR_UNKNOWN;
}