DIF PWM
Edit this on GitLab
DIF PWM
Explanation
About the Sample Application Code
This sample application code is provided by North Atlantic Industries (NAI) for interacting with their embedded function modules using their Software Support Kit (SSK). The code aims to demonstrate how to configure and operate a module in PWM (Pulse Width Modulation) mode. Below is an explanation and walkthrough of the important components and functionalities within the application.
Key Components of the Code
-
Included Headers:
-
<stdio.h>,<stdlib.h>,<string.h>,<time.h>,<ctype.h>: Standard C libraries for input/output, memory management, string manipulation, time functions, and character handling. -
naiapp_boardaccess_menu.h,naiapp_boardaccess_query.h,naiapp_boardaccess_access.h,naiapp_boardaccess_display.h,naiapp_boardaccess_utils.h: NAI’s header files for board access, querying, menu handling, and utility functions. -
nai.h,naibrd.h: Core NAI library headers for interacting with the embedded modules. -
naibrd_dif.h: Header for accessing Discrete I/O Function (DIF) module specific functions. -
nai_ether_adv.h: Header for advanced Ethernet functions.
-
-
Constants and Enumerations:
-
CONFIG_FILE: Default configuration file name. -
DEF_DIF_CHANNEL: Default channel for DIF operations. -
dif_pwm_commands: Enumeration of all possible DIF PWM commands.
-
-
Function Prototypes:
-
Run_DIF_PWM(),Cfg_DIF_PWM_Channel(),Display_DIF_PWM_ChannelCfg(), and other functions: Prototypes for functions handling various aspects of the DIF PWM configuration and operation.
-
-
Command Table (
DIF_PWM_MenuCmds):-
An array of structures mapping command strings to their respective functions for handling various PWM configurations like Mode, Period, Pulsewidth, etc.
-
*Main Function *
The entry point of the application:
int32_t main(void) {
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) {
stop = naiapp_query_CardIndex(naiapp_GetBoardCnt(), 0, &cardIndex);
if (stop != TRUE) {
check_status(naibrd_GetModuleCount(cardIndex, &moduleCnt));
stop = naiapp_query_ModuleNumber(moduleCnt, 1, &module);
if (stop != TRUE) {
moduleID = naibrd_GetModuleID(cardIndex, module);
if ((moduleID != 0)) {
Run_DIF_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;
}-
Initialization: The application is initialized with a default configuration file.
-
Main Loop: The loop prompts the user to select a card and module, retrieves the module ID and calls
Run_DIF_PWM()if the module is valid. -
Exit Handling: The loop can be exited with a user input, and the application waits for an 'Enter' key press to close.
Core Functions Explained
-
Run_DIF_PWM() -
Prompts the user for the card, module, and channel, then configures the channel with
Cfg_DIF_PWM_Channel()if it’s a valid DIF module. -
Cfg_DIF_PWM_Channel() -
Displays the current DIF channel configuration and processes user commands to configure various PWM settings using a command menu system.
-
Display_DIF_PWM_ChannelCfg() -
Retrieves and displays the current PWM configuration of a specified channel, including I/O format, output state, input state, and operational mode.
Configuration and Command Functions
-
Configure_DIF_PWM_Mode() -
Allows the user to set the PWM mode (Continuous, Burst, or Basic Input) for a selected channel.
-
Configure_DIF_PWM_Period()/Configure_DIF_PWM_Pulsewidth() -
Prompts the user to set the period and pulsewidth for the PWM signal.
-
Configure_DIF_PWM_Burstcount() -
Allows the user to set the number of pulses to issue in burst mode.
-
Configure_DIF_PWM_Polarity() -
Sets the polarity of the PWM signal (Positive or Negative).
-
Display_DIF_PWM_Configuration() -
Displays the current PWM settings such as period, pulsewidth, burst count, and polarity.
-
Display_DIF_Status() -
Retrieves and displays the status of the DIF, including bit latch and transition states.
Conclusion
This sample application demonstrates how to configure and operate NAI’s embedded function modules in PWM mode using their SSK. It includes comprehensive functionalities for querying and setting up the PWM parameters and provides a user-friendly command-line interface for interacting with the DIF module.
#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_PWM.txt";
/* Function prototypes */
static void Run_DIF_PWM(int32_t cardIndex, int32_t module, int32_t ModuleID);
static void Cfg_DIF_PWM_Channel(int32_t cardIndex, int32_t module, uint32_t ModuleID, int32_t MaxChannel);
static void Display_DIF_PWM_ChannelCfg(int32_t cardIndex, int32_t module, int32_t chan, uint32_t ModuleID);
static nai_status_t Display_DIF_PWM_Configuration(int32_t paramCount, int32_t* p_params);
static nai_status_t Display_DIF_Status(int32_t paramCount, int32_t* p_params);
static nai_status_t Configure_DIF_PWM_Mode(int32_t paramCount, int32_t* p_params);
static nai_status_t Configure_DIF_PWM_Period(int32_t paramCount, int32_t* p_params);
static nai_status_t Configure_DIF_PWM_Pulsewidth(int32_t paramCount, int32_t* p_params);
static nai_status_t Configure_DIF_PWM_Burstcount(int32_t paramCount, int32_t* p_params);
static nai_status_t Configure_DIF_PWM_Polarity(int32_t paramCount, int32_t* p_params);
static const int32_t DEF_DIF_CHANNEL = 1;
/****** Command Table *******/
enum dif_pwm_commands
{
DIF_PWM_CMD_MODE,
DIF_PWM_CMD_PERIOD,
DIF_PWM_CMD_PULSEWIDTH,
DIF_PWM_CMD_BURSTCOUNT,
DIF_PWM_CMD_POLARITY,
DIF_PWM_CMD_PWM_CFG,
DIF_PWM_CMD_PWM_START,
DIF_PWM_CMD_PWM_STOP,
DIF_PWM_CMD_PWM_DEMO,
DIF_PWM_CMD_PWM_INITIAL,
DIF_PWM_CMD_STATUS,
DIF_PWM_CMD_PWM_BURST,
DIF_PWM_CMD_PWM_CONT,
DIF_PWM_CMD_COUNT
};
/****** Command Tables *******/
naiapp_cmdtbl_params_t DIF_PWM_MenuCmds[] = {
{"Mode", " DIF Select PWM Mode", DIF_PWM_CMD_MODE, Configure_DIF_PWM_Mode},
{"Period", " DIF Set PWM Period", DIF_PWM_CMD_PERIOD, Configure_DIF_PWM_Period},
{"Width", " DIF Set PWM Pulsewidth", DIF_PWM_CMD_PULSEWIDTH, Configure_DIF_PWM_Pulsewidth},
{"Count", " DIF Set PWM burst count", DIF_PWM_CMD_BURSTCOUNT, Configure_DIF_PWM_Burstcount},
{"POlarity", " DIF Set PWM Polarity", DIF_PWM_CMD_POLARITY, Configure_DIF_PWM_Polarity},
{"PM", " DIF Display PWM configuration settings", DIF_PWM_CMD_PWM_CFG, Display_DIF_PWM_Configuration},
{"Trigger", " DIF Start PWM output", DIF_PWM_CMD_PWM_START, NULL},
{"Halt", " DIF Stop PWM output", DIF_PWM_CMD_PWM_STOP, NULL},
{"Demo", " DIF Demo PWM Settings", DIF_PWM_CMD_PWM_DEMO, NULL},
{"Reset", " DIF Reset All Channels to Initial Settings", DIF_PWM_CMD_PWM_INITIAL, NULL},
{"Stat", " DIF Display Status", DIF_PWM_CMD_STATUS, Display_DIF_Status},
{"SETBurst", " DIF Set all channels to PWM Burst", DIF_PWM_CMD_PWM_BURST, NULL},
{"SETCont", " DIF Set all channels to PWM Continuous", DIF_PWM_CMD_PWM_CONT, NULL},
};
/**************************************************************************************************************/
/**
<summary>
The purpose of the DIF_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 DIF routines.
- ClearDeviceCfg
- QuerySystemCfg
- DisplayDeviceCfg
- GetBoardSNModCfg
- SaveDeviceCfg
</summary>
*/
/**************************************************************************************************************/
#if defined (__VXWORKS__)
int32_t DIF_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_DIF_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_DIF_PWM prompts the user for the card, module and channel to use for the application and calls
Cfg_DIF_PWM_Channel if the card, module, channel is valid for as a discrete module.
</summary>
*/
/**************************************************************************************************************/
void Run_DIF_PWM(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_PWM_Channel(cardIndex, module, ModuleID, MaxChannel);
}
}
/**************************************************************************************************************/
/**
<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_PWM_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;
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));
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 ");
break;
case NAI_DIF_MODE_MEASURE_HIGH_TIME:
printf("NAI_DIF_MODE_MEASURE_HIGH_TIME ");
break;
case NAI_DIF_MODE_MEASURE_LOW_TIME:
printf("NAI_DIF_MODE_MEASURE_LOW_TIME ");
break;
case NAI_DIF_MODE_TIMESTAMP_RISING_EDGES:
printf("NAI_DIF_MODE_TIMESTAMP_RISING_EDGES ");
break;
case NAI_DIF_MODE_TIMESTAMP_FALLING_EDGES:
printf("NAI_DIF_MODE_TIMESTAMP_FALLING_EDGES ");
break;
case NAI_DIF_MODE_TIMESTAMP_ALL_EDGES:
printf("NAI_DIF_MODE_TIMESTAMP_ALL_EDGES ");
break;
case NAI_DIF_MODE_COUNT_RISING_EDGES:
printf("NAI_DIF_MODE_COUNT_RISING_EDGES ");
break;
case NAI_DIF_MODE_COUNT_FALLING_EDGES:
printf("NAI_DIF_MODE_COUNT_FALLING_EDGES ");
break;
case NAI_DIF_MODE_COUNT_ALL_EDGES:
printf("NAI_DIF_MODE_COUNT_ALL_EDGES ");
break;
case NAI_DIF_MODE_MEASURE_PERIOD_FROM_RISING_EDGE:
printf("NAI_DIF_MODE_MEASURE_PERIOD_FROM_RISING_EDGE ");
break;
case NAI_DIF_MODE_MEASURE_FREQUENCY:
printf("NAI_DIF_MODE_MEASURE_FREQUENCY ");
break;
case NAI_DIF_MODE_OUTPUT_PWM_FOREVER:
printf("NAI_DIF_MODE_OUTPUT_PWM_FOREVER ");
break;
case NAI_DIF_MODE_OUTPUT_PWM_CYCLE_NUM_TIMES:
printf("NAI_DIF_MODE_OUTPUT_PWM_CYCLE_NUM_TIMES ");
break;
case NAI_DIF_MODE_OUTPUT_PATTERN_RAM:
printf("NAI_DIF_MODE_OUTPUT_PATTERN_RAM ");
break;
default:
printf("Unknown ");
break;
}
}
/**************************************************************************************************************/
/**
<summary>
Cfg_DIF_PWM_Channel handles calling the Display_DIF_PWM_ChannelCfg routine to display the discrete channel configuration
and calling the routines associated with the user's menu commands.
</summary>
*/
/**************************************************************************************************************/
void Cfg_DIF_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 chan, defaultchan = 1;
int32_t cmd;
int32_t ch_loop;
float64_t time;
int8_t inputBuffer[80];
int32_t inputResponseCnt;
naiapp_AppParameters_t dif_params;
p_naiapp_AppParameters_t dif_pwm_params = &dif_params;
dif_pwm_params->cardIndex = cardIndex;
dif_pwm_params->module = module;
dif_pwm_params->modId = ModuleID;
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_pwm_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_PWM_FOREVER));
check_status(naibrd_DIF_SetIOFormat(cardIndex, module, chan, NAI_DIF_GEN5_IOFORMAT_OUTPUT));
naiapp_utils_LoadParamMenuCommands(DIF_PWM_CMD_COUNT, DIF_PWM_MenuCmds);
while (bContinue)
{
Display_DIF_PWM_ChannelCfg(cardIndex, module, chan, ModuleID);
naiapp_display_ParamMenuCommands((int8_t *)"DIF PWM 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_PWM_CMD_MODE:
case DIF_PWM_CMD_PERIOD:
case DIF_PWM_CMD_PULSEWIDTH:
case DIF_PWM_CMD_BURSTCOUNT:
case DIF_PWM_CMD_POLARITY:
case DIF_PWM_CMD_PWM_CFG:
case DIF_PWM_CMD_STATUS:
DIF_PWM_MenuCmds[cmd].func(APP_PARAM_COUNT, (int32_t*)dif_pwm_params);
break;
case DIF_PWM_CMD_PWM_START:
check_status(naibrd_DIF_StartPWM(cardIndex, module, chan));
break;
case DIF_PWM_CMD_PWM_STOP:
check_status(naibrd_DIF_StopPWM(cardIndex, module, chan));
printf("Mode reset to Input\n");
break;
case DIF_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_DIF_SetIOFormat(cardIndex, module, ch_loop, NAI_DIF_GEN5_IOFORMAT_OUTPUT));
status |= check_status(naibrd_DIF_SetPWM_Period(cardIndex, module, ch_loop, time));
time /= 10.0;
status |= check_status(naibrd_DIF_SetPWM_Pulsewidth(cardIndex, module, ch_loop, time));
status |= check_status(naibrd_DIF_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 DIF_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_DIF_SetOutputState(cardIndex, module, ch_loop, NAI_DIF_STATE_LO));
status |= check_status(naibrd_DIF_SetIOFormat(cardIndex, module, ch_loop, NAI_DIF_IOFORMAT_INPUT));
status |= check_status(naibrd_DIF_SetPWM_Pulsewidth(cardIndex, module, ch_loop, 16E-6));
status |= check_status(naibrd_DIF_SetPWM_BurstNum(cardIndex, module, ch_loop, 0));
status |= check_status(naibrd_DIF_SetOpMode( cardIndex, module, ch_loop, NAI_DIF_MODE_STD_INPUT_OUTPUT));
status |= check_status(naibrd_DIF_SetDebounceTime(cardIndex, module, ch_loop, 0.0));
status |= check_status(naibrd_DIF_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 DIF_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_DIF_SetOpMode( cardIndex, module, ch_loop, NAI_DIF_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 DIF_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_DIF_SetOpMode( cardIndex, module, ch_loop, NAI_DIF_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_DIF_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_DIF_PWM_Mode(int32_t paramCount, int32_t* p_params)
{
bool_t bQuit = FALSE;
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;
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_DIF_SetOpMode( cardIndex, module, chan, NAI_DIF_MODE_OUTPUT_PWM_FOREVER));
check_status(naibrd_DIF_SetIOFormat(cardIndex, module, chan, NAI_DIF_GEN5_IOFORMAT_OUTPUT));
}
else if ((toupper(inputBuffer[0]) == 'B'))
{
check_status(naibrd_DIF_SetOpMode( cardIndex, module, chan, NAI_DIF_MODE_OUTPUT_PWM_CYCLE_NUM_TIMES));
check_status(naibrd_DIF_SetIOFormat(cardIndex, module, chan, NAI_DIF_GEN5_IOFORMAT_OUTPUT));
}
else if ((toupper(inputBuffer[0]) == 'N'))
{
check_status(naibrd_DIF_SetOpMode( cardIndex, module, chan, NAI_DIF_MODE_STD_INPUT_OUTPUT));
check_status(naibrd_DIF_SetIOFormat(cardIndex, module, chan, NAI_DIF_IOFORMAT_INPUT));
}
}
}
return (bQuit) ? NAI_ERROR_UNKNOWN : NAI_SUCCESS;
}
/**************************************************************************************************************/
/**
<summary>
Configure_DIF_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_DIF_PWM_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;
int32_t chan = p_dif_params->channel;
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);
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_SetPWM_Period(cardIndex, module, chan, time));
}
}
}
return (bQuit) ? NAI_ERROR_UNKNOWN : NAI_SUCCESS;
}
/**************************************************************************************************************/
/**
<summary>
Configure_DIF_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_DIF_PWM_Pulsewidth(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;
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 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_DIF_GetTimebaseLSB(ModuleID);
switch (ModuleID)
{
case NAI_MODULE_ID_DF2:
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_DIF_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_DIF_PWM_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;
int32_t chan = p_dif_params->channel;
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_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_DIF_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_DIF_PWM_Polarity(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 == PWM Output Polarity Selection == \n Pos DIF PWM positive going pulse output \n Neg DIF PWM negative going pulse output \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]) == 'P'))
check_status(naibrd_DIF_SetPWM_Polarity( cardIndex, module, chan, (nai_dif_pwm_polarity_t) NAI_DIF_PWMPOLARITY_POS ));
else if ((toupper(inputBuffer[0]) == 'N'))
check_status(naibrd_DIF_SetPWM_Polarity( cardIndex, module, chan, (nai_dif_pwm_polarity_t) NAI_DIF_PWMPOLARITY_NEG ));
}
}
return (bQuit) ? NAI_ERROR_UNKNOWN : NAI_SUCCESS;
}
/**************************************************************************************************************/
/**
<summary>
Display_DIF_PWM_Configuration illustrate the methods to call in the naibrd library to retrieve the PWM
configuration settings.
</summary>
*/
/**************************************************************************************************************/
nai_status_t Display_DIF_PWM_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;
int32_t chan = p_dif_params->channel;
nai_dif_pwm_polarity_t polaritysetting;
float64_t period;
float64_t pulsewidth;
uint32_t burstnumber;
#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_DIF_GetPWM_Period(cardIndex, module, chan, &period));
printf(" %10.6f ", period);
check_status(naibrd_DIF_GetPWM_Pulsewidth(cardIndex, module, chan, &pulsewidth));
printf(" %10.6f ", pulsewidth);
check_status(naibrd_DIF_GetPWM_BurstNum(cardIndex, module, chan, &burstnumber));
printf(" 0x%08X ", burstnumber);
check_status(naibrd_DIF_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_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;
}