DT PWM
Edit this on GitLab
DT PWM
Explanation
This sample C application code from North Atlantic Industries (NAI) is designed to configure and manage the PWM (Pulse Width Modulation) settings on their embedded function modules via their Software Support Kit (SSK). The code includes functions for querying user input, configuring various PWM settings, and displaying the current configuration status on the modules.
File Inclusions
-
Standard Libraries:
-
stdio.h,stdlib.h,string.h,time.h,ctype.h: Standard C libraries for input/output, memory management, string manipulation, time operations, and character handling respectively.
-
-
NAI-specific Libraries:
-
"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": Libraries for accessing and displaying configurations, querying system states, and utility functions. -
"nai.h","naibrd.h","functions/naibrd_dt.h","advanced/nai_ether_adv.h": Libraries providing main API functions and advanced network functionalities.
-
Constants and Function Prototypes
-
CONFIG_FILE: Pointer to the default configuration file name ("default_DT_PWM.txt").
Function Prototypes:
- Run_DT_PWM: Primary function for handling PWM configuration.
- Cfg_DT_PWM_Channel: Handles PWM channel configurations.
- Various functions for displaying and configuring PWM settings such as Display_DT_PWM_ChannelCfg, Display_DT_Status, Configure_DT_PWM_Mode, etc.
Enumerations and Menu Commands
-
Enum
dt_pwm_commands: Defines command identifiers for various PWM operations like setting mode, period, pulse width, burst count, etc. -
Array
DT_PWM_MenuCmds: Contains command names, descriptions, and pointers to the corresponding configuration functions.
Main Application Flow
Main Function:
- Conditional Compilation: The entry-point is DT_PWM for VxWorks RTOS and main for other environments.
- Initializes variables for card and module configuration.
- Utilizes naiapp_RunBoardMenu to initialize configuration from the config file.
- Enters a loop to query user inputs for card index and module number.
- Calls Run_DT_PWM to configure the PWM settings if the module ID is valid.
- Displays options for user to quit or restart the application.
PWM Configuration Functions
Run_DT_PWM:
- Retrieves the maximum channel for the module using naibrd_DT_GetChannelCount.
- Calls Cfg_DT_PWM_Channel to handle specific channel configurations if valid.
Cfg_DT_PWM_Channel:
- Queries user for a channel number and loads available commands.
- Continuously displays the channel’s current PWM configuration using Display_DT_PWM_ChannelCfg.
- Handles user commands like starting/stopping PWM, setting configurations via a switch-case structure.
Display and Configuration Functions
Display_DT_PWM_ChannelCfg:
- Retrieves and displays the current configuration of a PWM channel, including I/O format, output state, input state, basic/enhanced mode, and operation mode.
Display_DT_PWM_Configuration:
- Fetches and prints the PWM configuration settings such as period, pulse width, burst count, polarity, and master channel.
Display_DT_Status:
- Displays the status of a discrete module including BIT status, transitions, and overcurrent information.
Configuration Functions:
Functions like Configure_DT_PWM_Mode, Configure_DT_PWM_Polarity, Configure_DT_PWM_Period, etc. handle user requests, query the relevant input, and call the corresponding naibrd library functions to update settings.
Example Configuration Procedure:
-
Setup the Environment:
-
Include necessary header files.
-
Configure menu commands.
-
-
Run Application:
-
Query user for card and module selection.
-
Display current configuration.
-
Handle user commands to modify PWM settings.
-
-
Modify Settings:
-
Use provided commands to set PWM mode, period, pulse width, and other parameters.
-
Update configurations and display status as requested.
-
Summary:
This application guides users through setting and managing PWM configurations on NAI boards, illustrating how to use the naibrd library for interacting with embedded hardware. Through specialized functions and detailed status displays, the application provides comprehensive control over PWM settings on discrete function modules.
#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_dt.h"
#include "advanced/nai_ether_adv.h"
static const int8_t *CONFIG_FILE = (const int8_t *)"default_DT_PWM.txt";
/* Function prototypes */
static void Run_DT_PWM(int32_t cardIndex, int32_t module, int32_t ModuleID);
static void Cfg_DT_PWM_Channel(int32_t cardIndex, int32_t module, uint32_t ModuleID, int32_t MaxChannel);
static void Display_DT_PWM_ChannelCfg(int32_t cardIndex, int32_t module, int32_t chan, uint32_t ModuleID);
static nai_status_t Display_DT_PWM_Configuration(int32_t paramCount, int32_t* p_params);
static nai_status_t Display_DT_Status(int32_t paramCount, int32_t* p_params);
static nai_status_t Configure_DT_PWM_Mode(int32_t paramCount, int32_t* p_params);
static nai_status_t Configure_DT_PWM_Polarity(int32_t paramCount, int32_t* p_params);
static nai_status_t Configure_DT_PWM_Period(int32_t paramCount, int32_t* p_params);
static nai_status_t Configure_DT_PWM_Pulsewidth(int32_t paramCount, int32_t* p_params);
static nai_status_t Configure_DT_PWM_Burstcount(int32_t paramCount, int32_t* p_params);
static nai_status_t Configure_DT_PWM_Master(int32_t paramCount, int32_t* p_params);
static const int32_t DEF_DT_CHANNEL = 1;
/****** Command Table *******/
enum dt_pwm_commands
{
DT_PWM_CMD_MODE,
DT_PWM_CMD_PERIOD,
DT_PWM_CMD_PULSEWIDTH,
DT_PWM_CMD_BURSTCOUNT,
DT_PWM_CMD_POLARITY,
DT_PWM_CMD_MASTER,
DT_PWM_CMD_PWM_CFG,
DT_PWM_CMD_PWM_START,
DT_PWM_CMD_PWM_STOP,
DT_PWM_CMD_PWM_DEMO,
DT_PWM_CMD_PWM_INITIAL,
DT_PWM_CMD_STATUS,
DT_PWM_CMD_PWM_BURST,
DT_PWM_CMD_PWM_CONT,
DT_PWM_CMD_COUNT
};
/****** Command Tables *******/
naiapp_cmdtbl_params_t DT_PWM_MenuCmds[] = {
{"Mode", " DT Select PWM Mode", DT_PWM_CMD_MODE, Configure_DT_PWM_Mode},
{"Period", " DT Set PWM Period", DT_PWM_CMD_PERIOD, Configure_DT_PWM_Period},
{"Width", " DT Set PWM Pulsewidth", DT_PWM_CMD_PULSEWIDTH, Configure_DT_PWM_Pulsewidth},
{"Count", " DT Set PWM Burst count", DT_PWM_CMD_BURSTCOUNT, Configure_DT_PWM_Burstcount},
{"POlarity", " DT Set PWM Polarity", DT_PWM_CMD_POLARITY, Configure_DT_PWM_Polarity},
{"MAster", " DT Set Master channel", DT_PWM_CMD_MASTER, Configure_DT_PWM_Master},
{"PM", " DT Display PWM configuration settings", DT_PWM_CMD_PWM_CFG, Display_DT_PWM_Configuration},
{"Trigger", " TTL Start PWM output", DT_PWM_CMD_PWM_START, NULL},
{"Halt", " TTL Stop PWM output", DT_PWM_CMD_PWM_STOP, NULL},
{"Demo", " DT Demo PWM Settings", DT_PWM_CMD_PWM_DEMO, NULL},
{"Reset", " DT Reset All Channels to Initial Settings",DT_PWM_CMD_PWM_INITIAL, NULL},
{"Stat", " DT Display Status", DT_PWM_CMD_STATUS, Display_DT_Status},
{"SETBurst", " DT Set all channels to PWM Burst", DT_PWM_CMD_PWM_BURST, NULL},
{"SETCont", " DT Set all channels to PWM Continuous", DT_PWM_CMD_PWM_CONT, NULL},
};
/**************************************************************************************************************/
/**
<summary>
The purpose of the DT_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 DT routines.
- ClearDeviceCfg
- QuerySystemCfg
- DisplayDeviceCfg
- GetBoardSNModCfg
- SaveDeviceCfg
</summary>
*/
/**************************************************************************************************************/
#if defined (__VXWORKS__)
int32_t DT_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_DT_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_DT_PWM prompts the user for the card, module and channel to use for the application and calls
Cfg_DT_PWM_Channel if the card, module, channel is valid for as a discrete module.
</summary>
*/
/**************************************************************************************************************/
static void Run_DT_PWM(int32_t cardIndex, int32_t module, int32_t ModuleID)
{
int32_t MaxChannel;
MaxChannel = naibrd_DT_GetChannelCount(ModuleID);
if (MaxChannel == 0)
{
printf(" *** Module selection not recognized as DSW module. ***\n\n");
}
else
{
Cfg_DT_PWM_Channel(cardIndex, module, ModuleID, MaxChannel);
}
}
/**************************************************************************************************************/
/**
<summary>
Cfg_DT_PWM_Channel handles calling the Display_DT_PWM_ChannelCfg routine to display the discrete channel configuration
and calling the routines associated with the user's menu commands.
</summary>
*/
/**************************************************************************************************************/
static void Cfg_DT_PWM_Channel(int32_t cardIndex, int32_t module, uint32_t ModuleID, int32_t MaxChannel)
{
nai_status_t status = 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 dt_params;
p_naiapp_AppParameters_t dt_pwm_params = &dt_params;
dt_pwm_params->cardIndex = cardIndex;
dt_pwm_params->module = module;
dt_pwm_params->modId = ModuleID;
while (bContinue)
{
printf(" \r\n\r\n");
printf("Channel selection \r\n");
printf("================= \r\n");
defaultchan = DEF_DT_CHANNEL;
bQuit = naiapp_query_ChannelNumber(MaxChannel, defaultchan, &chan);
naiapp_utils_LoadParamMenuCommands(DT_PWM_CMD_COUNT, DT_PWM_MenuCmds);
while (bContinue)
{
Display_DT_PWM_ChannelCfg(cardIndex, module, chan, ModuleID);
naiapp_display_ParamMenuCommands((int8_t *)"DT PWM Menu");
printf("\nType DT command or %c to return to module select menu: ", 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 DT_PWM_CMD_MODE:
case DT_PWM_CMD_PERIOD:
case DT_PWM_CMD_PULSEWIDTH:
case DT_PWM_CMD_BURSTCOUNT:
case DT_PWM_CMD_POLARITY:
case DT_PWM_CMD_MASTER:
case DT_PWM_CMD_PWM_CFG:
case DT_PWM_CMD_STATUS:
DT_PWM_MenuCmds[cmd].func(APP_PARAM_COUNT, (int32_t*)dt_pwm_params);
break;
case DT_PWM_CMD_PWM_START:
check_status(naibrd_DT_StartPWM(cardIndex, module, chan));
break;
case DT_PWM_CMD_PWM_STOP:
check_status(naibrd_DT_StopPWM(cardIndex, module, chan));
printf("Mode reset to Input\n");
break;
case DT_PWM_CMD_PWM_DEMO:
{
if ((ModuleID == NAI_MODULE_ID_KA) || (ModuleID == NAI_MODULE_ID_K6))
{
printf("PWM burst mode not supported for this module\n");
break;
}
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<=24; ch_loop++)
{
time = ch_loop;
status |= check_status(naibrd_DT_SetPWM_Period(cardIndex, module, ch_loop, time));
time /= 10.0;
status |= check_status(naibrd_DT_SetPWM_Pulsewidth(cardIndex, module, ch_loop, time));
status |= check_status(naibrd_DT_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 DT_PWM_CMD_PWM_INITIAL:
{
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<=24; ch_loop++)
{
status |= check_status(naibrd_DT_SetOutputState(cardIndex, module, ch_loop, NAI_DT_STATE_LO));
status |= check_status(naibrd_DT_SetIOFormat(cardIndex, module, ch_loop, NAI_DT_IOFORMAT_INPUT));
status |= check_status(naibrd_DT_SetPWM_Pulsewidth(cardIndex, module, ch_loop, 0.00361));
status |= check_status(naibrd_DT_SetPWM_BurstNum(cardIndex, module, ch_loop, 0));
status |= check_status(naibrd_DT_SetOpMode( cardIndex, module, ch_loop, NAI_DT_MODE_ENHANCED_INPUT));
status |= check_status(naibrd_DT_SetBasicOpModeEnable( cardIndex, module, ch_loop, NAI_DT_IOMODE_BASIC));
status |= check_status(naibrd_DT_SetDebounceTime(cardIndex, module, ch_loop, 0.0));
status |= check_status(naibrd_DT_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 DT_PWM_CMD_PWM_BURST:
{
if ((ModuleID == NAI_MODULE_ID_KA) || (ModuleID == NAI_MODULE_ID_K6))
{
printf("PWM burst mode not supported for this module\n");
break;
}
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<=24; ch_loop++)
{
status |= check_status(naibrd_DT_SetOpMode( cardIndex, module, ch_loop, NAI_DT_MODE_OUTPUT_PWM_CYCLE_NUM_TIMES));
status |= check_status(naibrd_DT_SetBasicOpModeEnable( cardIndex, module, ch_loop, NAI_DT_IOMODE_ENHANCED));
}
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 DT_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<=24; ch_loop++)
{
status |= check_status(naibrd_DT_SetOpMode( cardIndex, module, ch_loop, NAI_DT_MODE_OUTPUT_PWM_FOREVER));
status |= check_status(naibrd_DT_SetBasicOpModeEnable( cardIndex, module, ch_loop, NAI_DT_IOMODE_ENHANCED));
}
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>
Display_DT_PWM_ChannelCfg illustrate the methods to call in the naibrd library to retrieve the configuration states
for PWM operation.
</summary>
*/
/**************************************************************************************************************/
static void Display_DT_PWM_ChannelCfg(int32_t cardIndex, int32_t module, int32_t chan, uint32_t ModuleID)
{
uint32_t ioformat = 0;
nai_dt_state_t outputstate = 0;
nai_dt_state_t inputstate = 0;
nai_dt_state_t basicmode = 0;
nai_dt_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_DT_GetIOFormat(cardIndex, module, chan, &ioformat));
check_status(naibrd_DT_GetOutputState(cardIndex, module, chan, &outputstate));
check_status(naibrd_DT_GetInputState(cardIndex, module, chan, &inputstate));
check_status(naibrd_DT_GetBasicOpModeEnable(cardIndex, module, chan, &basicmode));
check_status(naibrd_DT_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 Basic / \n");
printf(" Format State State Enhanced Enhanced Mode Selection\n");
printf("--------- ------ ----------- -------- --------------------------------\n");
}
/*display configuration settings here- */
switch (ioformat)
{
case NAI_DT_IOFORMAT_INPUT:
printf(" Input ");
break;
case NAI_DT_IOFORMAT_OUTPUT_LOW:
printf(" Low Side "); /*may want add check for proper value depending on whether gen3 or gen5; for now, assume it correctly matches module*/
break;
case NAI_DT_IOFORMAT_OUTPUT_HIGH:
printf(" High Side"); /*may want add check for proper value depending on whether gen3 or gen5; for now, assume it correctly matches module*/
break;
case NAI_DT_IOFORMAT_OUTPUT_PUSHPULL:
printf(" Push/Pull"); /*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_DT_STATE_LO:
printf(" LOW Set ");
break;
case NAI_DT_STATE_HI:
printf(" HIGH Set ");
break;
default:
printf(" Unknown ");
break;
}
switch (inputstate)
{
case NAI_DT_STATE_LO:
printf(" LOW Input ");
break;
case NAI_DT_STATE_HI:
printf("HIGH Input ");
break;
default:
printf("Unknown ");
break;
}
switch (basicmode)
{
case NAI_DT_IOMODE_ENHANCED:
printf("Enhanced ");
break;
case NAI_DT_IOMODE_BASIC:
printf("Basic ");
break;
default:
printf("Unknown ");
break;
}
switch (opmode)
{
case NAI_DT_MODE_ENHANCED_INPUT:
printf("DT_MODE_ENHANCED_INPUT ");
break;
case NAI_DT_MODE_MEASURE_HIGH_TIME:
printf("DT_MODE_MEASURE_HIGH_TIME ");
break;
case NAI_DT_MODE_MEASURE_LOW_TIME:
printf("DT_MODE_MEASURE_LOW_TIME ");
break;
case NAI_DT_MODE_TIMESTAMP_RISING_EDGES:
printf("DT_MODE_TIMESTAMP_RISING_EDGES ");
break;
case NAI_DT_MODE_TIMESTAMP_FALLING_EDGES:
printf("DT_MODE_TIMESTAMP_FALLING_EDGES ");
break;
case NAI_DT_MODE_TIMESTAMP_ALL_EDGES:
printf("DT_MODE_TIMESTAMP_ALL_EDGES ");
break;
case NAI_DT_MODE_COUNT_RISING_EDGES:
printf("DT_MODE_COUNT_RISING_EDGES ");
break;
case NAI_DT_MODE_COUNT_FALLING_EDGES:
printf("DT_MODE_COUNT_FALLING_EDGES ");
break;
case NAI_DT_MODE_COUNT_ALL_EDGES:
printf("DT_MODE_COUNT_ALL_EDGES ");
break;
case NAI_DT_MODE_MEASURE_PERIOD_FROM_RISING_EDGE:
printf("DT_MODE_MEASURE_PERIOD_FROM_RISING_EDGE ");
break;
case NAI_DT_MODE_MEASURE_FREQUENCY:
printf("DT MODE Interval Counter ");
break;
case NAI_DT_MODE_OUTPUT_PWM_FOREVER:
printf("DT MODE PWM Continuous ");
break;
case NAI_DT_MODE_OUTPUT_PWM_CYCLE_NUM_TIMES:
printf("DT MODE PWM Burst ");
break;
case NAI_DT_MODE_OUTPUT_PATTERN_RAM:
printf("DT MODE PATTERN_RAM ");
break;
case NAI_DT_MODE_BASIC_INPUT:
printf("DT MODE BASIC_INPUT");
break;
case NAI_DT_MODE_BASIC_OUTPUT_LOWSIDE:
printf("DT MODE BASIC_OUTPUT_LOWSIDE");
break;
case NAI_DT_MODE_BASIC_OUTPUT_HIGHSIDE:
printf("DT MODE BASIC_OUTPUT_HIGHSIDE");
break;
case NAI_DT_MODE_BASIC_OUTPUT_PUSHPULL:
printf("DT MODE BASIC_OUTPUT_PUSHPULL");
break;
default:
printf("Unknown ");
break;
}
}
/**************************************************************************************************************/
/**
<summary>
Display_DT_PWM_Configuration illustrate the methods to call in the naibrd library to retrieve the PWM
configuration settings.
</summary>
*/
/**************************************************************************************************************/
static nai_status_t Display_DT_PWM_Configuration(int32_t paramCount, int32_t* p_params)
{
p_naiapp_AppParameters_t p_dt_params = (p_naiapp_AppParameters_t)p_params;
int32_t cardIndex = p_dt_params->cardIndex;
int32_t module = p_dt_params->module;
int32_t chan = p_dt_params->channel;
nai_dt_pwm_polarity_t polaritysetting;
float64_t period;
float64_t pulsewidth;
uint32_t burstnumber;
int32_t masterchannel;
#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 MasterChannel\n");
printf(" -------------- ---------------- ----------- ----------- ---------------\n");
check_status(naibrd_DT_GetPWM_Period(cardIndex, module, chan, &period));
printf(" %10.6f ", period);
check_status(naibrd_DT_GetPWM_Pulsewidth(cardIndex, module, chan, &pulsewidth));
printf(" %10.6f ", pulsewidth);
check_status(naibrd_DT_GetPWM_BurstNum(cardIndex, module, chan, &burstnumber));
printf(" 0x%08X ", burstnumber);
check_status(naibrd_DT_GetPWM_Polarity(cardIndex, module, chan, &polaritysetting));
if (polaritysetting==0)
printf(" POS ");
else
printf(" NEG ");
check_status(naibrd_DT_GetPWMMasterChannel(cardIndex, module, chan, &masterchannel));
printf(" %d ", masterchannel);
printf("\n\n");
return NAI_ERROR_UNKNOWN;
}
/**************************************************************************************************************/
/**
<summary>
Display_DT_Status illustrate the methods to call in the naibrd library to retrieve the status settings.
</summary>
*/
/**************************************************************************************************************/
static nai_status_t Display_DT_Status(int32_t paramCount, int32_t* p_params)
{
p_naiapp_AppParameters_t p_dt_params = (p_naiapp_AppParameters_t)p_params;
int32_t cardIndex = p_dt_params->cardIndex;
int32_t module = p_dt_params->module;
int32_t chan = p_dt_params->channel;
nai_dt_ioformat_t IOformat;
nai_dt_state_t state;
nai_status_bit_t status = 0;
uint32_t ModuleID;
uint32_t ModuleVer;
uint32_t ModuleRev;
uint32_t ModInfo_Special;
#if defined (WIN32)
UNREFERENCED_PARAMETER(paramCount);
#endif
/* Available settings:
IO configuration,
Output setting,
Input state,
BIT status RT/Latched,
Low-High transition RT/Latched,
High-Low transition RT/Latched,
Overcurrent RT/Latched
*/
naibrd_GetModuleInfo(cardIndex, module, &ModuleID, &ModuleVer, &ModuleRev, &ModInfo_Special);
printf("\n");
printf(" -----------------DT Status ---------------------------- \n");
printf(" BIT \n");
printf(" IOConfig OutputSetting InputState Latched / RT \n");
printf(" --------- --------------- ----------- --------------- \n");
check_status(naibrd_DT_GetIOFormat(cardIndex, module, chan, &IOformat));
switch (ModuleID)
{
case NAI_MODULE_ID_DT1:
case NAI_MODULE_ID_K6:
{
switch (IOformat)
{
case NAI_DT_IOFORMAT_INPUT:
printf(" INPUT ");
break;
case NAI_DT_IOFORMAT_OUTPUT_LOW:
printf(" Low Side");
break;
case NAI_DT_IOFORMAT_OUTPUT_HIGH:
printf("High Side");
break;
case NAI_DT_IOFORMAT_OUTPUT_PUSHPULL:
printf("Push/Pull");
break;
default:
printf(" ERROR ");
break;
}
break;
}
case NAI_MODULE_ID_KA:
switch (IOformat)
{
case NAI_DT_IOFORMAT_INPUT:
printf(" INPUT ");
break;
case NAI_DT_IOFORMAT_OUTPUT_LOW:
printf(" Low Side");
break;
default:
printf(" ERROR ");
break;
}
break;
default:
printf(" UNKNOWN ");
break;
}
printf(" ");
check_status(naibrd_DT_GetOutputState(cardIndex, module, chan, &state));
switch (state)
{
case NAI_DT_STATE_HI:
printf(" HI ");
break;
case NAI_DT_STATE_LO:
printf(" LO ");
break;
default:
printf(" UNK ");
break;
}
printf(" ");
check_status(naibrd_DT_GetInputState(cardIndex, module, chan, &state));
switch (state)
{
case NAI_DT_STATE_HI:
printf(" HI ");
break;
case NAI_DT_STATE_LO:
printf(" LO ");
break;
default:
printf(" UNK ");
break;
}
printf(" ");
check_status(naibrd_DT_GetStatus(cardIndex, module, chan, NAI_DT_STATUS_BIT_LATCHED, &status)); /*BIT latched*/
printf(" %d ", status);
check_status(naibrd_DT_GetStatus(cardIndex, module, chan, NAI_DT_STATUS_BIT_REALTIME, &status)); /*BIT RT*/
printf(" %d ", status);
printf("\n\n\n\n");
printf(" Lo-hi Transition Hi-lo Transition Overcurrent\n");
printf(" Latched / RT Latched / RT Latched / RT\n");
printf(" ---------------- ------------------ ----------------\n");
printf(" ");
check_status(naibrd_DT_GetStatus(cardIndex, module, chan, NAI_DT_STATUS_LO_HI_TRANS_LATCHED, &status));
printf(" %d ", status);
check_status(naibrd_DT_GetStatus(cardIndex, module, chan, NAI_DT_STATUS_LO_HI_TRANS_REALTIME, &status));
printf(" %d ", status);
printf(" ");
check_status(naibrd_DT_GetStatus(cardIndex, module, chan, NAI_DT_STATUS_HI_LO_TRANS_LATCHED, &status));
printf(" %d ", status);
check_status(naibrd_DT_GetStatus(cardIndex, module, chan, NAI_DT_STATUS_HI_LO_TRANS_REALTIME, &status));
printf(" %d ", status);
printf(" ");
check_status(naibrd_DT_GetStatus(cardIndex, module, chan, NAI_DT_STATUS_OVERCURRENT_LATCHED, &status));
printf(" %d ", status);
check_status(naibrd_DT_GetStatus(cardIndex, module, chan, NAI_DT_STATUS_OVERCURRENT_REALTIME, &status));
printf(" %d ", status);
printf("\n\n");
return NAI_ERROR_UNKNOWN;
}
/**************************************************************************************************************/
/**
<summary>
Configure_DT_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>
*/
/**************************************************************************************************************/
static nai_status_t Configure_DT_PWM_Mode(int32_t paramCount, int32_t* p_params)
{
p_naiapp_AppParameters_t p_dt_params = (p_naiapp_AppParameters_t)p_params;
int32_t cardIndex = p_dt_params->cardIndex;
int32_t module = p_dt_params->module;
int32_t chan = p_dt_params->channel;
bool_t bQuit = FALSE;
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 Input Enhanced Input mode \n None Basic input mode \n\n Type DT 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_DT_SetOpMode( cardIndex, module, chan, NAI_DT_MODE_OUTPUT_PWM_FOREVER));
check_status(naibrd_DT_SetBasicOpModeEnable( cardIndex, module, chan, NAI_DT_IOMODE_ENHANCED));
}
else if ((toupper(inputBuffer[0]) == 'B'))
{
check_status(naibrd_DT_SetOpMode( cardIndex, module, chan, NAI_DT_MODE_OUTPUT_PWM_CYCLE_NUM_TIMES));
check_status(naibrd_DT_SetBasicOpModeEnable( cardIndex, module, chan, NAI_DT_IOMODE_ENHANCED));
}
else if ((toupper(inputBuffer[0]) == 'I'))
{
check_status(naibrd_DT_SetOpMode( cardIndex, module, chan, NAI_DT_MODE_ENHANCED_INPUT));
/*delete check_status(naibrd_DT_SetBasicOpModeEnable( cardIndex, module, chan, NAI_DT_IOMODE_ENHANCED));*/
}
else if ((toupper(inputBuffer[0]) == 'N'))
{
check_status(naibrd_DT_SetOpMode( cardIndex, module, chan, NAI_DT_MODE_BASIC_INPUT));
/*delete check_status(naibrd_DT_SetBasicOpModeEnable( cardIndex, module, chan, NAI_DT_IOMODE_BASIC));*/
}
}
}
return (bQuit) ? NAI_ERROR_UNKNOWN : NAI_SUCCESS;
}
/**************************************************************************************************************/
/**
<summary>
Configure_DT_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>
*/
/**************************************************************************************************************/
static nai_status_t Configure_DT_PWM_Polarity(int32_t paramCount, int32_t* p_params)
{
p_naiapp_AppParameters_t p_dt_params = (p_naiapp_AppParameters_t)p_params;
int32_t cardIndex = p_dt_params->cardIndex;
int32_t module = p_dt_params->module;
int32_t chan = p_dt_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 DT PWM positive going pulse output \n Neg DT PWM negative going pulse output \n\n Type DT 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_DT_SetPWM_Polarity( cardIndex, module, chan, (nai_dt_pwm_polarity_t) NAI_DT_PWMPOLARITY_POS ));
else if ((toupper(inputBuffer[0]) == 'N'))
check_status(naibrd_DT_SetPWM_Polarity( cardIndex, module, chan, (nai_dt_pwm_polarity_t) NAI_DT_PWMPOLARITY_NEG ));
}
}
return (bQuit) ? NAI_ERROR_UNKNOWN : NAI_SUCCESS;
}
/**************************************************************************************************************/
/**
<summary>
Configure_DT_PWM_Master handles the user request to select the PWM master channel within the 6 channel groups.
and calls the method in the naibrd library for the setting.
</summary>
*/
/**************************************************************************************************************/
static nai_status_t Configure_DT_PWM_Master(int32_t paramCount, int32_t* p_params)
{
p_naiapp_AppParameters_t p_dt_params = (p_naiapp_AppParameters_t)p_params;
int32_t cardIndex = p_dt_params->cardIndex;
int32_t module = p_dt_params->module;
int32_t chan = p_dt_params->channel;
bool_t bQuit = FALSE;
uint32_t masterchannel;
int8_t inputBuffer[80];
int32_t inputResponseCnt;
#if defined (WIN32)
UNREFERENCED_PARAMETER(paramCount);
#endif
printf("\n == PWM Master Channel Selection == \n Channel applies within its group only \n (Enter 'r' to reset master) \n\n Enter channel to be set as master: ");
bQuit = naiapp_query_ForQuitResponse(sizeof(inputBuffer), NAI_QUIT_CHAR, inputBuffer, &inputResponseCnt);
if (!bQuit)
{
if (inputResponseCnt > 0)
{
if ((toupper(inputBuffer[0]) == 'R'))
check_status(naibrd_DT_ResetPWMMasterChannel( cardIndex, module, chan));
else
{
masterchannel = atoi((const char *)inputBuffer);
check_status(naibrd_DT_SetPWMMasterChannel( cardIndex, module, masterchannel));
}
}
}
return (bQuit) ? NAI_ERROR_UNKNOWN : NAI_SUCCESS;
}
/**************************************************************************************************************/
/**
<summary>
Configure_DT_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>
*/
/**************************************************************************************************************/
static nai_status_t Configure_DT_PWM_Period(int32_t paramCount, int32_t* p_params)
{
p_naiapp_AppParameters_t p_dt_params = (p_naiapp_AppParameters_t)p_params;
int32_t cardIndex = p_dt_params->cardIndex;
int32_t module = p_dt_params->module;
int32_t chan = p_dt_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_DT_GetTimebaseLSB(ModuleID);
switch (ModuleID)
{
case NAI_MODULE_ID_DT1:
min =(float64_t)(0x2u * lsb);
max =(float64_t)(0xFFFFFFFF * lsb);
case NAI_MODULE_ID_KA:
case NAI_MODULE_ID_K6:
min =(float64_t)(0x2u * lsb);
max =(float64_t)(0xFFFF * 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_DT_SetPWM_Period(cardIndex, module, chan, time));
}
}
}
return (bQuit) ? NAI_ERROR_UNKNOWN : NAI_SUCCESS;
}
/**************************************************************************************************************/
/**
<summary>
Configure_DT_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>
*/
/**************************************************************************************************************/
static nai_status_t Configure_DT_PWM_Pulsewidth(int32_t paramCount, int32_t* p_params)
{
p_naiapp_AppParameters_t p_dt_params = (p_naiapp_AppParameters_t)p_params;
int32_t cardIndex = p_dt_params->cardIndex;
int32_t module = p_dt_params->module;
int32_t chan = p_dt_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_DT_GetTimebaseLSB(ModuleID);
switch (ModuleID)
{
case NAI_MODULE_ID_DT1:
min = (float64_t)(0x1u * lsb);
max = (float64_t)(0xFFFFFFFE * lsb);
break;
case NAI_MODULE_ID_KA:
case NAI_MODULE_ID_K6:
min =(float64_t)(0x1u * lsb);
max =(float64_t)(0xFFFE * 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_DT_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>
*/
/**************************************************************************************************************/
static nai_status_t Configure_DT_PWM_Burstcount(int32_t paramCount, int32_t* p_params)
{
p_naiapp_AppParameters_t p_dt_params = (p_naiapp_AppParameters_t)p_params;
int32_t cardIndex = p_dt_params->cardIndex;
int32_t module = p_dt_params->module;
int32_t chan = p_dt_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_DT1:
if (burstcount < 1)
{
burstcount = 1; /*minimum count is one*/
printf("Setting burstcount to minimum of 1.\n");
}
check_status(naibrd_DT_SetPWM_BurstNum(cardIndex, module, chan, burstcount));
break;
default:
printf("Unsupported function for this module.\n");
break;
}
}
}
return (bQuit) ? NAI_ERROR_UNKNOWN : NAI_SUCCESS;
}