TTL PatternGenerator
Edit this on GitLab
TTL PatternGenerator
Explanation
About This Code
This sample C application from North Atlantic Industries (NAI) demonstrates how to interact with embedded function modules using their SSK (Standard Software Kit). The specific focus here is on configuring and running a TTL (Transistor-Transistor Logic) Pattern Generator. The code utilizes various functions from the naibrd library to achieve these operations.
Key Definitions and Components
Include Files
-
<stdio.h>,<stdlib.h>,<string.h>,<time.h>,<ctype.h>: Standard C library headers. -
include/naiapp_boardaccess_menu.h: Header for accessing board menu functionalities. -
include/naiapp_boardaccess_query.h: Header for querying system configurations. -
include/naiapp_boardaccess_access.h: Header for accessing board functionalities. -
include/naiapp_boardaccess_display.h: Header for display configurations. -
include/naiapp_boardaccess_utils.h: Utility functions for board access. -
nai.handnaibrd.h: Core NAI hardware definition headers. -
functions/naibrd_ttl.h: Specific to TTL functionalities. -
advanced/nai_ether_adv.h: Advanced Ethernet functionalities.
Constants
-
CONFIG_FILE: Default configuration file for the pattern generator. -
DEF_TTL_CHANNEL: Default TTL channel set to 1. -
MAX_TTL_PATTERN_GENERATOR_ENTRIES: Maximum number of pattern entries set to 4092.
Enumerations
-
ttl_patterngen_commands: Defines various command operations for the TTL Pattern Generator.
Key Data Structures
-
TTL_PatternGen_MenuCmds: Command table, associating command strings with their corresponding actions.
*Functionality *
Main Program
-
The main function initializes and runs a board menu based on the configuration file.
-
It iterates through user inputs to get the card index and module number, then calls
Run_TTL_PatternGenerator()if valid.
Command Handling Functions
-
Run_TTL_PatternGenerator(): Validates the module and callsCfg_TTL_PatternGen_Channel()to configure the channel. -
Cfg_TTL_PatternGen_Channel(): Handles user commands to configure TTL settings, including mode, addresses, period, burst count, etc. -
Display_TTL_PatternGen_ChannelCfg(): Displays the current channel configuration.
Configuration and Utility Functions
-
Configure_TTL_PatternGen_StartAddr(): Sets the start address for the pattern generator. -
Configure_TTL_PatternGen_EndAddr(): Sets the end address for the pattern generator. -
Configure_TTL_PatternGen_Period(): Configures the period for the pattern generator. -
Configure_TTL_PatternGen_Burstcount(): Sets the burst count value. -
Configure_TTL_PatternGen_Mode(): Selects the mode of the pattern generator. -
Load_TTL_PatternGenArray(): Loads pattern data from a file into the pattern generator. -
Configure_TTL_ControlEnable(): Enables or disables the pattern generator output. -
Configure_TTL_ControlPause(): Pauses or resumes the pattern generator output. -
Display_TTL_PatternGen_Configuration(): Shows the current configuration. -
Display_TTL_Status(): Displays the TTL status.
Notes
-
This application is likely run on a specific OS using macros to handle variations (
VXWORKS). -
Error handling is managed through the
check_status()function, which is used extensively to check the return status of the library functions.
This code provides a comprehensive example of configuring a TTL Pattern Generator using the NAI naibrd library, offering useful insights into how these embedded modules can be controlled in a robust and interactive manner.
#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_ttl.h"
#include "advanced/nai_ether_adv.h"
static const int8_t *CONFIG_FILE = (int8_t *)"default_TTL_PatternGenerator.txt";
/* Function prototypes */
void Run_TTL_PatternGenerator(int32_t cardIndex, int32_t module, int32_t ModuleID);
void Cfg_TTL_PatternGen_Channel(int32_t cardIndex, int32_t module, uint32_t ModuleID, int32_t MaxChannel);
void Display_TTL_PatternGen_ChannelCfg(int32_t cardIndex, int32_t module, int32_t chan, uint32_t ModuleID);
static nai_status_t Configure_TTL_PatternGen_StartAddr(int32_t paramCount, int32_t* p_params);
static nai_status_t Configure_TTL_PatternGen_EndAddr(int32_t paramCount, int32_t* p_params);
static nai_status_t Configure_TTL_PatternGen_Period(int32_t paramCount, int32_t* p_params);
static nai_status_t Configure_TTL_PatternGen_Burstcount(int32_t paramCount, int32_t* p_params);
static nai_status_t Configure_TTL_PatternGen_Mode(int32_t paramCount, int32_t* p_params);
static nai_status_t Load_TTL_PatternGenArray(int32_t paramCount, int32_t* p_params);
static nai_status_t Configure_TTL_ControlEnable(int32_t paramCount, int32_t* p_params);
static nai_status_t Configure_TTL_ControlPause(int32_t paramCount, int32_t* p_params);
static nai_status_t Display_TTL_PatternGen_Configuration(int32_t paramCount, int32_t* p_params);
static nai_status_t Display_TTL_Status(int32_t paramCount, int32_t* p_params);
static const int32_t DEF_TTL_CHANNEL = 1;
#define MAX_TTL_PATTERN_GENERATOR_ENTRIES 4092
/****** Command Table *******/
enum ttl_patterngen_commands
{
TTL_PATTERNGEN_CMD_MODE,
TTL_PATTERNGEN_CMD_STARTADDR,
TTL_PATTERNGEN_CMD_ENDADDR,
TTL_PATTERNGEN_CMD_PERIOD,
TTL_PATTERNGEN_CMD_BURSTCOUNT,
TTL_PATTERNGEN_CMD_LOAD_DATA,
TTL_PATTERNGEN_CMD_ENABLE,
TTL_PATTERNGEN_CMD_PAUSE_DATA,
TTL_PATTERNGEN_CMD_RESETMODE,
TTL_PATTERNGEN_CMD_RESETALL,
TTL_PATTERNGEN_CMD_SETALL,
TTL_PATTERNGEN_CMD_DISP,
TTL_PATTERNGEN_CMD_STATUS,
TTL_PATTERNGEN_CMD_LAST
};
/****** Command Tables *******/
naiapp_cmdtbl_params_t TTL_PatternGen_MenuCmds[] = {
{"Mode", "TTL Select Pattern Mode", TTL_PATTERNGEN_CMD_MODE, Configure_TTL_PatternGen_Mode},
{"StartAddr", "TTL Set Start Address", TTL_PATTERNGEN_CMD_STARTADDR, Configure_TTL_PatternGen_StartAddr},
{"EndAddr", "TTL Set End Address", TTL_PATTERNGEN_CMD_ENDADDR, Configure_TTL_PatternGen_EndAddr},
{"Period", "TTL Pattern Generator Period", TTL_PATTERNGEN_CMD_PERIOD, Configure_TTL_PatternGen_Period},
{"Count", "TTL Pattern Generator Burst count", TTL_PATTERNGEN_CMD_BURSTCOUNT, Configure_TTL_PatternGen_Burstcount},
{"Load", "TTL Load Pattern Generator Data", TTL_PATTERNGEN_CMD_LOAD_DATA, Load_TTL_PatternGenArray},
{"CONtrol", "TTL Enable or Disable Pattern Generator Output", TTL_PATTERNGEN_CMD_ENABLE, Configure_TTL_ControlEnable},
{"Pause/Play", "TTL Pause or Resume Pattern Gen Output", TTL_PATTERNGEN_CMD_PAUSE_DATA, Configure_TTL_ControlPause},
{"Reset", "TTL Reset Chan Mode, Input", TTL_PATTERNGEN_CMD_RESETMODE, NULL},
{"RAll", "TTL Reset All Channels, Input", TTL_PATTERNGEN_CMD_RESETALL, NULL},
{"SEtall", "TTL Set All Channels to Pattern Gen", TTL_PATTERNGEN_CMD_SETALL, NULL},
{"Display", "TTL Display channel Pattern Generator Info", TTL_PATTERNGEN_CMD_DISP, Display_TTL_PatternGen_Configuration},
{"Stat", "TTL Display Status", TTL_PATTERNGEN_CMD_STATUS, Display_TTL_Status},
};
/**************************************************************************************************************/
/**
<summary>
The purpose of the TTL_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 TTL routines.
- ClearDeviceCfg
- QuerySystemCfg
- DisplayDeviceCfg
- GetBoardSNModCfg
- SaveDeviceCfg
</summary>
*/
/**************************************************************************************************************/
#if defined (__VXWORKS__)
int32_t TTL_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_TTL_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_TTL_PatternGenerator prompts the user for the card, module and channel to use for the application and calls
Cfg_TTL_PatternGen_Channel if the card, module, channel is valid for as a TLL module.
</summary>
*/
/**************************************************************************************************************/
void Run_TTL_PatternGenerator(int32_t cardIndex, int32_t module, int32_t ModuleID)
{
int32_t MaxChannel;
MaxChannel = naibrd_TTL_GetChannelCount(ModuleID);
if (MaxChannel == 0)
{
printf(" *** Module selection not recognized as TTL module. ***\n\n");
}
else
{
Cfg_TTL_PatternGen_Channel(cardIndex, module, ModuleID, MaxChannel);
}
}
/**************************************************************************************************************/
/**
<summary>
Cfg_TTL_PatternGen_Channel handles calling the Display_TTL_PatternGen_ChannelCfg routine to display the TTL
channel configuration and calling the routines associated with the user's menu commands.
</summary>
*/
/**************************************************************************************************************/
void Cfg_TTL_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 defaultchan = 1;
int32_t cmd;
int32_t ch_loop;
int32_t status = 0;
int8_t inputBuffer[80];
int32_t inputResponseCnt;
naiapp_AppParameters_t ttl_params;
p_naiapp_AppParameters_t ttl_patgen_params = &ttl_params;
ttl_patgen_params->cardIndex = cardIndex;
ttl_patgen_params->module = module;
while (bContinue)
{
printf(" \r\n\r\n");
printf("Channel selection \r\n");
printf("================= \r\n");
defaultchan = DEF_TTL_CHANNEL;
bQuit = naiapp_query_ChannelNumber(MaxChannel, defaultchan, &ttl_patgen_params->channel);
/* Configure the selected channel for Pattern Generator Mode */
check_status(naibrd_TTL_SetOpMode(cardIndex, module, ttl_patgen_params->channel, NAI_TTL_MODE_OUTPUT_PATTERN_RAM));
naiapp_utils_LoadParamMenuCommands(TTL_PATTERNGEN_CMD_LAST, TTL_PatternGen_MenuCmds);
while (bContinue)
{
Display_TTL_PatternGen_ChannelCfg(cardIndex, module, ttl_patgen_params->channel, ModuleID);
naiapp_display_ParamMenuCommands((int8_t *)"TTL Pattern Generator Operation Menu");
printf("\nType TTL 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 TTL_PATTERNGEN_CMD_LOAD_DATA:
case TTL_PATTERNGEN_CMD_PERIOD:
case TTL_PATTERNGEN_CMD_STARTADDR:
case TTL_PATTERNGEN_CMD_ENDADDR:
case TTL_PATTERNGEN_CMD_BURSTCOUNT:
case TTL_PATTERNGEN_CMD_MODE:
case TTL_PATTERNGEN_CMD_ENABLE:
case TTL_PATTERNGEN_CMD_PAUSE_DATA:
case TTL_PATTERNGEN_CMD_DISP:
case TTL_PATTERNGEN_CMD_STATUS:
TTL_PatternGen_MenuCmds[cmd].func(APP_PARAM_COUNT, (int32_t*)ttl_patgen_params);
break;
case TTL_PATTERNGEN_CMD_RESETMODE:
{
status |= check_status(naibrd_TTL_SetEnhanceTriggerEnable(cardIndex, module, ttl_patgen_params->channel, NAI_TTL_ENHANCED_OP_DISABLE));
status |= check_status(naibrd_TTL_SetOpMode(cardIndex, module, ttl_patgen_params->channel, NAI_TTL_MODE_STD_INPUT_OUTPUT));
status |= check_status(naibrd_TTL_SetPatternGenCtrl(cardIndex, module, NAI_TTL_CTRL_PATTERN_ENABLE, NAI_TTL_ENHANCED_OP_DISABLE));
status |= check_status(naibrd_TTL_SetPatternGenCtrl(cardIndex, module, NAI_TTL_CTRL_PATTERN_BURST, NAI_TTL_ENHANCED_OP_DISABLE));
status |= check_status(naibrd_TTL_SetPatternGenCtrl(cardIndex, module, NAI_TTL_CTRL_PATTERN_PAUSE, NAI_TTL_ENHANCED_OP_DISABLE));
if (status == NAI_SUCCESS)
printf("Reset completed \n");
else
printf("Error %2X on set \n", status);
}
break;
case TTL_PATTERNGEN_CMD_RESETALL:
{
status = NAI_SUCCESS;
for (ch_loop = 1; ch_loop <= MaxChannel; ch_loop++)
{
status |= check_status(naibrd_TTL_SetEnhanceTriggerEnable(cardIndex, module, ch_loop, NAI_TTL_ENHANCED_OP_DISABLE));
status |= check_status(naibrd_TTL_SetOpMode(cardIndex, module, ch_loop, NAI_TTL_MODE_STD_INPUT_OUTPUT));
status |= check_status(naibrd_TTL_SetPatternGenCtrl(cardIndex, module, NAI_TTL_CTRL_PATTERN_ENABLE, NAI_TTL_ENHANCED_OP_DISABLE));
status |= check_status(naibrd_TTL_SetPatternGenCtrl(cardIndex, module, NAI_TTL_CTRL_PATTERN_BURST, NAI_TTL_ENHANCED_OP_DISABLE));
status |= check_status(naibrd_TTL_SetPatternGenCtrl(cardIndex, module, NAI_TTL_CTRL_PATTERN_PAUSE, NAI_TTL_ENHANCED_OP_DISABLE));
status |= check_status(naibrd_TTL_Reset(cardIndex, module, ch_loop, NAI_TTL_RESET_TIMER_ONLY));
}
if (status == NAI_SUCCESS)
printf("Reset All completed \n");
else
printf("Error %2X on set \n", status);
}
break;
case TTL_PATTERNGEN_CMD_SETALL:
{
status = NAI_SUCCESS;
for (ch_loop = 1; ch_loop <= MaxChannel; ch_loop++)
{
status |= check_status(naibrd_TTL_SetOutputState(cardIndex, module, ch_loop, NAI_TTL_STATE_LO));
status |= check_status(naibrd_TTL_SetIOFormat(cardIndex, module, ch_loop, NAI_TTL_GEN5_IOFORMAT_OUTPUT));
status |= check_status(naibrd_TTL_SetOpMode(cardIndex, module, ch_loop, NAI_TTL_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_TTL_PatternGen_ChannelCfg illustrate the methods to call in the naibrd library to retrieve the configuration states
for basic operation.
</summary>
*/
/**************************************************************************************************************/
void Display_TTL_PatternGen_ChannelCfg(int32_t cardIndex, int32_t module, int32_t chan, uint32_t ModuleID)
{
uint32_t ioformat = 0;
nai_ttl_state_t outputstate = 0;
nai_ttl_state_t inputstate = 0;
nai_ttl_enhanced_mode_t opmode = 0;
nai_ttl_enable_t enablebit = 0;
nai_ttl_enable_t burstbit = 0;
nai_ttl_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_TTL_GetIOFormat(cardIndex, module, chan, &ioformat));
check_status(naibrd_TTL_GetOutputState(cardIndex, module, chan, &outputstate));
check_status(naibrd_TTL_GetInputState(cardIndex, module, chan, &inputstate));
check_status(naibrd_TTL_GetOpMode(cardIndex, module, chan, &opmode));
check_status(naibrd_TTL_GetPatternGenCtrl(cardIndex, module, NAI_TTL_CTRL_PATTERN_ENABLE, &enablebit));
check_status(naibrd_TTL_GetPatternGenCtrl(cardIndex, module, NAI_TTL_CTRL_PATTERN_BURST, &burstbit));
check_status(naibrd_TTL_GetPatternGenCtrl(cardIndex, module, NAI_TTL_CTRL_PATTERN_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 Pattern Gen Mode \n");
printf("-------- ------- ------- ------------------------- -----------------------\n");
}
/*display configuration settings here- */
switch (ioformat)
{
case NAI_TTL_IOFORMAT_INPUT:
printf(" Input ");
break;
case NAI_TTL_GEN3_IOFORMAT_OUTPUT:
case NAI_TTL_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_TTL_STATE_LO:
printf(" LOW ");
break;
case NAI_TTL_STATE_HI:
printf(" HIGH ");
break;
default:
printf(" Unknown ");
break;
}
switch (inputstate)
{
case NAI_TTL_STATE_LO:
printf(" LOW Input ");
break;
case NAI_TTL_STATE_HI:
printf("HIGH Input ");
break;
default:
printf("Unknown ");
break;
}
switch (opmode)
{
case NAI_TTL_MODE_STD_INPUT_OUTPUT:
printf("STD_INPUT_OUTPUT ");
break;
case NAI_TTL_MODE_MEASURE_HIGH_TIME:
printf("NAI_TTL_MODE_MEASURE_HIGH_TIME ");
break;
case NAI_TTL_MODE_MEASURE_LOW_TIME:
printf("NAI_TTL_MODE_MEASURE_LOW_TIME ");
break;
case NAI_TTL_MODE_TIMESTAMP_RISING_EDGES:
printf("NAI_TTL_MODE_TIMESTAMP_RISING_EDGES ");
break;
case NAI_TTL_MODE_TIMESTAMP_FALLING_EDGES:
printf("NAI_TTL_MODE_TIMESTAMP_FALLING_EDGES ");
break;
case NAI_TTL_MODE_TIMESTAMP_ALL_EDGES:
printf("NAI_TTL_MODE_TIMESTAMP_ALL_EDGES ");
break;
case NAI_TTL_MODE_COUNT_RISING_EDGES:
printf("NAI_TTL_MODE_COUNT_RISING_EDGES ");
break;
case NAI_TTL_MODE_COUNT_FALLING_EDGES:
printf("NAI_TTL_MODE_COUNT_FALLING_EDGES ");
break;
case NAI_TTL_MODE_COUNT_ALL_EDGES:
printf("NAI_TTL_MODE_COUNT_ALL_EDGES ");
break;
case NAI_TTL_MODE_MEASURE_PERIOD_FROM_RISING_EDGE:
printf("NAI_TTL_MODE_MEASURE_PERIOD_FROM_RISING_EDGE ");
break;
case NAI_TTL_MODE_MEASURE_FREQUENCY:
printf("NAI_TTL_MODE_MEASURE_FREQUENCY ");
break;
case NAI_TTL_MODE_OUTPUT_PWM_FOREVER:
printf("NAI_TTL_MODE_OUTPUT_PWM_FOREVER ");
break;
case NAI_TTL_MODE_OUTPUT_PWM_CYCLE_NUM_TIMES:
printf("NAI_TTL_MODE_OUTPUT_PWM_CYCLE_NUM_TIMES ");
break;
case NAI_TTL_MODE_OUTPUT_PATTERN_RAM:
printf("NAI_TTL_MODE_OUTPUT_PATTERN_RAM ");
break;
default:
printf("Unknown ");
break;
}
switch (enablebit)
{
case NAI_TTL_STATE_LO:
printf(" Disabled");
break;
case NAI_TTL_STATE_HI:
printf(" Enabled");
break;
/* undefined value read back */
default:
printf(" UNK ");
break;
}
switch (burstbit)
{
case NAI_TTL_STATE_LO:
printf(" Continuous Mode");
break;
case NAI_TTL_STATE_HI:
printf(" Burst Mode");
break;
/* undefined value read back */
default:
printf(" UNK ");
break;
}
switch (pausebit)
{
case NAI_TTL_STATE_LO:
break;
case NAI_TTL_STATE_HI:
printf(" PAUSED");
break;
/* undefined value read back */
default:
printf(" UNK ");
break;
}
}
/**************************************************************************************************************/
/**
<summary>
Configure_TTL_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_TTL_PatternGen_StartAddr(int32_t paramCount, int32_t* p_params)
{
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;
p_naiapp_AppParameters_t p_ttl_params = (p_naiapp_AppParameters_t)p_params;
int32_t cardIndex = p_ttl_params->cardIndex;
int32_t module = p_ttl_params->module;
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_TL2:
case NAI_MODULE_ID_TL4:
case NAI_MODULE_ID_TL6:
case NAI_MODULE_ID_TL8:
min = 0x00040000; /* naibrd_TTL_GetValidPatternGenStart(ModuleID); */
max = 0x0007FFFC; /* naibrd_TTL_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_TTL_SetPatternGenStartAddr(cardIndex, module, startAddr));
}
}
}
return (bQuit) ? NAI_ERROR_UNKNOWN : NAI_SUCCESS;
}
/**************************************************************************************************************/
/**
<summary>
Configure_TTL_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_TTL_PatternGen_EndAddr(int32_t paramCount, int32_t* p_params)
{
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;
p_naiapp_AppParameters_t p_ttl_params = (p_naiapp_AppParameters_t)p_params;
int32_t cardIndex = p_ttl_params->cardIndex;
int32_t module = p_ttl_params->module;
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_TL2:
case NAI_MODULE_ID_TL4:
case NAI_MODULE_ID_TL6:
case NAI_MODULE_ID_TL8:
min = 0x00040000; /*naibrd_TTL_GetValidPatternGenStart(ModuleID); */
max = 0x0007FFFC; /* naibrd_TTL_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_TTL_SetPatternGenEndAddr(cardIndex, module, endAddr));
}
}
}
return (bQuit) ? NAI_ERROR_UNKNOWN : NAI_SUCCESS;
}
/**************************************************************************************************************/
/**
<summary>
Configure_TTL_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_TTL_PatternGen_Period(int32_t paramCount, int32_t* p_params)
{
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;
p_naiapp_AppParameters_t p_ttl_params = (p_naiapp_AppParameters_t)p_params;
int32_t cardIndex = p_ttl_params->cardIndex;
int32_t module = p_ttl_params->module;
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_TTL_GetTimebaseLSB(ModuleID);
switch (ModuleID)
{
case NAI_MODULE_ID_TL2:
case NAI_MODULE_ID_TL4:
case NAI_MODULE_ID_TL6:
case NAI_MODULE_ID_TL8:
min = (float64_t)(0x2u * lsb);
max = (float64_t)(0xFFFFFFFF * lsb);
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_TTL_SetPatternGenPeriod(cardIndex, module, 1, 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_TTL_PatternGen_Burstcount(int32_t paramCount, int32_t* p_params)
{
bool_t bQuit = FALSE;
uint32_t burstcount;
uint32_t ModuleID;
uint32_t ModuleVer;
uint32_t ModuleRev;
uint32_t ModInfo_Special;
p_naiapp_AppParameters_t p_ttl_params = (p_naiapp_AppParameters_t)p_params;
int32_t cardIndex = p_ttl_params->cardIndex;
int32_t module = p_ttl_params->module;
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_TL2:
case NAI_MODULE_ID_TL4:
case NAI_MODULE_ID_TL6:
case NAI_MODULE_ID_TL8:
if (burstcount < 1)
{
burstcount = 1; /*minimum count is one*/
printf("Setting burstcount to minimum of 1.\n");
}
check_status(naibrd_TTL_SetPatternGen_BurstNum(cardIndex, module, burstcount));
break;
default:
printf("Unsupported function for this module.\n");
break;
}
}
}
return (bQuit) ? NAI_ERROR_UNKNOWN : NAI_SUCCESS;
}
/**************************************************************************************************************/
/**
<summary>
Configure_TTL_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_TTL_PatternGen_Mode(int32_t paramCount, int32_t* p_params)
{
bool_t bQuit = FALSE;
p_naiapp_AppParameters_t p_ttl_params = (p_naiapp_AppParameters_t)p_params;
int32_t cardIndex = p_ttl_params->cardIndex;
int32_t module = p_ttl_params->module;
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 TTL command : ");
bQuit = naiapp_query_ForQuitResponse(sizeof(inputBuffer), NAI_QUIT_CHAR, inputBuffer, &inputResponseCnt);
if (!bQuit)
{
if (inputResponseCnt > 0)
{
if ((toupper(inputBuffer[0]) == 'C'))
{
naibrd_TTL_SetPatternGenCtrl(cardIndex, module, NAI_TTL_CTRL_PATTERN_BURST, NAI_TTL_ENHANCED_OP_DISABLE);
}
else if ((toupper(inputBuffer[0]) == 'B'))
{
naibrd_TTL_SetPatternGenCtrl(cardIndex, module, NAI_TTL_CTRL_PATTERN_BURST, NAI_TTL_OUTPUT_ENHANCED_OP_ENABLE);
}
}
}
return (bQuit) ? NAI_ERROR_UNKNOWN : NAI_SUCCESS;
}
/**************************************************************************************************************/
/**
<summary>
Load_TTL_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_TTL_PatternGenArray(int32_t paramCount, int32_t* p_params)
{
bool_t patternLoaded = FALSE;
uint32_t dataPattern[MAX_TTL_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 addr[256];
int8_t data[256];
p_naiapp_AppParameters_t p_ttl_params = (p_naiapp_AppParameters_t)p_params;
int32_t cardIndex = p_ttl_params->cardIndex;
int32_t module = p_ttl_params->module;
#if defined (WIN32)
UNREFERENCED_PARAMETER(paramCount);
#endif
for (i = 0; i < MAX_TTL_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_TTL_PATTERN_GENERATOR_ENTRIES)
break;
else
{
/* Entries in the RAMPattern.txt are expected to be addr,data */
len = (int32_t)strlen((const char*)buffer);
i = 0;
j = 0;
/* read the addr entry */
while ((buffer[i] != ',') && (i < len))
{
if (isdigit(buffer[i]) || isalpha(buffer[i]))
addr[j++] = buffer[i];
i++;
}
addr[i] = '\0';
/* Increment i to skip the comma */
i++;
j = 0;
/* read the data entry */
while (i < len)
{
if (isdigit(buffer[i]) || isalpha(buffer[i]))
data[j++] = buffer[i];
i++;
}
data[j] = '\0';
if ((strlen((const char*)addr) > 0) && (strlen((const char*)data) > 0))
{
dataPattern[entryCnt] = naiapp_utils_HexStrToDecUInt32(data);
entryCnt++;
}
}
}
if (entryCnt > 0)
{
/* Load the pattern into memory */
check_status(naibrd_TTL_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_TTL_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_TTL_ControlEnable(int32_t paramCount, int32_t* p_params)
{
bool_t bQuit = FALSE;
bool_t bUpdateOutput = FALSE;
nai_ttl_state_t enState = 0;
p_naiapp_AppParameters_t p_ttl_params = (p_naiapp_AppParameters_t)p_params;
int32_t cardIndex = p_ttl_params->cardIndex;
int32_t module = p_ttl_params->module;
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_TTL_OUTPUT_ENHANCED_OP_ENABLE;
bUpdateOutput = TRUE;
break;
case 'D':
enState = NAI_TTL_ENHANCED_OP_DISABLE;
bUpdateOutput = TRUE;
break;
default:
printf("ERROR: Invalid switch state selection\n");
break;
}
}
}
if (!bQuit)
{
if (bUpdateOutput)
check_status(naibrd_TTL_SetPatternGenCtrl(cardIndex, module, NAI_TTL_CTRL_PATTERN_ENABLE, enState));
}
return (bQuit) ? NAI_ERROR_UNKNOWN : NAI_SUCCESS;
}
/**************************************************************************************************************/
/**
<summary>
Configure_TTL_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_TTL_ControlPause(int32_t paramCount, int32_t* p_params)
{
bool_t bQuit = FALSE;
bool_t bUpdateOutput = FALSE;
nai_ttl_state_t enState = 0;
p_naiapp_AppParameters_t p_ttl_params = (p_naiapp_AppParameters_t)p_params;
int32_t cardIndex = p_ttl_params->cardIndex;
int32_t module = p_ttl_params->module;
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_TTL_OUTPUT_ENHANCED_OP_ENABLE;
bUpdateOutput = TRUE;
break;
case 'R':
enState = NAI_TTL_OUTPUT_ENHANCED_OP_ENABLE;
bUpdateOutput = TRUE;
break;
default:
printf("ERROR: Invalid switch state selection\n");
break;
}
}
}
if (!bQuit)
{
if (bUpdateOutput)
check_status(naibrd_TTL_SetPatternGenCtrl(cardIndex, module, NAI_TTL_CTRL_PATTERN_PAUSE, enState));
}
return (bQuit) ? NAI_ERROR_UNKNOWN : NAI_SUCCESS;
}
/**************************************************************************************************************/
/**
<summary>
Display_TTL_PatternGen_Configuration illustrate the methods to call in the naibrd library to retrieve the PWM
configuration settings.
</summary>
*/
/**************************************************************************************************************/
static nai_status_t Display_TTL_PatternGen_Configuration(int32_t paramCount, int32_t* p_params)
{
float64_t period;
uint32_t burstnumber;
uint32_t startaddr;
uint32_t endaddr;
p_naiapp_AppParameters_t p_ttl_params = (p_naiapp_AppParameters_t)p_params;
int32_t cardIndex = p_ttl_params->cardIndex;
int32_t module = p_ttl_params->module;
#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_TTL_GetPatternGenPeriod(cardIndex, module, 1, &period));
printf(" %10.6f ", period);
check_status(naibrd_TTL_GetPatternGen_BurstNum(cardIndex, module, &burstnumber));
printf(" 0x%08X ", burstnumber);
check_status(naibrd_TTL_GetPatternGenStartAddr(cardIndex, module, &startaddr));
printf(" 0x%08X ", startaddr);
check_status(naibrd_TTL_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_TTL_Status(int32_t paramCount, int32_t* p_params)
{
nai_status_bit_t status;
p_naiapp_AppParameters_t p_ttl_params = (p_naiapp_AppParameters_t)p_params;
int32_t cardIndex = p_ttl_params->cardIndex;
int32_t module = p_ttl_params->module;
int32_t chan = p_ttl_params->channel;
#if defined (WIN32)
UNREFERENCED_PARAMETER(paramCount);
#endif
/* Available status:
NAI_TTL_STATUS_BIT_LATCHED,
NAI_TTL_STATUS_OVERCURRENT_LATCHED,
NAI_TTL_STATUS_LO_HI_TRANS_LATCHED,
NAI_TTL_STATUS_HI_LO_TRANS_LATCHED,
*/
printf("\n");
printf(" ----------------- Status ----------------------------\n");
printf(" BIT OC Lo-Hi Hi-Lo \n");
printf(" ------- -------- ------ ------- \n");
check_status(naibrd_TTL_GetStatus(cardIndex, module, chan, NAI_TTL_STATUS_BIT_LATCHED, &status));
printf(" %3i ", status);
check_status(naibrd_TTL_GetStatus(cardIndex, module, chan, NAI_TTL_STATUS_OVERCURRENT_LATCHED, &status));
printf(" %3i ", status);
check_status(naibrd_TTL_GetStatus(cardIndex, module, chan, NAI_TTL_STATUS_LO_HI_TRANS_LATCHED, &status));
printf(" %3i ", status);
check_status(naibrd_TTL_GetStatus(cardIndex, module, chan, NAI_TTL_STATUS_HI_LO_TRANS_LATCHED, &status));
printf(" %3i ", status);
printf("\n\n");
return NAI_ERROR_UNKNOWN;
}