TTL PWM
Edit this on GitLab
TTL PWM
Explanation
About the Sample Application Code
This sample application code is written in C and is provided by North Atlantic Industries (NAI) for use with their Software Support Kit (SSK). This program is designed to interact with NAI’s embedded function modules, specifically focusing on configuring and running a TTL (Transistor-Transistor Logic) Pulse Width Modulation (PWM) operation.
Below is a detailed explanation of the components and functionality of the provided code:
Included Files - Standard Libraries - 'stdio.h', 'stdlib.h', 'string.h', 'time.h', 'ctype.h': These are standard C libraries providing basic input-output, memory management, string manipulation, time control, and character type functions respectively.
-
NAI Specific Header Files
-
'"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"'
-
'"nai.h"'
-
'"naibrd.h"'
-
'"functions/naibrd_ttl.h"'
-
'"advanced/nai_ether_adv.h"'
Definitions and Static Variables - Configuration File: 'static const int8_t *CONFIG_FILE = (int8_t *)"default_TTL_PWM.txt";' - Default Channel: 'static const int32_t DEF_TTL_CHANNEL = 1;'
Function Prototypes These prototypes declare the functions used for TTL PWM operations: - 'Run_TTL_PWM' - 'Cfg_TTL_PWM_Channel' - 'Display_TTL_PWM_ChannelCfg' - 'Display_TTL_PWM_Configuration' - 'Display_TTL_Status' - 'Configure_TTL_PWM_Mode' - 'Configure_TTL_PWM_Period' - 'Configure_TTL_PWM_Pulsewidth' - 'Configure_TTL_PWM_Burstcount' - 'Configure_TTL_PWM_Polarity'
Enumerations These enumerations define the commands used in the TTL PWM operations: '''c enum ttl_pwm_commands { TTL_PWM_CMD_MODE, TTL_PWM_CMD_PERIOD, TTL_PWM_CMD_PULSEWIDTH, TTL_PWM_CMD_BURSTCOUNT, TTL_PWM_CMD_POLARITY, TTL_PWM_CMD_PWM_CFG, TTL_PWM_CMD_PWM_START, TTL_PWM_CMD_PWM_STOP, TTL_PWM_CMD_PWM_DEMO, TTL_PWM_CMD_PWM_INITIAL, TTL_PWM_CMD_STATUS, TTL_PWM_CMD_PWM_BURST, TTL_PWM_CMD_PWM_CONT, TTL_PWM_CMD_COUNT }; '''
Command Table The 'TTL_PWM_MenuCmds' array lists each command’s name, description, corresponding enumeration, and the function handling the command: '''c naiapp_cmdtbl_params_t TTL_PWM_MenuCmds[] = { … }; '''
Main Function The main function ('int main(void)') initializes variables and handles the main loop of the application to query the user, configure the TTL PWM channels, and repeat or exit based on user input. The application uses multiple helper functions to query and set configuration parameters.
Helper Functions These functions handle specific configurations: - Run_TTL_PWM: Prompts the user for card, module, and channel, and validates for TTL modules. - Cfg_TTL_PWM_Channel: Displays the channel configuration and handles menu commands. - Display_TTL_PWM_ChannelCfg: Retrieves and displays the current configuration of TTL channels. - Display_TTL_PWM_Configuration: Shows detailed PWM settings such as period, pulse width, burst count, and polarity. - Display_TTL_Status: Retrieves and shows the status of TTL channels. - Configure Functions: Functions like 'Configure_TTL_PWM_Mode', 'Configure_TTL_PWM_Period', 'Configure_TTL_PWM_Pulsewidth', 'Configure_TTL_PWM_Burstcount', and 'Configure_TTL_PWM_Polarity' handle setting individual TTL PWM parameters based on user input.
Summary This sample code demonstrates how to interact with the NAI function modules, particularly for configuring and running TTL PWM operations. It covers querying hardware configuration, setting various PWM parameters, and displaying operational statuses. The code provides an extensive command menu for users to make configuration changes interactively.
#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_PWM.txt";
/* Function prototypes */
static void Run_TTL_PWM(int32_t cardIndex, int32_t module, int32_t ModuleID);
static void Cfg_TTL_PWM_Channel(int32_t cardIndex, int32_t module, uint32_t ModuleID, int32_t MaxChannel);
static void Display_TTL_PWM_ChannelCfg(int32_t cardIndex, int32_t module, int32_t chan, uint32_t ModuleID);
static nai_status_t Display_TTL_PWM_Configuration(int32_t paramCount, int32_t* p_params);
static nai_status_t Display_TTL_Status(int32_t paramCount, int32_t* p_params);
static nai_status_t Configure_TTL_PWM_Mode(int32_t paramCount, int32_t* p_params);
static nai_status_t Configure_TTL_PWM_Period(int32_t paramCount, int32_t* p_params);
static nai_status_t Configure_TTL_PWM_Pulsewidth(int32_t paramCount, int32_t* p_params);
static nai_status_t Configure_TTL_PWM_Burstcount(int32_t paramCount, int32_t* p_params);
static nai_status_t Configure_TTL_PWM_Polarity(int32_t paramCount, int32_t* p_params);
static const int32_t DEF_TTL_CHANNEL = 1;
/****** Command Table *******/
enum ttl_pwm_commands
{
TTL_PWM_CMD_MODE,
TTL_PWM_CMD_PERIOD,
TTL_PWM_CMD_PULSEWIDTH,
TTL_PWM_CMD_BURSTCOUNT,
TTL_PWM_CMD_POLARITY,
TTL_PWM_CMD_PWM_CFG,
TTL_PWM_CMD_PWM_START,
TTL_PWM_CMD_PWM_STOP,
TTL_PWM_CMD_PWM_DEMO,
TTL_PWM_CMD_PWM_INITIAL,
TTL_PWM_CMD_STATUS,
TTL_PWM_CMD_PWM_BURST,
TTL_PWM_CMD_PWM_CONT,
TTL_PWM_CMD_COUNT
};
/****** Command Tables *******/
naiapp_cmdtbl_params_t TTL_PWM_MenuCmds[] = {
{"Mode", " TTL Select PWM Mode", TTL_PWM_CMD_MODE, Configure_TTL_PWM_Mode},
{"Period", " TTL Set PWM Period", TTL_PWM_CMD_PERIOD, Configure_TTL_PWM_Period},
{"Width", " TTL Set PWM Pulsewidth", TTL_PWM_CMD_PULSEWIDTH, Configure_TTL_PWM_Pulsewidth},
{"Count", " TTL Set PWM burst count", TTL_PWM_CMD_BURSTCOUNT, Configure_TTL_PWM_Burstcount},
{"POlarity", " TTL Set PWM Polarity", TTL_PWM_CMD_POLARITY, Configure_TTL_PWM_Polarity},
{"PM", " TTL Display PWM configuration settings", TTL_PWM_CMD_PWM_CFG, Display_TTL_PWM_Configuration},
{"Trigger", " TTL Start PWM output", TTL_PWM_CMD_PWM_START, NULL},
{"Halt", " TTL Stop PWM output", TTL_PWM_CMD_PWM_STOP, NULL},
{"Demo", " TTL Demo PWM Settings", TTL_PWM_CMD_PWM_DEMO, NULL},
{"Reset", " TTL Reset All Channels to Initial Settings", TTL_PWM_CMD_PWM_INITIAL, NULL},
{"Stat", " TTL Display Status", TTL_PWM_CMD_STATUS, Display_TTL_Status},
{"SETBurst", " TTL Set all channels to PWM Burst", TTL_PWM_CMD_PWM_BURST, NULL},
{"SETCont", " TTL Set all channels to PWM Continuous", TTL_PWM_CMD_PWM_CONT, NULL},
};
/**************************************************************************************************************/
/**
<summary>
The purpose of the TTL_PWM is to illustrate the methods to call in the naibrd library to perform configuration
setup for output in PWM operation mode. Pulse period, pulse width, pulse polarity settings are 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_PWM(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_PWM(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_PWM prompts the user for the card, module and channel to use for the application and calls
Cfg_TTL_PWM_Channel if the card, module, channel is valid for as a discrete module.
</summary>
*/
/**************************************************************************************************************/
void Run_TTL_PWM(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_PWM_Channel(cardIndex, module, ModuleID, MaxChannel);
}
}
/**************************************************************************************************************/
/**
<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_PWM_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;
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));
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_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;
}
}
/**************************************************************************************************************/
/**
<summary>
Cfg_TTL_PWM_Channel handles calling the Display_TTL_PWM_ChannelCfg routine to display the discrete channel configuration
and calling the routines associated with the user's menu commands.
</summary>
*/
/**************************************************************************************************************/
void Cfg_TTL_PWM_Channel(int32_t cardIndex, int32_t module, uint32_t ModuleID, int32_t MaxChannel)
{
nai_status_t status = (nai_status_t)0;
bool_t bQuit = FALSE;
bool_t bContinue = TRUE;
bool_t bCmdFound = FALSE;
int32_t defaultchan = 1;
int32_t cmd;
int32_t ch_loop;
float64_t time;
int8_t inputBuffer[80];
int32_t inputResponseCnt;
naiapp_AppParameters_t ttl_params;
p_naiapp_AppParameters_t ttl_pwm_params = &ttl_params;
ttl_pwm_params->cardIndex = cardIndex;
ttl_pwm_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_pwm_params->channel);
naiapp_utils_LoadParamMenuCommands(TTL_PWM_CMD_COUNT, TTL_PWM_MenuCmds);
while (bContinue)
{
Display_TTL_PWM_ChannelCfg(cardIndex, module, ttl_pwm_params->channel, ModuleID);
naiapp_display_ParamMenuCommands((int8_t *)"TTL PWM 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_PWM_CMD_MODE:
case TTL_PWM_CMD_PERIOD:
case TTL_PWM_CMD_PULSEWIDTH:
case TTL_PWM_CMD_BURSTCOUNT:
case TTL_PWM_CMD_POLARITY:
case TTL_PWM_CMD_PWM_CFG:
case TTL_PWM_CMD_STATUS:
TTL_PWM_MenuCmds[cmd].func(APP_PARAM_COUNT, (int32_t*)ttl_pwm_params);
break;
case TTL_PWM_CMD_PWM_START:
/* check_status(naibrd_TTL_StartPWM(cardIndex, module, chan)); */
check_status(naibrd_TTL_SetEnhanceTriggerEnable(cardIndex, module, ttl_pwm_params->channel, NAI_TTL_OUTPUT_ENHANCED_OP_ENABLE));
break;
case TTL_PWM_CMD_PWM_STOP:
/* check_status(naibrd_TTL_StopPWM(cardIndex, module, chan)); */
check_status(naibrd_TTL_SetEnhanceTriggerEnable(cardIndex, module, ttl_pwm_params->channel, NAI_TTL_ENHANCED_OP_DISABLE));
break;
case TTL_PWM_CMD_PWM_DEMO:
{
status = NAI_SUCCESS;
printf("Set up all channels in incrementing period/pulsewidths and burstcounts? \n Enter Yes to confirm: ");
bQuit = naiapp_query_ForQuitResponse(sizeof(inputBuffer), NAI_QUIT_CHAR, inputBuffer, &inputResponseCnt);
if (!bQuit)
{
if (inputResponseCnt > 0)
{
if ((toupper(inputBuffer[0]) == 'Y'))
{
for (ch_loop = 1; ch_loop <= MaxChannel; ch_loop++)
{
time = ch_loop;
status |= check_status(naibrd_TTL_SetPWM_Period(cardIndex, module, ch_loop, time));
time /= 10.0;
status |= check_status(naibrd_TTL_SetPWM_Pulsewidth(cardIndex, module, ch_loop, time));
status |= check_status(naibrd_TTL_SetPWM_BurstNum(cardIndex, module, ch_loop, ch_loop));
}
if (status == NAI_SUCCESS)
printf("\n PWM channel configuration initialized for all channels. \n Set PWM Mode as needed. ");
else
printf("\n Configuration not completed successfully. \n");
}
}
}
}
break;
case TTL_PWM_CMD_PWM_INITIAL:
{
status = NAI_SUCCESS;
printf("Reset all channels to initial configuration? \n Enter Yes to confirm: ");
bQuit = naiapp_query_ForQuitResponse(sizeof(inputBuffer), NAI_QUIT_CHAR, inputBuffer, &inputResponseCnt);
if (!bQuit)
{
if (inputResponseCnt > 0)
{
if ((toupper(inputBuffer[0]) == 'Y'))
{
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_IOFORMAT_INPUT));
status |= check_status(naibrd_TTL_SetPWM_Pulsewidth(cardIndex, module, ch_loop, 16E-6));
status |= check_status(naibrd_TTL_SetPWM_BurstNum(cardIndex, module, ch_loop, 0));
status |= check_status(naibrd_TTL_SetOpMode(cardIndex, module, ch_loop, NAI_TTL_MODE_STD_INPUT_OUTPUT));
status |= check_status(naibrd_TTL_SetDebounceTime(cardIndex, module, ch_loop, 0.0));
status |= check_status(naibrd_TTL_GetDebounceTime(cardIndex, module, ch_loop, &time));
if (time > 1E-10)
status++;
}
if (status == NAI_SUCCESS)
printf("\n PWM channel configuration initialized for all channels. \n");
else
printf("\n Initialization not completed successfully. \n");
}
}
}
}
break;
case TTL_PWM_CMD_PWM_BURST:
{
printf("Reset all channels to PWM burst mode? \n Enter Yes to confirm: ");
bQuit = naiapp_query_ForQuitResponse(sizeof(inputBuffer), NAI_QUIT_CHAR, inputBuffer, &inputResponseCnt);
if (!bQuit)
{
if (inputResponseCnt > 0)
{
if ((toupper(inputBuffer[0]) == 'Y'))
{
for (ch_loop = 1; ch_loop <= MaxChannel; ch_loop++)
{
status |= check_status(naibrd_TTL_SetOpMode(cardIndex, module, ch_loop, NAI_TTL_MODE_OUTPUT_PWM_CYCLE_NUM_TIMES));
}
if (status == NAI_SUCCESS)
printf("\n PWM channel configuration set for PWM Burst mode for all channels. \n");
else
printf("\n Initialization not completed successfully. \n");
}
}
}
}
break;
case TTL_PWM_CMD_PWM_CONT:
{
printf("Reset all channels to PWM continuous mode? \n Enter Yes to confirm: ");
bQuit = naiapp_query_ForQuitResponse(sizeof(inputBuffer), NAI_QUIT_CHAR, inputBuffer, &inputResponseCnt);
if (!bQuit)
{
if (inputResponseCnt > 0)
{
if ((toupper(inputBuffer[0]) == 'Y'))
{
for (ch_loop = 1; ch_loop <= MaxChannel; ch_loop++)
{
status |= check_status(naibrd_TTL_SetOpMode(cardIndex, module, ch_loop, NAI_TTL_MODE_OUTPUT_PWM_FOREVER));
}
if (status == NAI_SUCCESS)
printf("\n PWM channel configuration set for PWM Burst mode for all channels. \n");
else
printf("\n Initialization not completed successfully. \n");
}
}
}
}
break;
default:
printf("Invalid command entered\n");
break;
}
}
else
printf("Invalid command entered\n");
}
}
else
bContinue = FALSE;
}
}
}
/**************************************************************************************************************/
/**
<summary>
Configure_TTL_PWM_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>
*/
/**************************************************************************************************************/
nai_status_t Configure_TTL_PWM_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;
int32_t chan = p_ttl_params->channel;
int8_t inputBuffer[80];
int32_t inputResponseCnt;
#if defined (WIN32)
UNREFERENCED_PARAMETER(paramCount);
#endif
printf("\n == PWM Mode Selection == \n C Continuous PWM mode \n Burst PWM Burst mode \n None Basic input mode \n\n Type DSW 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_TTL_SetIOFormat(cardIndex, module, chan, NAI_TTL_IOFORMAT_OUTPUT));
check_status(naibrd_TTL_SetOpMode(cardIndex, module, chan, NAI_TTL_MODE_OUTPUT_PWM_FOREVER));
}
else if ((toupper(inputBuffer[0]) == 'B'))
{
check_status(naibrd_TTL_SetIOFormat(cardIndex, module, chan, NAI_TTL_IOFORMAT_OUTPUT));
check_status(naibrd_TTL_SetOpMode(cardIndex, module, chan, NAI_TTL_MODE_OUTPUT_PWM_CYCLE_NUM_TIMES));
}
else if ((toupper(inputBuffer[0]) == 'N'))
{
check_status(naibrd_TTL_SetOpMode(cardIndex, module, chan, NAI_TTL_MODE_STD_INPUT_OUTPUT));
}
}
}
return (bQuit) ? NAI_ERROR_UNKNOWN : NAI_SUCCESS;
}
/**************************************************************************************************************/
/**
<summary>
Configure_TTL_PWM_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_PWM_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;
int32_t chan = p_ttl_params->channel;
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_SetPWM_Period(cardIndex, module, chan, time));
}
}
}
return (bQuit) ? NAI_ERROR_UNKNOWN : NAI_SUCCESS;
}
/**************************************************************************************************************/
/**
<summary>
Configure_TTL_PWM_Pulsewidth handles the user request to configure the time values for pulsewidth on the selected
channel and calls the method in the naibrd library to set the width.
</summary>
*/
/**************************************************************************************************************/
nai_status_t Configure_TTL_PWM_Pulsewidth(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;
int32_t chan = p_ttl_params->channel;
int8_t inputBuffer[80];
int32_t inputResponseCnt;
#if defined (WIN32)
UNREFERENCED_PARAMETER(paramCount);
#endif
printf("\nEnter the desired pulsewidth in milliseconds: ");
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);
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)(0x1u * lsb);
max = (float64_t)(0xFFFFFFFE * 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_TTL_SetPWM_Pulsewidth(cardIndex, module, chan, 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>
*/
/**************************************************************************************************************/
nai_status_t Configure_TTL_PWM_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;
int32_t chan = p_ttl_params->channel;
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_SetPWM_BurstNum(cardIndex, module, chan, burstcount));
break;
default:
printf("Unsupported function for this module.\n");
break;
}
}
}
return (bQuit) ? NAI_ERROR_UNKNOWN : NAI_SUCCESS;
}
/**************************************************************************************************************/
/**
<summary>
Configure_TTL_PWM_Polarity handles the user request to select the PWM output polarity for the selected channel
and calls the method in the naibrd library for the setting.
</summary>
*/
/**************************************************************************************************************/
nai_status_t Configure_TTL_PWM_Polarity(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;
int32_t chan = p_ttl_params->channel;
int8_t inputBuffer[80];
int32_t inputResponseCnt;
#if defined (WIN32)
UNREFERENCED_PARAMETER(paramCount);
#endif
printf("\n == PWM Output Polarity Selection == \n Pos TTL PWM positive going pulse output \n Neg TTL PWM negative going pulse output \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]) == 'P'))
check_status(naibrd_TTL_SetPWM_Polarity(cardIndex, module, chan, (nai_ttl_pwm_polarity_t)NAI_TTL_PWMPOLARITY_POS));
else if ((toupper(inputBuffer[0]) == 'N'))
check_status(naibrd_TTL_SetPWM_Polarity(cardIndex, module, chan, (nai_ttl_pwm_polarity_t)NAI_TTL_PWMPOLARITY_NEG));
}
}
return (bQuit) ? NAI_ERROR_UNKNOWN : NAI_SUCCESS;
}
/**************************************************************************************************************/
/**
<summary>
Display_TTL_PWM_Configuration illustrate the methods to call in the naibrd library to retrieve the PWM
configuration settings.
</summary>
*/
/**************************************************************************************************************/
nai_status_t Display_TTL_PWM_Configuration(int32_t paramCount, int32_t* p_params)
{
nai_ttl_pwm_polarity_t polaritysetting;
float64_t period;
float64_t pulsewidth;
uint32_t burstnumber;
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 configuration settings:
PWM period", (Value read back in milliseconds)
PWM pulsewidth", (Value read back in milliseconds)
PWM burst count (Number of pulses issued upon trigger in burst mode)
PWM polarity", 0 = positive going pulsewidth, 1 = negative going
*/
printf("\n");
printf(" -------------PWM Configuration Settings---------------------------- \n");
printf(" Period (ms) Pulsewidth (ms) Burst Cnt Polarity \n");
printf(" -------------- ---------------- ----------- ----------- \n");
check_status(naibrd_TTL_GetPWM_Period(cardIndex, module, chan, &period));
printf(" %10.6f ", period);
check_status(naibrd_TTL_GetPWM_Pulsewidth(cardIndex, module, chan, &pulsewidth));
printf(" %10.6f ", pulsewidth);
check_status(naibrd_TTL_GetPWM_BurstNum(cardIndex, module, chan, &burstnumber));
printf(" 0x%08X ", burstnumber);
check_status(naibrd_TTL_GetPWM_Polarity(cardIndex, module, chan, &polaritysetting));
if (polaritysetting == 0)
printf(" POS ");
else
printf(" NEG ");
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;
}