PB BasicOps

PB BasicOps Sample Application (SSK 2.x)

Overview

The PB BasicOps sample application demonstrates how to perform basic PROFIBUS DP Master operations using the NAI Software Support Kit (SSK 2.x). It covers master-slave communication management, alarm handling, diagnostics, I/O data read/write, bus parameter configuration, live list retrieval, and operational mode control. This sample provides a comprehensive reference for integrating PROFIBUS master functionality into your own applications.

The application supports NAI PROFIBUS modules and exposes a wide range of PROFIBUS DP Master Class 1 and Class 2 operations through an interactive menu system. Each menu command maps directly to one or more naibrd_PB_*() API calls.

For the SSK 1.x version, see PB BasicOps (SSK 1.x).

Prerequisites

Before running this sample, make sure you have:

An NAI board with a PROFIBUS module installed.
SSK 2.x installed on your development host.
The sample applications built. Refer to the SSK 2.x Software Development Guide for platform-specific build instructions.
A PROFIBUS network with at least one slave device configured.

How to Run

Launch the pb_basic_ops executable from your build output directory. On startup the application looks for a configuration file (default_PBBasicOps.txt). On the first run, this file will not exist — the application will present an interactive board menu where you configure a board connection, card index, and module slot. You can save this configuration so that subsequent runs skip the menu and connect automatically. Once connected, the interactive command menu lets you exercise each PROFIBUS operation.

Board Connection and Module Selection

Note	This startup sequence is common to all NAI sample applications. The board connection and module selection code shown here is not specific to PROFIBUS.

The main() function follows a standard SSK 2.x startup flow:

Call naiapp_RunBoardMenu() to load a saved configuration file (if one exists) or present the interactive board menu. The configuration file (default_PBBasicOps.txt) is not included with the SSK — it is created when the user saves their connection settings from the board menu. On the first run, the menu will always appear.
Query the user for a card index with naiapp_query_CardIndex().
Query for a module slot with naiapp_query_ModuleNumber().
Retrieve the module ID with naibrd_GetModuleName() and verify the module supports PROFIBUS by checking naibrd_PB_GetChannelCount().

#if defined (NAIBSP_CONFIG_SOFTWARE_OS_VXWORKS)
int32_t naiapp_PB_BasicOps(void)
#else
int32_t main(void)
#endif
{
   bool_t stop = NAI_FALSE;
   int32_t moduleCount;
   int32_t channelCount;
   int8_t inputBuffer[80];
   int32_t inputResponseCnt;

   if (naiapp_RunBoardMenu(DEF_CONFIG_FILE) == (bool_t)NAI_TRUE)
   {
      while (stop != NAI_TRUE)
      {
         stop = naiapp_query_CardIndex(naiapp_GetBoardCnt(), 0, &inputPBConfig.cardIndex);
         if (stop != NAI_TRUE)
         {
            check_status(naibrd_GetModuleCount(inputPBConfig.cardIndex, &moduleCount));
            stop = naiapp_query_ModuleNumber(moduleCount, 1, &inputPBConfig.module);
            if (stop != NAI_TRUE)
            {
               check_status(naibrd_GetModuleName(inputPBConfig.cardIndex, inputPBConfig.module, &inputPBConfig.modId));
               channelCount = naibrd_PB_GetChannelCount(inputPBConfig.modId);
               if ((channelCount != 0))
               {
                  naiapp_Run_PB_BasicOps();
               }
               else
               {
                  naiif_printf(" *** Module selection not recognized as valid module type for this application. ***\r\n\r\n");
               }
            }
            naiif_printf("\r\nType Q to quit or Enter key to restart application:\r\n");
            stop = naiapp_query_ForQuitResponse(sizeof(inputBuffer), NAI_QUIT_CHAR, inputBuffer, &inputResponseCnt);
         }
      }
   }
   naiif_printf("\r\nType the Enter key to exit the program: ");
   naiapp_query_ForQuitResponse(sizeof(inputBuffer), NAI_QUIT_CHAR, inputBuffer, &inputResponseCnt);
   naiapp_access_CloseAllOpenCards();
   return 0;
}

Note the SSK 2.x differences from SSK 1.x in this startup sequence:

The VxWorks preprocessor guard uses NAIBSP_CONFIG_SOFTWARE_OS_VXWORKS (SSK 1.x uses __VXWORKS__).
The module identifier is retrieved with naibrd_GetModuleName() (SSK 1.x uses naibrd_GetModuleID()).
Boolean constants are NAI_TRUE / NAI_FALSE (SSK 1.x uses TRUE / FALSE).
Console output uses naiif_printf() from the platform abstraction layer (SSK 1.x uses printf() directly).

Important

Common connection errors you may encounter at this stage:

No board found — verify that the board is powered on and physically connected. Check that the configuration file lists the correct interface and address.
Connection timeout — confirm network settings (for Ethernet connections) or bus configuration (for PCI/PCIe). Firewalls and IP mismatches are frequent causes.
Invalid card or module index — indices are zero-based for cards and one-based for modules. Ensure the values you pass match your hardware setup.
Module not present at selected slot — the slot you selected does not contain the expected module. Use the board menu to verify which slots are populated.

Program Structure

Entry Point

On standard platforms (Petalinux, DEOS) the entry point is main(). On VxWorks the entry point is naiapp_PB_BasicOps().

Command Loop

The naiapp_Run_PB_BasicOps() function presents an interactive menu with PROFIBUS operations. Each operation is implemented as an EXEC_naibrd_PB_*() function that prompts for any required parameters and calls the corresponding library function.

The available operations include:

Operation	Description
GetMS0ConnectionStatus	Query cyclic connection status for a slave address
ResetMS0ConnectionCounters	Reset connection counters for a slave
GetAlarmCounters	Retrieve alarm counters for a slave
ResetAlarmCounters	Reset alarm counters for a slave
GetLastAlarmData	Retrieve the most recent alarm data
GetSlaveDiagnostics	Read diagnostic data from a slave
SetandEnableMaxCycleCounter	Configure maximum cycle count before offline
GetCPULoad	Read processor load statistics
StartReconfiguration	Initiate or cancel bus reconfiguration
SetSystemTime	Set the PROFIBUS system clock
GetLiveList	Discover active and passive stations on the bus
BusParamReconfiguration	Reconfigure master address, HSA, or slave interval
GetOperationMode	Read current master state and operation mode
SetPollCycleMode	Switch between acyclic and cyclic polling
ReadIOData	Read I/O data from a slave
WriteIOData	Write I/O data to a slave
GetStatistics	Retrieve bus statistics
SetNewIOConfig	Apply a new I/O configuration
GetPSAKVersion	Read the PROFIBUS stack version
SetDynamicBusParams	Configure dynamic bus parameters
SetBusParams	Configure static bus parameters
TestSegment / TestTermination	Run segment and termination tests
SetOffline / SetStop / SetClear / SetOperate	Control the master state machine
AcyclicRead / AcyclicWrite	Perform acyclic (Class 2) read/write operations
InitiateCommunication / AbortCommunication	Manage Class 2 connections
GetLockStatusForSegments	Query segment lock status

Operation

Description

GetMS0ConnectionStatus

Query cyclic connection status for a slave address

ResetMS0ConnectionCounters

Reset connection counters for a slave

GetAlarmCounters

Retrieve alarm counters for a slave

ResetAlarmCounters

Reset alarm counters for a slave

GetLastAlarmData

Retrieve the most recent alarm data

GetSlaveDiagnostics

Read diagnostic data from a slave

SetandEnableMaxCycleCounter

Configure maximum cycle count before offline

GetCPULoad

Read processor load statistics

StartReconfiguration

Initiate or cancel bus reconfiguration

SetSystemTime

Set the PROFIBUS system clock

GetLiveList

Discover active and passive stations on the bus

BusParamReconfiguration

Reconfigure master address, HSA, or slave interval

GetOperationMode

Read current master state and operation mode

SetPollCycleMode

Switch between acyclic and cyclic polling

ReadIOData

Read I/O data from a slave

WriteIOData

Write I/O data to a slave

GetStatistics

Retrieve bus statistics

SetNewIOConfig

Apply a new I/O configuration

GetPSAKVersion

Read the PROFIBUS stack version

SetDynamicBusParams

Configure dynamic bus parameters

SetBusParams

Configure static bus parameters

TestSegment / TestTermination

Run segment and termination tests

SetOffline / SetStop / SetClear / SetOperate

Control the master state machine

AcyclicRead / AcyclicWrite

Perform acyclic (Class 2) read/write operations

InitiateCommunication / AbortCommunication

Manage Class 2 connections

GetLockStatusForSegments

Query segment lock status

Connection Status and Diagnostics

The connection status functions query the cyclic data exchange state for a specified slave address. The diagnostics function retrieves detailed station status bytes, identity information, and optional extended diagnostic data.

Key API calls:

naibrd_PB_GetMS0ConnectionStatus() — reads connection status including restart count and missing/invalid response counts.
naibrd_PB_ResetMS0ConnectionCounters() — resets the connection counters.
naibrd_PB_GetSlaveDiagnostics() — reads station status, master address, identity, and extended diagnostic data.

I/O Data Operations

The I/O data functions allow reading from and writing to slave devices in the cyclic data exchange.

Key API calls:

naibrd_PB_ReadIOData() — reads I/O data from a slave.
naibrd_PB_WriteIOData() — writes I/O data to a slave.
naibrd_PB_SetPollCycleMode() — switches between acyclic and cyclic polling modes.

Master State Control

The master state machine is controlled through dedicated functions for each state transition.

Key API calls:

naibrd_PB_GetOperationMode() — reads the current master state and operation mode.
naibrd_PB_SetOffline() / naibrd_PB_SetStop() / naibrd_PB_SetClear() / naibrd_PB_SetOperate() — transition the master to the specified state.

Troubleshooting Reference

Error / Symptom	Possible Causes	Suggested Resolution
No board found	Board not powered or not connected	Verify power and physical connections; check configuration file
Connection timeout	Network/bus misconfiguration	Confirm IP address, subnet, or PCI/PCIe settings
Module not recognized	Module does not support PROFIBUS	Verify the correct slot contains a PROFIBUS module
Slave not in data exchange	Slave offline or address mismatch	Check slave power, address configuration, and bus cabling
GetLiveList returns no stations	Bus not connected or HSA too low	Verify bus termination and that HSA covers all slave addresses
I/O read returns error	Slave not configured or in wrong state	Ensure master is in Operate state and slave is in data exchange
CPU load unexpectedly high	Heavy bus traffic or configuration issue	Review bus parameters and reduce poll rate if needed
Alarm counters incrementing	Communication or process alarms occurring	Check slave diagnostics for root cause; review alarm data
Acyclic operation fails	Class 2 connection not established	Call InitiateCommunication before acyclic read/write
Reconfiguration fails	Master not in correct state for reconfiguration	Transition master to Stop or Clear state before reconfiguring

Error / Symptom

Possible Causes

Suggested Resolution

No board found

Board not powered or not connected

Verify power and physical connections; check configuration file

Connection timeout

Network/bus misconfiguration

Confirm IP address, subnet, or PCI/PCIe settings

Module not recognized

Module does not support PROFIBUS

Verify the correct slot contains a PROFIBUS module

Slave not in data exchange

Slave offline or address mismatch

Check slave power, address configuration, and bus cabling

GetLiveList returns no stations

Bus not connected or HSA too low

Verify bus termination and that HSA covers all slave addresses

I/O read returns error

Slave not configured or in wrong state

Ensure master is in Operate state and slave is in data exchange

CPU load unexpectedly high

Heavy bus traffic or configuration issue

Review bus parameters and reduce poll rate if needed

Alarm counters incrementing

Communication or process alarms occurring

Check slave diagnostics for root cause; review alarm data

Acyclic operation fails

Class 2 connection not established

Call InitiateCommunication before acyclic read/write

Reconfiguration fails

Master not in correct state for reconfiguration

Transition master to Stop or Clear state before reconfiguring

Full Source

The complete source for this sample is provided below for reference. The sections above explain each part in detail.

Full Source — pb_basic_ops.c (SSK 2.x)

/**************************************************************************************************************/
/**
 * <summary>
 * The purpose of the PB_BasicOps is to illustrate the methods to call in the library to perform basic profibus
 * operations.
 * </summary>
 */
/**************************************************************************************************************/

/* nailib include files */
#include "nai_libs/nailib/include/naitypes.h"
#include "nai_libs/nailib/include/nailib.h"
#include "nai_libs/nailib/include/nailib_utils.h"

/* naibrd include files */
#include "nai_libs/naibrd/include/naibrd.h"
#include "nai_libs/naibrd/include/functions/naibrd_pb.h"

/* naiif include files */
#include "nai_libs/naiif/include/naiif_stdio.h"

/* Common Sample Program include files */
#include "nai_sample_apps/naiapp_common/include/naiapp_boardaccess_menu.h"
#include "nai_sample_apps/naiapp_common/include/naiapp_boardaccess_query.h"
#include "nai_sample_apps/naiapp_common/include/naiapp_boardaccess_access.h"
#include "nai_sample_apps/naiapp_common/include/naiapp_boardaccess_utils.h"

/**********************/
/* Application Name   */
/**********************/
static const int8_t *DEF_CONFIG_FILE = (int8_t *)"default_PBBasicOps.txt";


typedef struct
{
   int32_t cardIndex;
   int32_t module;
   uint32_t modId;
} PBConfig;

PBConfig inputPBConfig;

/********************************/
/* Internal Function Prototypes */
/********************************/
static bool_t naiapp_Run_PB_BasicOps(void);
static void printMasterState(NAIBRD_PB_DPM_MASTER_STATE masterState);
static void printOperationMode(NAIBRD_PB_DPM_OPERATION_MODE operationMode);
static void naibrd_PB_PrintPBStatus(int32_t pbStatus);

bool_t EXEC_naibrd_PB_GetMS0ConnectionStatus();
bool_t EXEC_naibrd_PB_ResetMS0ConnectionCounters();
bool_t EXEC_naibrd_PB_GetAlarmCounters();
bool_t EXEC_naibrd_PB_ResetAlarmCounters();
bool_t EXEC_naibrd_PB_GetLastAlarmData();
bool_t EXEC_naibrd_PB_GetSlaveDiagnostics();
bool_t EXEC_naibrd_PB_SetandEnableMaxCycleCounter();
bool_t EXEC_naibrd_PB_GetCPULoad();
bool_t EXEC_naibrd_PB_StartReconfiguration();
bool_t EXEC_naibrd_PB_SetSystemTime();
#ifdef _FUTURE_CAPABILITY
bool_t EXEC_naibrd_PB_GetSystemTime();
bool_t EXEC_naibrd_PB_EnableRedundancy();
#endif
bool_t EXEC_naibrd_PB_GetLiveList();
bool_t EXEC_naibrd_PB_BusParamReconfiguration();
bool_t EXEC_naibrd_PB_GetOperationMode();
bool_t EXEC_naibrd_PB_SetPollCycleMode();
bool_t EXEC_naibrd_PB_ReadIOData();
bool_t EXEC_naibrd_PB_GetStatistics();
bool_t EXEC_naibrd_PB_SetNewIOConfig();
bool_t EXEC_naibrd_PB_GetPSAKVersion();
bool_t EXEC_naibrd_PB_WriteIOData();
bool_t EXEC_naibrd_PB_SetDynamicBusParams();
bool_t EXEC_naibrd_PB_SetBusParams();
bool_t EXEC_naibrd_PB_TestSegment();
bool_t EXEC_naibrd_PB_TestTermination();
bool_t EXEC_naibrd_PB_SetOffline();
bool_t EXEC_naibrd_PB_SetStop();
bool_t EXEC_naibrd_PB_SetClear();
bool_t EXEC_naibrd_PB_SetOperate();
bool_t EXEC_naibrd_PB_AcyclicRead();
bool_t EXEC_naibrd_PB_AcyclicWrite();
bool_t EXEC_naibrd_PB_InitiateCommunication();
bool_t EXEC_naibrd_PB_AbortCommunication();
bool_t EXEC_naibrd_PB_GetLockStatusForSegments();

/**************************************************************************************************************/
/**
 * <summary>
 *
 * The main routine assists in gaining access to the board.
 *
 * The following routines from the nai_sys_cfg.c file are
 * called to assist with accessing and configuring the board.
 *
 * - ConfigDevice
 * - DisplayDeviceCfg
 * - GetBoardSNModCfg
 * - CheckModule
 *
 * </summary>
 */
/***************************************************************************************************************/
#if defined (NAIBSP_CONFIG_SOFTWARE_OS_VXWORKS)
int32_t naiapp_PB_BasicOps(void)
#else
int32_t main(void)
#endif
{
   bool_t stop = NAI_FALSE;
   int32_t moduleCount;
   int32_t channelCount;
   int8_t inputBuffer[80];
   int32_t inputResponseCnt;

   if (naiapp_RunBoardMenu(DEF_CONFIG_FILE) == (bool_t)NAI_TRUE)
   {
      while (stop != NAI_TRUE)
      {
         /* Select Card Index */
         stop = naiapp_query_CardIndex(naiapp_GetBoardCnt(), 0, &inputPBConfig.cardIndex);
         if (stop != NAI_TRUE)
         {
            check_status(naibrd_GetModuleCount(inputPBConfig.cardIndex, &moduleCount));

            /* Select Module */
            stop = naiapp_query_ModuleNumber(moduleCount, 1, &inputPBConfig.module);
            if (stop != NAI_TRUE)
            {
               check_status(naibrd_GetModuleName(inputPBConfig.cardIndex, inputPBConfig.module, &inputPBConfig.modId));

               channelCount = naibrd_PB_GetChannelCount(inputPBConfig.modId);

               if ((channelCount != 0))
               {
                  naiapp_Run_PB_BasicOps();
               }
               else
               {
                   naiif_printf(" *** Module selection not recognized as valid module type for this application. ***\r\n\r\n");
               }
            }

            naiif_printf("\r\nType Q to quit or Enter key to restart application:\r\n");
            stop = naiapp_query_ForQuitResponse(sizeof(inputBuffer), NAI_QUIT_CHAR, inputBuffer, &inputResponseCnt );
         }
      }
   }

   naiif_printf("\r\nType the Enter key to exit the program: ");
   naiapp_query_ForQuitResponse(sizeof(inputBuffer), NAI_QUIT_CHAR, inputBuffer, &inputResponseCnt);

   naiapp_access_CloseAllOpenCards();

   return 0;
}

/*****************************************************************************************************************************************/
/* Execute naibrd_PB_GetMS0ConnectionStatus */
bool_t EXEC_naibrd_PB_GetMS0ConnectionStatus()
{
   bool_t bQuit = NAI_FALSE;
   nai_status_t status = NAI_SUCCESS;
   int8_t inputBuffer[80];
   int32_t inputResponseCnt;

   naiif_printf("-------------------------------------------------\r\n");
   naiif_printf("GetMS0ConnectionStatus\r\n");
   naiif_printf("-------------------------------------------------\r\n");

   naiif_printf("\r\nPlease enter SlaveAddress (2 - 128): ");
   memset(inputBuffer, 0x00, sizeof(inputBuffer));
   bQuit = naiapp_query_ForQuitResponse(sizeof(inputBuffer), NAI_QUIT_CHAR, inputBuffer, &inputResponseCnt);
   if (!bQuit)
   {
      int32_t slaveAddr = 0;
      NAIBRD_PB_CONNECTION_STATUS connectionStatus;

      naiapp_query_NumberFromResponse(&slaveAddr,inputBuffer, inputResponseCnt);

      status = naibrd_PB_GetMS0ConnectionStatus(inputPBConfig.cardIndex, inputPBConfig.module, slaveAddr, &connectionStatus);
      if (status == NAI_SUCCESS)
      {
         naiif_printf("Cyclic Connection Status for Slave Address %d: \r\n", slaveAddr);
         naiif_printf("Is Slave in Data Exchange = %d\r\n", connectionStatus.isSlaveInDataExchange);
         naiif_printf("Number of Restarts = %d\r\n", connectionStatus.numberOfRestarts);
         naiif_printf("Missing Response Count = %d\r\n", connectionStatus.missingResponseCount);
         naiif_printf("Invalid Response Count = %d\r\n", connectionStatus.invalidResponseCount);
      }
      else
      {
         naiif_printf("ERROR Trying to execute naibrd_PB_GetMS0ConnectionStatus - Status = %d\r\n", status);
      }
   }
   return bQuit;
}

/*****************************************************************************************************************************************/
/* Execute naibrd_PB_ResetMS0ConnectionCounters */
bool_t EXEC_naibrd_PB_ResetMS0ConnectionCounters()
{
   bool_t bQuit = NAI_FALSE;
   nai_status_t status = NAI_SUCCESS;
   int8_t inputBuffer[80];
   int32_t inputResponseCnt;

   naiif_printf("-------------------------------------------------\r\n");
   naiif_printf("ResetMS0ConnectionCounters\r\n");
   naiif_printf("-------------------------------------------------\r\n");

   naiif_printf("\r\nPlease enter SlaveAddress (2 - 128): ");
   memset(inputBuffer, 0x00, sizeof(inputBuffer));
   bQuit = naiapp_query_ForQuitResponse(sizeof(inputBuffer), NAI_QUIT_CHAR, inputBuffer, &inputResponseCnt);
   if (!bQuit)
   {
      int32_t slaveAddr = 0;
      naiapp_query_NumberFromResponse(&slaveAddr,inputBuffer, inputResponseCnt);

      status = naibrd_PB_ResetMS0ConnectionCounters(inputPBConfig.cardIndex, inputPBConfig.module, slaveAddr);

      if (status == NAI_SUCCESS)
      {
         naiif_printf("Reset Ms0 Connection Counters - Success\r\n");
      }
      else
      {
         naiif_printf("ERROR Trying to execute naibrd_PB_ResetMS0ConnectionStatus - Status = %d\r\n", status);
      }
   }

   return bQuit;
}

/*****************************************************************************************************************************************/
/* Execute naibrd_PB_GetAlarmCounters */
bool_t EXEC_naibrd_PB_GetAlarmCounters()
{
   bool_t bQuit = NAI_FALSE;
   nai_status_t status = NAI_SUCCESS;
   int8_t inputBuffer[80];
   int32_t inputResponseCnt;

   naiif_printf("-------------------------------------------------\r\n");
   naiif_printf("GetAlarmCounters\r\n");
   naiif_printf("-------------------------------------------------\r\n");

   naiif_printf("\r\nPlease enter SlaveAddress (2 - 128): ");
   memset(inputBuffer, 0x00, sizeof(inputBuffer));
   bQuit = naiapp_query_ForQuitResponse(sizeof(inputBuffer), NAI_QUIT_CHAR, inputBuffer, &inputResponseCnt);
   if (!bQuit)
   {
      int32_t slaveAddr = 0;
      NAIBRD_PB_ALARM_COUNTERS alarmCounters;

      naiapp_query_NumberFromResponse(&slaveAddr,inputBuffer, inputResponseCnt);

      status = naibrd_PB_GetAlarmCounters(inputPBConfig.cardIndex, inputPBConfig.module, slaveAddr, &alarmCounters);
      if (status == NAI_SUCCESS)
      {
         naiif_printf("Alarm Counters for Slave Address %d: \r\n", slaveAddr);
         naiif_printf("Number Diagnostic Alarms = %d\r\n", alarmCounters.numberDiagAlarms);
         naiif_printf("Number Process Alarms = %d\r\n", alarmCounters.numberProcessAlarms);
         naiif_printf("Number Pull Alarms = %d\r\n", alarmCounters.numberPullAlarms);
         naiif_printf("Number Status Alarms = %d\r\n", alarmCounters.numberStatusAlarms);
         naiif_printf("Number Update Alarms = %d\r\n", alarmCounters.numberUpdateAlarms);
         naiif_printf("Number Manufacturer Alarms = %d\r\n", alarmCounters.numberManufacturerAlarms);
      }
      else
      {
         naiif_printf("ERROR Trying to execute naibrd_PB_GetAlarmCounters - Status = %d\r\n", status);
      }
   }
   return bQuit;
}

/*****************************************************************************************************************************************/
/* Execute naibrd_PB_ResetAlarmCounters */
bool_t EXEC_naibrd_PB_ResetAlarmCounters()
{
   bool_t bQuit = NAI_FALSE;
   nai_status_t status = NAI_SUCCESS;
   int8_t inputBuffer[80];
   int32_t inputResponseCnt;

   naiif_printf("-------------------------------------------------\r\n");
   naiif_printf("ResetAlarmCounters\r\n");
   naiif_printf("-------------------------------------------------\r\n");

   naiif_printf("\r\nPlease enter SlaveAddress (2 - 128): ");
   memset(inputBuffer, 0x00, sizeof(inputBuffer));
   bQuit = naiapp_query_ForQuitResponse(sizeof(inputBuffer), NAI_QUIT_CHAR, inputBuffer, &inputResponseCnt);
   if (!bQuit)
   {
      int32_t slaveAddr = 0;
      naiapp_query_NumberFromResponse(&slaveAddr,inputBuffer, inputResponseCnt);

      status = naibrd_PB_ResetAlarmCounters(inputPBConfig.cardIndex, inputPBConfig.module, slaveAddr);

      if (status == NAI_SUCCESS)
      {
         naiif_printf("Reset Alarm Counters - Success\r\n");
      }
      else
      {
         naiif_printf("ERROR Trying to execute naibrd_PB_ResetAlarmCounters - Status = %d\r\n", status);
      }
   }

   return bQuit;
}

/*****************************************************************************************************************************************/
/* Execute naibrd_PB_GetLastAlarmData */
bool_t EXEC_naibrd_PB_GetLastAlarmData()
{
   bool_t bQuit = NAI_FALSE;
   nai_status_t status = NAI_SUCCESS;
   int8_t inputBuffer[80];
   int32_t inputResponseCnt;

   naiif_printf("-------------------------------------------------\r\n");
   naiif_printf("GetLastAlarmData\r\n");
   naiif_printf("-------------------------------------------------\r\n");

   naiif_printf("\r\nPlease enter SlaveAddress (2 - 128): ");
   memset(inputBuffer, 0x00, sizeof(inputBuffer));
   bQuit = naiapp_query_ForQuitResponse(sizeof(inputBuffer), NAI_QUIT_CHAR, inputBuffer, &inputResponseCnt);
   if (!bQuit)
   {
      int32_t slaveAddr = 0;
      NAIBRD_PB_ALARM_DATA lastAlarmData;

      naiapp_query_NumberFromResponse(&slaveAddr,inputBuffer, inputResponseCnt);

      status = naibrd_PB_GetLastAlarmData(inputPBConfig.cardIndex, inputPBConfig.module, slaveAddr, &lastAlarmData);
      if (status == NAI_SUCCESS)
      {
         int32_t i = 0;
         naiif_printf("naibrd_PB_GetLastAlarmData - Success\r\n");
         naiif_printf("BlockLength = %d\r\n", lastAlarmData.blockLength);
         naiif_printf("Type = %d\r\n", lastAlarmData.type);
         naiif_printf("SlotNumber = %d\r\n", lastAlarmData.slotNumber);
         naiif_printf("Specifier = %d\r\n", lastAlarmData.specifier);
         naiif_printf("Diagnostic User Data Count = %d\r\n", lastAlarmData.diagnosticUserDataCount);

         for (i = 0; i < lastAlarmData.diagnosticUserDataCount; i++)
         {
            naiif_printf("DiagnosticUserDataArray[%d] = %dn", i, lastAlarmData.diagnosticUserDataArray[i]);
         }
      }
      else
      {
         naiif_printf("ERROR Trying to execute naibrd_PB_GetLastAlarmData - Status = %d\r\n", status);
      }
   }

   return bQuit;
}

/*****************************************************************************************************************************************/
/* Execute naibrd_PB_GetSlaveDiagnostics */
bool_t EXEC_naibrd_PB_GetSlaveDiagnostics()
{
   bool_t bQuit = NAI_FALSE;
   nai_status_t status = NAI_SUCCESS;
   int8_t inputBuffer[80];
   int32_t inputResponseCnt;

   naiif_printf("-------------------------------------------------\r\n");
   naiif_printf("GetSlaveDiagnostics\r\n");
   naiif_printf("-------------------------------------------------\r\n");

   naiif_printf("\r\nPlease enter SlaveAddress (2 - 128): ");
   memset(inputBuffer, 0x00, sizeof(inputBuffer));
   bQuit = naiapp_query_ForQuitResponse(sizeof(inputBuffer), NAI_QUIT_CHAR, inputBuffer, &inputResponseCnt);
   if (!bQuit)
   {
      int32_t slaveAddr = 0;
      NAIBRD_PB_SLAVE_DIAGNOSTICS slaveDiagnostics;

      naiapp_query_NumberFromResponse(&slaveAddr,inputBuffer, inputResponseCnt);

      status = naibrd_PB_GetSlaveDiagnostics(inputPBConfig.cardIndex, inputPBConfig.module, slaveAddr, &slaveDiagnostics);
      if (status == NAI_SUCCESS)
      {
         int32_t i = 0;
         naiif_printf("Slave Diagnostic Data for Slave = 0x%x\r\n", slaveAddr);
         naiif_printf("StationStatus1 = 0x%x\nStationStatus2 = 0x%x\r\nStationStatus3 = 0x%x\r\n", slaveDiagnostics.stationStatus1,
            slaveDiagnostics.stationStatus2, slaveDiagnostics.stationStatus3);
         naiif_printf("Master Address = 0x%x\nIdentity Number High Byte = 0x%x\r\nIdentity Number Low Byte = 0x%x\r\n",
            slaveDiagnostics.masterAddr, slaveDiagnostics.identityNumberHigh, slaveDiagnostics.identityNumberLow);

         if (slaveDiagnostics.lengthOfExtraDiagData > 0)
         {
            naiif_printf("\r\nExtra Diagnostic Data was Found!\r\n");

            for (i = 0; i < slaveDiagnostics.lengthOfExtraDiagData; i++)
            {
               naiif_printf("0x%x ", slaveDiagnostics.extraDiagDataArray[i]);
            }
            naiif_printf("\r\n\r\n");
         }
         else
         {
            naiif_printf("No extra diagnostic data was found!\r\n");
         }
      }
      else
      {
         naiif_printf("ERROR Trying to execute naibrd_PB_GetSlaveDiagnostics - Status = %d\r\n", status);
      }
   }

   return bQuit;
}

/*****************************************************************************************************************************************/
/* Execute naibrd_PB_SetandEnableMaxCycleCounter */
bool_t EXEC_naibrd_PB_SetandEnableMaxCycleCounter()
{
   bool_t bQuit = NAI_FALSE;
   nai_status_t status = NAI_SUCCESS;
   int8_t inputBuffer[80];
   int32_t inputResponseCnt;

   naiif_printf("-------------------------------------------------\r\n");
   naiif_printf("SetandEnableMaxCycleCounter\r\n");
   naiif_printf("-------------------------------------------------\r\n");

   naiif_printf("\r\nEnter Max Cycle Count prior to channel going offline: ");
   memset(inputBuffer, 0x00, sizeof(inputBuffer));
   bQuit = naiapp_query_ForQuitResponse(sizeof(inputBuffer), NAI_QUIT_CHAR, inputBuffer, &inputResponseCnt);
   if (!bQuit)
   {
      int32_t maxCycleCount = 0;

      naiapp_query_NumberFromResponse(&maxCycleCount, inputBuffer, inputResponseCnt);

      status = naibrd_PB_SetAndEnableMaxCycleCounter(inputPBConfig.cardIndex, inputPBConfig.module, maxCycleCount);
      if (status == NAI_SUCCESS)
      {
         naiif_printf("Set And Enable Max Cycle Count - Success\r\n");
      }
      else
      {
         naiif_printf("ERROR Trying to execute naibrd_PB_SetAndEnableMaxCycleCounter - Status = %d\r\n", status);
      }
   }

   return bQuit;
}

/*****************************************************************************************************************************************/
/* Execute naibrd_PB_GetCPULoad */
bool_t EXEC_naibrd_PB_GetCPULoad()
{
   bool_t bQuit = NAI_FALSE;
   nai_status_t status = NAI_SUCCESS;
   NAIBRD_PB_CPU_LOAD cpuLoad;

   naiif_printf("-------------------------------------------------\r\n");
   naiif_printf("GetCPULoad\r\n");
   naiif_printf("-------------------------------------------------\r\n");


   status = naibrd_PB_GetCPULoad(inputPBConfig.cardIndex, inputPBConfig.module, &cpuLoad);
   if (status == NAI_SUCCESS)
   {
      naiif_printf("CPU Load:\r\n");
      naiif_printf("Last 100ms = %d%%\r\n", cpuLoad.last100ms);
      naiif_printf("Last 1s = %d%%\r\n", cpuLoad.last1s);
      naiif_printf("Last 10s = %d%%\r\n", cpuLoad.last10s);
   }
   else
   {
      naiif_printf("ERROR Trying to execute naibrd_PB_GetCPULoad - Status = %d\r\n", status);
   }

   return bQuit;
}

/*****************************************************************************************************************************************/
/* Execute naibrd_PB_StartReconfiguration */
bool_t EXEC_naibrd_PB_StartReconfiguration()
{
   bool_t bQuit = NAI_FALSE;
   nai_status_t status = NAI_SUCCESS;
   int8_t inputBuffer[80];
   int32_t inputResponseCnt;

   naiif_printf("-------------------------------------------------\r\n");
   naiif_printf("StartReconfiguration\r\n");
   naiif_printf("-------------------------------------------------\r\n");

   naiif_printf("\r\nEnter 1 to enable Start Reconfiguration or 0 to disable Start Reconfiguration: ");
   memset(inputBuffer, 0x00, sizeof(inputBuffer));
   bQuit = naiapp_query_ForQuitResponse(sizeof(inputBuffer), NAI_QUIT_CHAR, inputBuffer, &inputResponseCnt);
   if (!bQuit)
   {
      int32_t startReconfig = 0;

      naiapp_query_NumberFromResponse(&startReconfig, inputBuffer, inputResponseCnt);

      status = naibrd_PB_StartReconfiguration(inputPBConfig.cardIndex, inputPBConfig.module, startReconfig);
      if (status == NAI_SUCCESS)
      {
         naiif_printf("Start Reconfiguration - Success\r\n");
      }
      else
      {
         naiif_printf("ERROR Trying to execute naibrd_PB_GetSlaveDiagnostics - Status = %d\r\n", status);
      }
   }

   return bQuit;
}

/*****************************************************************************************************************************************/
/* Execute naibrd_PB_SetSystemTime */
bool_t EXEC_naibrd_PB_SetSystemTime()
{
   bool_t bQuit = NAI_FALSE;
   nai_status_t status = NAI_SUCCESS;
   int8_t inputBuffer[80];
   int32_t inputResponseCnt;

   naiif_printf("-------------------------------------------------\r\n");
   naiif_printf("SetSystemTime\r\n");
   naiif_printf("-------------------------------------------------\r\n");

   naiif_printf("\r\nEnter Clock Status: (see naibrd_pb.h for valid combinations of High and Low bytes) ");
   memset(inputBuffer, 0x00, sizeof(inputBuffer));
   bQuit = naiapp_query_ForQuitResponse(sizeof(inputBuffer), NAI_QUIT_CHAR, inputBuffer, &inputResponseCnt);
   if (!bQuit)
   {
      uint32_t clockStatus = 0;
      naiapp_query_UnsignedNumberFromResponse(&clockStatus, inputBuffer, inputResponseCnt);

      naiif_printf("\r\nEnter Seconds since 1970: ");
      memset(inputBuffer, 0x00, sizeof(inputBuffer));
      bQuit = naiapp_query_ForQuitResponse(sizeof(inputBuffer), NAI_QUIT_CHAR, inputBuffer, &inputResponseCnt);
      if (!bQuit)
      {
         uint32_t sysTimeSeconds = 0;
         naiapp_query_UnsignedNumberFromResponse(&sysTimeSeconds, inputBuffer, inputResponseCnt);

         naiif_printf("\r\nEnter Nano Seconds: ");
         memset(inputBuffer, 0x00, sizeof(inputBuffer));
         bQuit = naiapp_query_ForQuitResponse(sizeof(inputBuffer), NAI_QUIT_CHAR, inputBuffer, &inputResponseCnt);
         if (!bQuit)
         {
            uint32_t sysTimeNanoSeconds = 0;
            naiapp_query_UnsignedNumberFromResponse(&sysTimeNanoSeconds, inputBuffer, inputResponseCnt);

            status = naibrd_PB_SetSystemTime(inputPBConfig.cardIndex, inputPBConfig.module, clockStatus, sysTimeSeconds, sysTimeNanoSeconds);
            if (status == NAI_SUCCESS)
            {
               naiif_printf("Set System Time - Success\r\n");
            }
            else
            {
               naiif_printf("ERROR Trying to execute naibrd_PB_SetSystemTime - Status = %d\r\n", status);
            }
         }
      }
   }

   return bQuit;
}

/*****************************************************************************************************************************************/
/* Execute naibrd_PB_GetLiveList */
bool_t EXEC_naibrd_PB_GetLiveList()
{
   bool_t bQuit = NAI_FALSE;
   nai_status_t status = NAI_SUCCESS;
   int8_t inputBuffer[80];
   int32_t inputResponseCnt;

   naiif_printf("-------------------------------------------------\r\n");
   naiif_printf("GetLiveList\r\n");
   naiif_printf("-------------------------------------------------\r\n");

   naiif_printf("\r\nEnter 1 to make request to collect data or 0 to display data already collected: ");
   memset(inputBuffer, 0x00, sizeof(inputBuffer));
   bQuit = naiapp_query_ForQuitResponse(sizeof(inputBuffer), NAI_QUIT_CHAR, inputBuffer, &inputResponseCnt);
   if (!bQuit)
   {
      int32_t makeRequest = 0;
      naiapp_query_NumberFromResponse(&makeRequest, inputBuffer, inputResponseCnt);

      if (makeRequest)
      {
         status = naibrd_PB_KickoffGetLiveList(inputPBConfig.cardIndex, inputPBConfig.module);

         if (status == NAI_SUCCESS)
         {
            naiif_printf("Kickoff Get Live List - Success\r\n");
         }
         else
         {
            naiif_printf("ERROR Trying to execute naibrd_PB_KickoffGetLiveList - Status = %d\r\n", status);
         }
      }
      else /* Interested in collected results */
      {
         NAIBRD_PB_LIVELIST_RESULTS liveListResults;
         status = naibrd_PB_GetLiveListResults(inputPBConfig.cardIndex, inputPBConfig.module, &liveListResults);

         if (status == NAI_SUCCESS)
         {
            int32_t i = 0;
            naiif_printf("Get Live List Results - Success\r\n");

            for (i = 0; i < liveListResults.passiveStationCount; i++)
            {
               naiif_printf("Found PASSIVE Station %d\r\n", liveListResults.passiveStations[i]);
            }

            for (i = 0; i < liveListResults.activeStationCount; i++)
            {
               naiif_printf("Found ACTIVE Station %d\r\n", liveListResults.activeStations[i]);
            }
            naiif_printf("\r\n");
         }
         else
         {
            naiif_printf("ERROR Trying to execute naibrd_PB_GetLiveListResults - Status = %d\r\n", status);
            if (status == NAI_ERROR_FUNCTION_SPECIFIC_ERROR)
            {
               int32_t pbStatus;
               status = naibrd_PB_GetLastFunctionCallStatus(inputPBConfig.cardIndex, inputPBConfig.module, &pbStatus);
               naibrd_PB_PrintPBStatus(pbStatus);
            }
         }
      }
   }

   return bQuit;
}

/*****************************************************************************************************************************************/
/* Execute naibrd_PB_BusParamReconfiguration */
bool_t EXEC_naibrd_PB_BusParamReconfiguration()
{
   bool_t bQuit = NAI_FALSE;
   nai_status_t status = NAI_SUCCESS;
   int8_t inputBuffer[80];
   int32_t inputResponseCnt;

   naiif_printf("-------------------------------------------------\r\n");
   naiif_printf("BusParamReconfiguration\r\n");
   naiif_printf("-------------------------------------------------\r\n");

   naiif_printf("\r\nEnter 0 to reconfigure Master Address\nEnter 1 to reconfigure Hsa\r\nEnter 2 to reconfigure Min Slave Interval: ");
   memset(inputBuffer, 0x00, sizeof(inputBuffer));
   bQuit = naiapp_query_ForQuitResponse(sizeof(inputBuffer), NAI_QUIT_CHAR, inputBuffer, &inputResponseCnt);
   if (!bQuit)
   {
      int32_t busParam = 0;
      bool_t requiresField2 = NAI_FALSE;

      naiapp_query_NumberFromResponse(&busParam, inputBuffer, inputResponseCnt);

      if (busParam == 0)
      {
         naiif_printf("\r\nEnter new Master Address: ");
      }
      else if (busParam == 1)
      {
         naiif_printf("\r\nEnter new Hsa: ");
      }
      else if (busParam == 2)
      {
         naiif_printf("\r\nEnter new Min Slave Interval Hi Byte: ");
         requiresField2 = NAI_TRUE;
      }

      memset(inputBuffer, 0x00, sizeof(inputBuffer));
      bQuit = naiapp_query_ForQuitResponse(sizeof(inputBuffer), NAI_QUIT_CHAR, inputBuffer, &inputResponseCnt);
      if (!bQuit)
      {
         int32_t field1Value = 0;
         int32_t field2Value = 0;
         naiapp_query_NumberFromResponse(&field1Value, inputBuffer, inputResponseCnt);

         if (requiresField2)
         {
            naiif_printf("\r\nEnter new Min Slave Interval Lo Byte: ");

            memset(inputBuffer, 0x00, sizeof(inputBuffer));
            bQuit = naiapp_query_ForQuitResponse(sizeof(inputBuffer), NAI_QUIT_CHAR, inputBuffer, &inputResponseCnt);
            if (!bQuit)
            {
               naiapp_query_NumberFromResponse(&field2Value, inputBuffer, inputResponseCnt);
            }
         }

         if (!bQuit)
         {
            status = naibrd_PB_BusParamReconfiguration(inputPBConfig.cardIndex, inputPBConfig.module, busParam, field1Value, field2Value);
            if (status == NAI_SUCCESS)
            {
               naiif_printf("Bus Param Reconfiguration - Success\r\n");
            }
            else
            {
               naiif_printf("ERROR Trying to execute naibrd_PB_BusParamReconfiguration - Status = %d\r\n", status);
            }
         }
      }
   }

   return bQuit;
}

/*****************************************************************************************************************************************/
/* Execute naibrd_PB_GetOperationMode */
bool_t EXEC_naibrd_PB_GetOperationMode()
{
   bool_t bQuit = NAI_FALSE;
   nai_status_t status = NAI_SUCCESS;
   NAIBRD_PB_DPM_MASTER_STATE masterState;
   NAIBRD_PB_DPM_OPERATION_MODE operationMode;

   naiif_printf("-------------------------------------------------\r\n");
   naiif_printf("GetOperationMode\r\n");
   naiif_printf("-------------------------------------------------\r\n");

   status = naibrd_PB_GetOperationMode(inputPBConfig.cardIndex, inputPBConfig.module, &masterState, &operationMode);

   if (status == NAI_SUCCESS)
   {
      naiif_printf("Get Operation Mode - Success\r\n");
      printMasterState(masterState);
      printOperationMode(operationMode);
   }
   else
   {
      naiif_printf("ERROR Trying to execute naibrd_PB_GetOperationMode - Status = %d\r\n", status);
   }

   return bQuit;
}

/*****************************************************************************************************************************************/
/* Execute naibrd_PB_SetPollCycleMode */
bool_t EXEC_naibrd_PB_SetPollCycleMode()
{
   bool_t bQuit = NAI_FALSE;
   nai_status_t status = NAI_SUCCESS;
   int8_t inputBuffer[80];
   int32_t inputResponseCnt;

   naiif_printf("-------------------------------------------------\r\n");
   naiif_printf("SetPollCycleMode\r\n");
   naiif_printf("-------------------------------------------------\r\n");

   naiif_printf("\r\nEnter 0 for ACYCLIC mode or 1 for CYCLIC mode: ");
   memset(inputBuffer, 0x00, sizeof(inputBuffer));
   bQuit = naiapp_query_ForQuitResponse(sizeof(inputBuffer), NAI_QUIT_CHAR, inputBuffer, &inputResponseCnt);
   if (!bQuit)
   {
      int32_t pollCycleMode = 0;

      naiapp_query_NumberFromResponse(&pollCycleMode, inputBuffer, inputResponseCnt);

      status = naibrd_PB_SetPollCycleMode(inputPBConfig.cardIndex, inputPBConfig.module, pollCycleMode);
      if (status == NAI_SUCCESS)
      {
         naiif_printf("Set Poll Cycle Mode - Success\r\n");
      }
      else
      {
         naiif_printf("ERROR Trying to execute naibrd_PB_SetPollCycleMode - Status = %d\r\n", status);
      }
   }

   return bQuit;
}

/*****************************************************************************************************************************************/
/* Execute naibrd_PB_ReadIOData */
bool_t EXEC_naibrd_PB_ReadIOData()
{
   bool_t bQuit = NAI_FALSE;
   nai_status_t status = NAI_SUCCESS;
   int8_t inputBuffer[80];
   int32_t inputResponseCnt;

   naiif_printf("-------------------------------------------------\r\n");
   naiif_printf("ReadIOData\r\n");
   naiif_printf("-------------------------------------------------\r\n");

   naiif_printf("\r\nPlease enter SlaveAddress (2 - 128): ");
   memset(inputBuffer, 0x00, sizeof(inputBuffer));
   bQuit = naiapp_query_ForQuitResponse(sizeof(inputBuffer), NAI_QUIT_CHAR, inputBuffer, &inputResponseCnt);
   if (!bQuit)
   {
      int32_t slaveAddr = 0;
      naiapp_query_NumberFromResponse(&slaveAddr, inputBuffer, inputResponseCnt);

      naiif_printf("\r\nPlease enter Offset into slave: ");
      memset(inputBuffer, 0x00, sizeof(inputBuffer));
      bQuit = naiapp_query_ForQuitResponse(sizeof(inputBuffer), NAI_QUIT_CHAR, inputBuffer, &inputResponseCnt);
      if (!bQuit)
      {
         int32_t offset = 0;
         naiapp_query_NumberFromResponse(&offset, inputBuffer, inputResponseCnt);

         naiif_printf("\r\nPlease enter Number of Bytes to Read: ");
         memset(inputBuffer, 0x00, sizeof(inputBuffer));
         bQuit = naiapp_query_ForQuitResponse(sizeof(inputBuffer), NAI_QUIT_CHAR, inputBuffer, &inputResponseCnt);
         if (!bQuit)
         {
            int32_t readCount = 0;
            int8_t data[NAIBRD_PB_MAX_PDU_LENGTH];
            naiapp_query_NumberFromResponse(&readCount, inputBuffer, inputResponseCnt);

            status = naibrd_PB_ReadIOData(inputPBConfig.cardIndex, inputPBConfig.module, slaveAddr, offset, readCount, &(data[0]));

            if (status == NAI_SUCCESS)
            {
               int32_t i = 0;
               naiif_printf("Read IO Data - Success\r\n");

               naiif_printf("IO Data:\r\n");
               for (i = 0; i < readCount; i++)
               {
                  naiif_printf("0x%02x ", (data[i] & 0xFF));
               }
               naiif_printf("\r\n\r\n");
            }
            else
            {
               naiif_printf("ERROR Trying to execute naibrd_PB_ReadIOData - Status = %d\r\n", status);
            }
         }
      }
   }

   return bQuit;
}

/*****************************************************************************************************************************************/
/* Execute naibrd_PB_GetStatistics */
bool_t EXEC_naibrd_PB_GetStatistics()
{
   bool_t bQuit = NAI_FALSE;
   nai_status_t status = NAI_SUCCESS;
   NAIBRD_PB_STATISTICS statistics;

   naiif_printf("-------------------------------------------------\r\n");
   naiif_printf("GetStatistics\r\n");
   naiif_printf("-------------------------------------------------\r\n");

   status = naibrd_PB_GetStatistics(inputPBConfig.cardIndex, inputPBConfig.module, &statistics);
   if (status == NAI_SUCCESS)
   {
      int32_t i = 0;
      naiif_printf("naibrd_PB_GetStatistics - Success\r\n");
      naiif_printf("NumMasterStations = %d\r\n", statistics.numMasterStations);
      naiif_printf("Master Active Stations:\r\n");

      for (i=0; i < statistics.numMasterStations; i++)
      {
         naiif_printf("%d\r\n", statistics.masterStationsArray[i]);
      }
      naiif_printf("\r\n");

      naiif_printf("NumSlaveStations = %d\r\n", statistics.numSlaveStations);
      naiif_printf("Slave Active Stations:\r\n");

      for (i=0; i < statistics.numSlaveStations; i++)
      {
         naiif_printf("%d\r\n", statistics.slaveStationsArray[i]);
      }
      naiif_printf("\r\n");

      naiif_printf("Bus Parameters:\r\n");
      naiif_printf("\tStation Address:\t%d\r\n", statistics.stationAddress);
      naiif_printf("\tBaudrate:\t%d\r\n", statistics.baudRate);
      naiif_printf("\tTIdle1:\t\t%d\r\n", statistics.tIdle1);
      naiif_printf("\tTIdle2:\t\t%d\r\n", statistics.tIdle2);
      naiif_printf("\tTSlot:\t\t%d\r\n", statistics.tSlot);
      naiif_printf("\tTtr:\t\t%d\r\n", statistics.tTr);
      naiif_printf("\tMinSlaveInterval:\t\t%d\r\n", statistics.minSlaveInterval);
      naiif_printf("\tMaxAcyclicServicesPerPollCycle:\t%d\r\n", statistics.maxAcyclicServicesPerPollCycle);
   }
   else
   {
      naiif_printf("ERROR Trying to execute naibrd_PB_GetStatistics - Status = %d\r\n", status);
   }

   return bQuit;
}

/*****************************************************************************************************************************************/
/* Execute naibrd_PB_SetNewIOConfig */
bool_t EXEC_naibrd_PB_SetNewIOConfig()
{
   bool_t bQuit = NAI_FALSE;
   nai_status_t status = NAI_SUCCESS;
   int8_t inputBuffer[80];
   int32_t inputResponseCnt;

   naiif_printf("-------------------------------------------------\r\n");
   naiif_printf("SetNewIOConfig\r\n");
   naiif_printf("-------------------------------------------------\r\n");

   naiif_printf("\r\nPlease enter SlaveAddress (2 - 128): ");
   memset(inputBuffer, 0x00, sizeof(inputBuffer));
   bQuit = naiapp_query_ForQuitResponse(sizeof(inputBuffer), NAI_QUIT_CHAR, inputBuffer, &inputResponseCnt);
   if (!bQuit)
   {
      int32_t slaveAddr = 0;
      int32_t cfgDataLength = 0;
      int8_t cfgData[NAIBRD_PB_MAX_CFG_DATA_LENGTH];

      naiapp_query_NumberFromResponse(&slaveAddr, inputBuffer, inputResponseCnt);

      naiif_printf("\r\nPlease enter number of bytes of configuration (1 - %d): ", NAIBRD_PB_MAX_CFG_DATA_LENGTH);
      memset(inputBuffer, 0x00, sizeof(inputBuffer));
      bQuit = naiapp_query_ForQuitResponse(sizeof(inputBuffer), NAI_QUIT_CHAR, inputBuffer, &inputResponseCnt);
      if (!bQuit)
      {
         int32_t i = 0;
         naiapp_query_NumberFromResponse(&cfgDataLength, inputBuffer, inputResponseCnt);

         /* Now prompt for data to be written */
         naiif_printf("\r\nPlease enter configuration data in the form of 0x00");
         for (i = 0; i < cfgDataLength; i++)
         {
            naiif_printf("\r\ncfgData[%d]: ", i);

            bQuit = naiapp_query_ForQuitResponse(sizeof(inputBuffer), NAI_QUIT_CHAR, inputBuffer, &inputResponseCnt);
            if (bQuit)
            {
               break;
            }

            cfgData[i] = (int8_t)strtol((char*)inputBuffer, NULL, 16);
         }

         if (!bQuit)
         {
            status = naibrd_PB_SetNewIOConfig(inputPBConfig.cardIndex, inputPBConfig.module, slaveAddr, cfgDataLength, &(cfgData[0]));

            if (status == NAI_SUCCESS)
            {
               naiif_printf("Set New IO Config - Success\r\n");
            }
            else
            {
               naiif_printf("ERROR Trying to execute naibrd_PB_SetNewIOConfig - Status = %d\r\n", status);
               if (status == NAI_ERROR_FUNCTION_SPECIFIC_ERROR)
               {
                  int32_t pbStatus = NAI_PB_SUCCESS;
                  status = naibrd_PB_GetLastFunctionCallStatus(inputPBConfig.cardIndex, inputPBConfig.module, &pbStatus);
                  if (status == NAI_SUCCESS)
                  {
                     naiif_printf("PB Specific Status = %d\r\n", pbStatus);
                  }
               }
            }
         }
      }
   }

   return bQuit;
}

/*****************************************************************************************************************************************/
/* Execute naibrd_PB_GetPSAKVersion */
bool_t EXEC_naibrd_PB_GetPSAKVersion()
{
   bool_t bQuit = NAI_FALSE;
   nai_status_t status = NAI_SUCCESS;
   char firmwareVersion[NAIBRD_PB_VERSION_MAX_LENGTH];
   char psakVersion[NAIBRD_PB_VERSION_MAX_LENGTH];

   naiif_printf("-------------------------------------------------\r\n");
   naiif_printf("GetPSAKVersion\r\n");
   naiif_printf("-------------------------------------------------\r\n");

   status = naibrd_PB_GetPSAKVersion(inputPBConfig.cardIndex, inputPBConfig.module, NAIBRD_PB_VERSION_MAX_LENGTH, &(firmwareVersion[0]),
      NAIBRD_PB_VERSION_MAX_LENGTH, &(psakVersion[0]));

   if (status == NAI_SUCCESS)
   {
      naiif_printf("Get PSAK Version - Success\r\n");
      naiif_printf("Firmware Version = %s\r\n", firmwareVersion);
      naiif_printf("PSAK Version = %s\r\n", psakVersion);
   }
   else
   {
      naiif_printf("ERROR Trying to execute naibrd_PB_GetPSAKVersion - Status = %d\r\n", status);
   }

   return bQuit;
}

/*****************************************************************************************************************************************/
/* Execute naibrd_PB_WriteIOData */
bool_t EXEC_naibrd_PB_WriteIOData()
{
   bool_t bQuit = NAI_FALSE;
   nai_status_t status = NAI_SUCCESS;
   int8_t inputBuffer[80];
   int32_t inputResponseCnt;

   naiif_printf("-------------------------------------------------\r\n");
   naiif_printf("WriteIOData\r\n");
   naiif_printf("-------------------------------------------------\r\n");

   naiif_printf("\r\nPlease enter SlaveAddress (2 - 128): ");
   memset(inputBuffer, 0x00, sizeof(inputBuffer));
   bQuit = naiapp_query_ForQuitResponse(sizeof(inputBuffer), NAI_QUIT_CHAR, inputBuffer, &inputResponseCnt);
   if (!bQuit)
   {
      int32_t slaveAddr = 0;
      naiapp_query_NumberFromResponse(&slaveAddr, inputBuffer, inputResponseCnt);

      naiif_printf("\r\nPlease enter Offset into slave: ");
      memset(inputBuffer, 0x00, sizeof(inputBuffer));
      bQuit = naiapp_query_ForQuitResponse(sizeof(inputBuffer), NAI_QUIT_CHAR, inputBuffer, &inputResponseCnt);
      if (!bQuit)
      {
         int32_t offset = 0;
         int8_t bytesToWrite[2];
         int32_t numBytesToWrite = 0;

         naiapp_query_NumberFromResponse(&offset, inputBuffer, inputResponseCnt);

         naiif_printf("\r\nPlease enter number of bytes to be written: ");
         memset(inputBuffer, 0x00, sizeof(inputBuffer));
         bQuit = naiapp_query_ForQuitResponse(sizeof(inputBuffer), NAI_QUIT_CHAR, inputBuffer, &inputResponseCnt);
         if (!bQuit)
         {
            int32_t i = 0;
            naiapp_query_NumberFromResponse(&numBytesToWrite, inputBuffer, inputResponseCnt);

            /* Now prompt for data to be written */
            naiif_printf("\r\nPlease enter data in the form of 0x00");
            for (i = 0; i < numBytesToWrite; i++)
            {
               naiif_printf("\r\nData[%d]: ", i);

               bQuit = naiapp_query_ForQuitResponse(sizeof(inputBuffer), NAI_QUIT_CHAR, inputBuffer, &inputResponseCnt);
               if (bQuit)
               {
                  break;
               }

               bytesToWrite[i] = (int8_t)strtol((char*)inputBuffer, NULL, 16);
            }

            if (!bQuit)
            {
               status = naibrd_PB_WriteIOData(inputPBConfig.cardIndex, inputPBConfig.module, slaveAddr, offset, numBytesToWrite,
                  bytesToWrite);

               if (status == NAI_SUCCESS)
               {
                  naiif_printf("Write IO Data - Success\r\n");
               }
               else
               {
                  naiif_printf("ERROR Trying to execute naibrd_PB_WriteIOData - Status = %d\r\n", status);
               }
            }
         }
      }
   }

   return bQuit;
}

/*****************************************************************************************************************************************/
/* Execute naibrd_PB_SetDynamicBusParams */
bool_t EXEC_naibrd_PB_SetDynamicBusParams()
{
   bool_t bQuit = NAI_FALSE;
   nai_status_t status = NAI_SUCCESS;
   int8_t inputBuffer[80];
   int32_t inputResponseCnt;

   naiif_printf("-------------------------------------------------\r\n");
   naiif_printf("SetDynamicBusParams\r\n");
   naiif_printf("-------------------------------------------------\r\n");

   naiif_printf("\r\nPlease enter StationAddress: ");
   memset(inputBuffer, 0x00, sizeof(inputBuffer));
   bQuit = naiapp_query_ForQuitResponse(sizeof(inputBuffer), NAI_QUIT_CHAR, inputBuffer, &inputResponseCnt);
   if (!bQuit)
   {
      int32_t stationAddr = 0;
      naiapp_query_NumberFromResponse(&stationAddr, inputBuffer, inputResponseCnt);

      naiif_printf("\r\nPlease enter Max Retry Limit: ");
      memset(inputBuffer, 0x00, sizeof(inputBuffer));
      bQuit = naiapp_query_ForQuitResponse(sizeof(inputBuffer), NAI_QUIT_CHAR, inputBuffer, &inputResponseCnt);
      if (!bQuit)
      {
         int32_t maxRetryLimit = 0;
         naiapp_query_NumberFromResponse(&maxRetryLimit, inputBuffer, inputResponseCnt);

         naiif_printf("\r\nPlease enter TSlot: ");
         memset(inputBuffer, 0x00, sizeof(inputBuffer));
         bQuit = naiapp_query_ForQuitResponse(sizeof(inputBuffer), NAI_QUIT_CHAR, inputBuffer, &inputResponseCnt);
         if (!bQuit)
         {
            int32_t tSlot = 0;
            naiapp_query_NumberFromResponse(&tSlot, inputBuffer, inputResponseCnt);

            naiif_printf("\r\nPlease enter MaxTSDR: ");
            memset(inputBuffer, 0x00, sizeof(inputBuffer));
            bQuit = naiapp_query_ForQuitResponse(sizeof(inputBuffer), NAI_QUIT_CHAR, inputBuffer, &inputResponseCnt);
            if (!bQuit)
            {
               int32_t maxTsdr = 0;
               naiapp_query_NumberFromResponse(&maxTsdr, inputBuffer, inputResponseCnt);

               status = naibrd_PB_SetDynamicBusParams(inputPBConfig.cardIndex, inputPBConfig.module, stationAddr, maxRetryLimit, tSlot,
                  maxTsdr);

               if (status == NAI_SUCCESS)
               {
                  naiif_printf("Set Dynamic Bus Params - Success\r\n");
               }
               else
               {
                  naiif_printf("ERROR Trying to execute naibrd_PB_SetDynamicBusParams - Status = %d\r\n", status);
               }
            }
         }
      }
   }

   return bQuit;
}

/*****************************************************************************************************************************************/
/* Execute naibrd_PB_SetBusParams */
bool_t EXEC_naibrd_PB_SetBusParams()
{
   bool_t bQuit = NAI_FALSE;
   nai_status_t status = NAI_SUCCESS;
   int8_t inputBuffer[80];
   int32_t inputResponseCnt;

   naiif_printf("-------------------------------------------------\r\n");
   naiif_printf("SetBusParams\r\n");
   naiif_printf("-------------------------------------------------\r\n");

   naiif_printf("\r\nPlease enter tSlot (Slot time - max time master has to wait for 1st byte of response or frame from token receiver after\
      a token exchange) Valid values (37 - 16383): ");
   memset(inputBuffer, 0x00, sizeof(inputBuffer));
   bQuit = naiapp_query_ForQuitResponse(sizeof(inputBuffer), NAI_QUIT_CHAR, inputBuffer, &inputResponseCnt);
   if (!bQuit)
   {
      NAIBRD_PB_BUS_PARAMS busParams;
      naiapp_query_NumberFromResponse(&(busParams.tSlot), inputBuffer, inputResponseCnt);

      naiif_printf("\r\nPlease enter Min Tsdr (Min time delay of the slave processing a request to sending the response) Valid values \
                   (11 - 1023): ");
      memset(inputBuffer, 0x00, sizeof(inputBuffer));
      bQuit = naiapp_query_ForQuitResponse(sizeof(inputBuffer), NAI_QUIT_CHAR, inputBuffer, &inputResponseCnt);
      if (!bQuit)
      {
         naiapp_query_NumberFromResponse(&(busParams.minTsdr), inputBuffer, inputResponseCnt);

         naiif_printf("\r\nPlease enter Max Tsdr (Max time delay of the slave processing a request to sending the response) Valid values \
                      (37 - 65535): ");
         memset(inputBuffer, 0x00, sizeof(inputBuffer));
         bQuit = naiapp_query_ForQuitResponse(sizeof(inputBuffer), NAI_QUIT_CHAR, inputBuffer, &inputResponseCnt);
         if (!bQuit)
         {
            naiapp_query_NumberFromResponse(&(busParams.maxTsdr), inputBuffer, inputResponseCnt);

            naiif_printf("\r\nPlease enter Baudrate: (Valid values defined in naibrd_pb.h): ");
            memset(inputBuffer, 0x00, sizeof(inputBuffer));
            bQuit = naiapp_query_ForQuitResponse(sizeof(inputBuffer), NAI_QUIT_CHAR, inputBuffer, &inputResponseCnt);
            if (!bQuit)
            {
               naiapp_query_NumberFromResponse(&(busParams.baudrate), inputBuffer, inputResponseCnt);

               naiif_printf("\r\nPlease enter TQui (Quiet Time is the time during which the PB control logic has to close its sender and \
                            its receiver) Valid values (0 - 493): ");
               memset(inputBuffer, 0x00, sizeof(inputBuffer));
               bQuit = naiapp_query_ForQuitResponse(sizeof(inputBuffer), NAI_QUIT_CHAR, inputBuffer, &inputResponseCnt);
               if (!bQuit)
               {
                  naiapp_query_NumberFromResponse(&(busParams.tQui), inputBuffer, inputResponseCnt);

                  naiif_printf("\r\nPlease enter TSet (Setup Time - indicates the latency of the data link layer) Valid values (1 - 494): ");
                  memset(inputBuffer, 0x00, sizeof(inputBuffer));
                  bQuit = naiapp_query_ForQuitResponse(sizeof(inputBuffer), NAI_QUIT_CHAR, inputBuffer, &inputResponseCnt);
                  if (!bQuit)
                  {
                     naiapp_query_NumberFromResponse(&(busParams.tSet), inputBuffer, inputResponseCnt);

                     naiif_printf("\r\nPlease enter TtrHigh (Target Rotation Time - the maximum permissible rotation time of a token in the \
                        PB network) Valid values (256 - 16776960): ");
                     memset(inputBuffer, 0x00, sizeof(inputBuffer));
                     bQuit = naiapp_query_ForQuitResponse(sizeof(inputBuffer), NAI_QUIT_CHAR, inputBuffer, &inputResponseCnt);
                     if (!bQuit)
                     {
                        naiapp_query_NumberFromResponse(&(busParams.tTrHi), inputBuffer, inputResponseCnt);

                        naiif_printf("\r\nPlease enter TtrLow (Target Rotation Time - the maximum permissible rotation time of a token in \
                                     the PB network) Valid values (256 - 16776960): ");
                        memset(inputBuffer, 0x00, sizeof(inputBuffer));
                        bQuit = naiapp_query_ForQuitResponse(sizeof(inputBuffer), NAI_QUIT_CHAR, inputBuffer, &inputResponseCnt);
                        if (!bQuit)
                        {
                           naiapp_query_NumberFromResponse(&(busParams.tTrLow), inputBuffer, inputResponseCnt);

                           naiif_printf("\r\nPlease enter Max Retry Limit (Maximum number of frame repetitions indicates how often the \
                                        master repeats a request, after the end of the slot time, before it designates the responder as \
                                        not available) Valid values (0 - 7): ");

                           memset(inputBuffer, 0x00, sizeof(inputBuffer));
                           bQuit = naiapp_query_ForQuitResponse(sizeof(inputBuffer), NAI_QUIT_CHAR, inputBuffer, &inputResponseCnt);
                           if (!bQuit)
                           {
                              naiapp_query_NumberFromResponse(&(busParams.maxRetryLimit), inputBuffer, inputResponseCnt);


                              status = naibrd_PB_SetBusParams(inputPBConfig.cardIndex, inputPBConfig.module, &busParams);

                              if (status == NAI_SUCCESS)
                              {
                                 naiif_printf("Set Dynamic Bus Params - Success\r\n");
                              }
                              else
                              {
                                 naiif_printf("ERROR Trying to execute naibrd_PB_SetBusParams - Status = %d\r\n", status);
                              }
                           }
                        }
                     }
                  }
               }
            }
         }
      }
   }

   return bQuit;
}

/*****************************************************************************************************************************************/
/* Execute naibrd_PB_TestSegment */
bool_t EXEC_naibrd_PB_TestSegment()
{
   bool_t bQuit = NAI_FALSE;
   bool_t enable = NAI_FALSE;
   nai_status_t status = NAI_SUCCESS;
   int32_t segment = 0;
   int8_t inputBuffer[80];
   int32_t inputResponseCnt;

   naiif_printf("-------------------------------------------------\r\n");
   naiif_printf("TestSegment\r\n");
   naiif_printf("-------------------------------------------------\r\n");

   naiif_printf("2 Parameters Required to Execute naibrd_PB_EnableSegmentForUse\r\n");

   naiif_printf("\r\nPlease enter Segment to test. Valid values (1 - 8) and 255 for Aux port: ");
   memset(inputBuffer, 0x00, sizeof(inputBuffer));
   bQuit = naiapp_query_ForQuitResponse(sizeof(inputBuffer), NAI_QUIT_CHAR, inputBuffer, &inputResponseCnt);
   if (!bQuit)
   {
      naiapp_query_NumberFromResponse(&segment, inputBuffer, inputResponseCnt);

      bQuit = naiapp_query_ForBinaryResponse(sizeof(inputBuffer), NAI_QUIT_CHAR, inputBuffer, &inputResponseCnt,
         (int8_t *)"Please type 'Y' to Enable Segment or 'N' to Disable the Segment",
         (int8_t *)"Invalid value detected for Enable",
         NAI_FALSE, &enable);

      if (!bQuit)
      {
         status = naibrd_PB_EnableSegmentForUse(inputPBConfig.cardIndex, inputPBConfig.module, segment, enable);
         if (status == NAI_SUCCESS)
         {
            if (enable)
            {
               naiif_printf("Segment %d is now Enabled!\r\n", segment);
            }
            else
            {
               naiif_printf("Segment %d is now Disabled!\r\n", segment);
            }
         }
         else
         {
            naiif_printf("ERROR Trying to execute naibrd_PB_EnableSegmentForUse - Status = %d\r\n", status);
         }
      }
   }

   return bQuit;
}

/*****************************************************************************************************************************************/
/* Execute naibrd_PB_TestTermination */
bool_t EXEC_naibrd_PB_TestTermination()
{
   bool_t bQuit = NAI_FALSE;
   bool_t enable = NAI_FALSE;
   nai_status_t status = NAI_SUCCESS;
   int32_t segment = 0;
   uint32_t terminationEnableRegVal = 0;
   uint32_t segmentTermination = 0;
   int8_t inputBuffer[80];
   int32_t inputResponseCnt;

   naiif_printf("-------------------------------------------------\r\n");
   naiif_printf("TestTermination\r\n");
   naiif_printf("-------------------------------------------------\r\n");

   naiif_printf("2 Parameters Required to Execute naibrd_PB_SetTerminationEnableForSegments\r\n");

   naiif_printf("\r\nPlease enter Segment to test termination. Valid values (1 - 8) and 255 for Aux port: ");
   memset(inputBuffer, 0x00, sizeof(inputBuffer));
   bQuit = naiapp_query_ForQuitResponse(sizeof(inputBuffer), NAI_QUIT_CHAR, inputBuffer, &inputResponseCnt);
   if (!bQuit)
   {
      naiapp_query_NumberFromResponse(&segment, inputBuffer, inputResponseCnt);

      bQuit = naiapp_query_ForBinaryResponse(sizeof(inputBuffer), NAI_QUIT_CHAR, inputBuffer, &inputResponseCnt,
         (int8_t *)"Please type 'Y' to Enable Termination or 'N' to Disable Termination",
         (int8_t *)"Invalid value detected for Enable",
         NAI_FALSE, &enable);

      if (!bQuit)
      {

         status = naibrd_PB_GetTerminationEnableForSegments(inputPBConfig.cardIndex, inputPBConfig.module, &terminationEnableRegVal);

         if (status == NAI_SUCCESS)
         {
            naiif_printf("\r\nCurrent value of Termination Enable register before granting request: 0x%x\r\n", terminationEnableRegVal);
            switch (segment)
            {
            case SEGMENT_1 :
               segmentTermination = 0x01;
               break;

            case SEGMENT_2 :
               segmentTermination = 0x02;
               break;

            case SEGMENT_3 :
               segmentTermination = 0x04;
               break;

            case SEGMENT_4 :
               segmentTermination = 0x08;
               break;

            case SEGMENT_5 :
               segmentTermination = 0x10;
               break;

            case SEGMENT_6 :
               segmentTermination = 0x20;
               break;

            case SEGMENT_7 :
               segmentTermination = 0x40;
               break;

            case SEGMENT_8 :
               segmentTermination = 0x80;
               break;

            case SEGMENT_AUX :
               segmentTermination = 0x0100;
               break;

            default :
               status = NAI_ERROR_INVALID_RANGE;
               break;
            }

            if (status == NAI_SUCCESS)
            {
               if (enable)
               {
                  terminationEnableRegVal |= segmentTermination;
               }
               else
               {
                  terminationEnableRegVal &= (~segmentTermination);
               }

               status = naibrd_PB_SetTerminationEnableForSegments(inputPBConfig.cardIndex, inputPBConfig.module, terminationEnableRegVal);
               if (status == NAI_SUCCESS)
               {
                  naiif_printf("New value of Termination Enable register after granting request: 0x%x\r\n", terminationEnableRegVal);
                  if (enable)
                  {
                     naiif_printf("Segment %d is now Terminated!\r\n", segment);
                  }
                  else
                  {
                     naiif_printf("Segment %d is now NOT Terminated!\r\n", segment);
                  }
               }
               else
               {
                  naiif_printf("ERROR Trying to execute naibrd_PB_SetTerminationEnableForSegments - Status = %d\r\n", status);
               }
            }
         }
      }
   }

   return bQuit;
}

/*****************************************************************************************************************************************/
/* Execute naibrd_PB_SetOffline */
bool_t EXEC_naibrd_PB_SetOffline()
{
   bool_t bQuit = NAI_FALSE;
   bool_t redMode = NAI_FALSE;
   nai_status_t status = NAI_SUCCESS;
   int8_t inputBuffer[80];
   int32_t inputResponseCnt;

   naiif_printf("-------------------------------------------------\r\n");
   naiif_printf("SetOffline\r\n");
   naiif_printf("-------------------------------------------------\r\n");

   naiif_printf("1 Parameter Required to Execute naibrd_PB_SetOffline\r\n");
   bQuit = naiapp_query_ForBinaryResponse(sizeof(inputBuffer), NAI_QUIT_CHAR, inputBuffer, &inputResponseCnt,
      (int8_t *)"Please type 'Y' for Redundancy Mode or 'N' for Normal", (int8_t *)"Invalid value detected for Redundancy Mode",
      NAI_FALSE, &redMode);

   if (!bQuit)
   {
      status = naibrd_PB_SetOffline(inputPBConfig.cardIndex, inputPBConfig.module, (redMode)?1:0);
      if (status == NAI_SUCCESS)
      {
         naiif_printf("BUS WAS COMMANDED OFFLINE.  Please Confirm bus light is off for slave device\r\n");
      }
      else
      {
         naiif_printf("ERROR Trying to execute naibrd_PB_SetOffline - Status = %d\r\n", status);
      }
   }

   return bQuit;
}

/*****************************************************************************************************************************************/
/* Execute naibrd_PB_SetStop */
bool_t EXEC_naibrd_PB_SetStop()
{
   nai_status_t status = NAI_SUCCESS;

   naiif_printf("-------------------------------------------------\r\n");
   naiif_printf("SetStop\r\n");
   naiif_printf("-------------------------------------------------\r\n");

   naiif_printf("No Parameters Required to Execute naibrd_PB_SetStop\r\n");

   status = naibrd_PB_SetStop(inputPBConfig.cardIndex, inputPBConfig.module);
   if (status == NAI_SUCCESS)
   {
      naiif_printf("BUS WAS COMMANDED TO STOP.  Please Confirm bus light is on for slave device\r\n");
   }
   else
   {
      naiif_printf("ERROR Trying to execute naibrd_PB_SetStop - Status = %d\r\n", status);
   }

   return NAI_FALSE;
}

/*****************************************************************************************************************************************/
/* Execute naibrd_PB_SetClear */
bool_t EXEC_naibrd_PB_SetClear()
{
   bool_t bQuit = NAI_FALSE;
   bool_t redMode = NAI_FALSE;
   nai_status_t status = NAI_SUCCESS;
   int8_t inputBuffer[80];
   int32_t inputResponseCnt;

   naiif_printf("-------------------------------------------------\r\n");
   naiif_printf("SetClear\r\n");
   naiif_printf("-------------------------------------------------\r\n");

   naiif_printf("1 Parameter Required to Execute naibrd_PB_SetClear\r\n");

   bQuit = naiapp_query_ForBinaryResponse(sizeof(inputBuffer), NAI_QUIT_CHAR, inputBuffer, &inputResponseCnt,
      (int8_t *)"Please type 'Y' for Redundancy Mode or 'N' for Normal",
      (int8_t *)"Invalid value detected for Redundancy Mode", NAI_FALSE, &redMode);

   if (!bQuit)
   {
      status = naibrd_PB_SetClear(inputPBConfig.cardIndex, inputPBConfig.module, (redMode)?1:0);
      if (status == NAI_SUCCESS)
      {
         naiif_printf("BUS WAS COMMANDED TO CLEAR.  Please Confirm bus light is on for slave device\r\n");
      }
      else
      {
         naiif_printf("ERROR Trying to execute naibrd_PB_SetClear - Status = %d\r\n", status);
      }
   }

   return bQuit;
}

/*****************************************************************************************************************************************/
/* Execute naibrd_PB_SetOperate */
bool_t EXEC_naibrd_PB_SetOperate()
{
   bool_t bQuit = NAI_FALSE;
   bool_t redMode = NAI_FALSE;
   nai_status_t status = NAI_SUCCESS;
   int8_t inputBuffer[80];
   int32_t inputResponseCnt;

   naiif_printf("-------------------------------------------------\r\n");
   naiif_printf("SetOperate\r\n");
   naiif_printf("-------------------------------------------------\r\n");

   naiif_printf("1 Parameter Required to Execute naibrd_PB_SetOperate\r\n");

   bQuit = naiapp_query_ForBinaryResponse(sizeof(inputBuffer), NAI_QUIT_CHAR, inputBuffer, &inputResponseCnt,
      (int8_t *)"Please type 'Y' for Redundancy Mode or 'N' for Normal", (int8_t *)"Invalid value detected for Redundancy Mode",
      NAI_FALSE, &redMode);

   if (!bQuit)
   {
      status = naibrd_PB_SetOperate(inputPBConfig.cardIndex, inputPBConfig.module, (redMode)?1:0);
      if (status == NAI_SUCCESS)
      {
         naiif_printf("BUS WAS COMMANDED TO OPERATE.  Please Confirm bus light is on for slave device\r\n");
      }
      else
      {
         naiif_printf("ERROR Trying to execute naibrd_PB_SetOperate - Status = %d\r\n", status);
      }
   }

   return bQuit;
}

/*****************************************************************************************************************************************/
/* Execute naibrd_PB_AcyclicRead */
bool_t EXEC_naibrd_PB_AcyclicRead()
{
   bool_t bQuit = NAI_FALSE;
   nai_status_t status = NAI_SUCCESS;
   int8_t inputBuffer[80];
   int32_t inputResponseCnt;

   naiif_printf("-------------------------------------------------\r\n");
   naiif_printf("AcyclicRead\r\n");
   naiif_printf("-------------------------------------------------\r\n");

   naiif_printf("\r\nPlease enter SlaveAddress (2 - 128): ");
   memset(inputBuffer, 0x00, sizeof(inputBuffer));
   bQuit = naiapp_query_ForQuitResponse(sizeof(inputBuffer), NAI_QUIT_CHAR, inputBuffer, &inputResponseCnt);
   if (!bQuit)
   {
      int32_t slaveAddr = 0;
      naiapp_query_NumberFromResponse(&slaveAddr, inputBuffer, inputResponseCnt);

      naiif_printf("\r\nPlease enter Slot Number: ");
      memset(inputBuffer, 0x00, sizeof(inputBuffer));
      bQuit = naiapp_query_ForQuitResponse(sizeof(inputBuffer), NAI_QUIT_CHAR, inputBuffer, &inputResponseCnt);

      if (!bQuit)
      {
         int32_t slotNumber = 0;
         naiapp_query_NumberFromResponse(&slotNumber, inputBuffer, inputResponseCnt);

         naiif_printf("\r\nPlease enter Param Index: ");
         memset(inputBuffer, 0x00, sizeof(inputBuffer));
         bQuit = naiapp_query_ForQuitResponse(sizeof(inputBuffer), NAI_QUIT_CHAR, inputBuffer, &inputResponseCnt);

         if (!bQuit)
         {
            int32_t paramIndex = 0;
            naiapp_query_NumberFromResponse(&paramIndex, inputBuffer, inputResponseCnt);

            naiif_printf("\r\nPlease enter Param Data Length: ");
            memset(inputBuffer, 0x00, sizeof(inputBuffer));
            bQuit = naiapp_query_ForQuitResponse(sizeof(inputBuffer), NAI_QUIT_CHAR, inputBuffer, &inputResponseCnt);

            if (!bQuit)
            {
               int32_t paramDataLength = 0;
               int8_t data[NAIBRD_PB_MAX_CFG_DATA_LENGTH];
               int32_t dataReadCount = 0;

               naiapp_query_NumberFromResponse(&paramDataLength, inputBuffer, inputResponseCnt);

               status = naibrd_PB_AcyclicRead(inputPBConfig.cardIndex, inputPBConfig.module, slaveAddr, slotNumber, paramIndex,
                  paramDataLength, &dataReadCount, &(data[0]));

               if (status == NAI_SUCCESS)
               {
                  int i = 0;
                  naiif_printf("naibrd_PB_AcyclicRead - Success\r\n");
                  naiif_printf("Acyclic Read Data:\r\n");

                  for (i = 0; i < dataReadCount; i++)
                  {
                     naiif_printf("0x%02x ", (data[i] & 0xFF));
                  }
                  naiif_printf("\r\n\r\n");
               }
               else
               {
                  naiif_printf("ERROR naibrd_PB_AcyclicRead - Status = %d\r\n", status);
               }
            }
         }
      }
   }

   return bQuit;
}

/*****************************************************************************************************************************************/
/* Execute naibrd_PB_AcyclicWrite */
bool_t EXEC_naibrd_PB_AcyclicWrite()
{
   bool_t bQuit = NAI_FALSE;
   nai_status_t status = NAI_SUCCESS;
      int8_t inputBuffer[80];
   int32_t inputResponseCnt;

   naiif_printf("-------------------------------------------------\r\n");
   naiif_printf("AcyclicWrite\r\n");
   naiif_printf("-------------------------------------------------\r\n");

   naiif_printf("\r\nPlease enter SlaveAddress (2 - 128): ");
   memset(inputBuffer, 0x00, sizeof(inputBuffer));
   bQuit = naiapp_query_ForQuitResponse(sizeof(inputBuffer), NAI_QUIT_CHAR, inputBuffer, &inputResponseCnt);
   if (!bQuit)
   {
      int32_t slaveAddr = 0;
      naiapp_query_NumberFromResponse(&slaveAddr, inputBuffer, inputResponseCnt);

      naiif_printf("\r\nPlease enter Slot Number: ");
      memset(inputBuffer, 0x00, sizeof(inputBuffer));
      bQuit = naiapp_query_ForQuitResponse(sizeof(inputBuffer), NAI_QUIT_CHAR, inputBuffer, &inputResponseCnt);

      if (!bQuit)
      {
         int32_t slotNumber = 0;
         naiapp_query_NumberFromResponse(&slotNumber, inputBuffer, inputResponseCnt);

         naiif_printf("\r\nPlease enter Param Index: ");
         memset(inputBuffer, 0x00, sizeof(inputBuffer));
         bQuit = naiapp_query_ForQuitResponse(sizeof(inputBuffer), NAI_QUIT_CHAR, inputBuffer, &inputResponseCnt);

         if (!bQuit)
         {
            int32_t paramIndex = 0;
            naiapp_query_NumberFromResponse(&paramIndex, inputBuffer, inputResponseCnt);

            naiif_printf("\r\nPlease enter Param Data Length: ");
            memset(inputBuffer, 0x00, sizeof(inputBuffer));
            bQuit = naiapp_query_ForQuitResponse(sizeof(inputBuffer), NAI_QUIT_CHAR, inputBuffer, &inputResponseCnt);

            if (!bQuit)
            {
               int32_t i = 0;
               int32_t paramDataLength = 0;
               int32_t paramData[NAIBRD_PB_MAX_CMD_PARAMS];
               naiapp_query_NumberFromResponse(&paramDataLength, inputBuffer, inputResponseCnt);

               for (i = 0; i < paramDataLength; i++)
               {
                  naiif_printf("\r\nEnter Value for Param Data[%d]: ");
                  memset(inputBuffer, 0x00, sizeof(inputBuffer));
                  bQuit = naiapp_query_ForQuitResponse(sizeof(inputBuffer), NAI_QUIT_CHAR, inputBuffer, &inputResponseCnt);

                  if (!bQuit)
                  {
                     naiapp_query_NumberFromResponse(&(paramData[i]), inputBuffer, inputResponseCnt);
                  }
               }

               if (!bQuit && status == NAI_SUCCESS)
               {
                  status = naibrd_PB_AcyclicWrite(inputPBConfig.cardIndex, inputPBConfig.module, slaveAddr, slotNumber, paramIndex,
                                                  paramDataLength, &(paramData[0]));

                  if (status == NAI_SUCCESS)
                  {
                     naiif_printf("naibrd_PB_AcyclicRead - Success\r\n");
                  }
                  else
                  {
                     naiif_printf("ERROR naibrd_PB_AcyclicRead - Status = %d\r\n", status);
                  }
               }
            }
         }
      }
   }

   return bQuit;
}

/*****************************************************************************************************************************************/
/* Execute naibrd_PB_InitiateCommunication */
bool_t EXEC_naibrd_PB_InitiateCommunication()
{
   bool_t bQuit = NAI_FALSE;
   nai_status_t status = NAI_SUCCESS;
   int8_t inputBuffer[80];
   int32_t inputResponseCnt;

   naiif_printf("-------------------------------------------------\r\n");
   naiif_printf("InitiateCommunication\r\n");
   naiif_printf("-------------------------------------------------\r\n");

   naiif_printf("\r\nPlease enter SlaveAddress (2 - 128): ");
   memset(inputBuffer, 0x00, sizeof(inputBuffer));

   bQuit = naiapp_query_ForQuitResponse(sizeof(inputBuffer), NAI_QUIT_CHAR, inputBuffer, &inputResponseCnt);
   if (!bQuit)
   {
      int32_t slaveAddr = 0;
      naiapp_query_NumberFromResponse(&slaveAddr, inputBuffer, inputResponseCnt);

      naiif_printf("\r\nPlease enter Comm Ref: ");
      memset(inputBuffer, 0x00, sizeof(inputBuffer));
      bQuit = naiapp_query_ForQuitResponse(sizeof(inputBuffer), NAI_QUIT_CHAR, inputBuffer, &inputResponseCnt);

      if (!bQuit)
      {
         int32_t commRef = 0;
         naiapp_query_NumberFromResponse(&commRef, inputBuffer, inputResponseCnt);

         naiif_printf("\r\nPlease enter Max Timeout in Milliseconds: ");

         memset(inputBuffer, 0x00, sizeof(inputBuffer));
         bQuit = naiapp_query_ForQuitResponse(sizeof(inputBuffer), NAI_QUIT_CHAR, inputBuffer, &inputResponseCnt);

         if (!bQuit)
         {
            int32_t maxTimeoutInMS = 0;
            naiapp_query_NumberFromResponse(&maxTimeoutInMS, inputBuffer, inputResponseCnt);

            status = naibrd_PB_InitiateCommunication(inputPBConfig.cardIndex, inputPBConfig.module, slaveAddr, commRef, maxTimeoutInMS);
            if (status == NAI_SUCCESS)
            {
               naiif_printf("Initiate Communication - Success\r\n");
            }
            else
            {
               naiif_printf("ERROR initiating communication - Status = %d\r\n", status);
            }
         }
      }
   }

   return bQuit;
}

/*****************************************************************************************************************************************/
/* Execute naibrd_PB_AbortCommunication */
bool_t EXEC_naibrd_PB_AbortCommunication()
{
   bool_t bQuit = NAI_FALSE;
   nai_status_t status = NAI_SUCCESS;
   int8_t inputBuffer[80];
   int32_t inputResponseCnt;

   naiif_printf("-------------------------------------------------\r\n");
   naiif_printf("AbortCommunication\r\n");
   naiif_printf("-------------------------------------------------\r\n");

   naiif_printf("\r\nPlease enter SlaveAddress (2 - 128): ");
   memset(inputBuffer, 0x00, sizeof(inputBuffer));

   bQuit = naiapp_query_ForQuitResponse(sizeof(inputBuffer), NAI_QUIT_CHAR, inputBuffer, &inputResponseCnt);
   if (!bQuit)
   {
      int32_t slaveAddr = 0;
      naiapp_query_NumberFromResponse(&slaveAddr, inputBuffer, inputResponseCnt);

      naiif_printf("\r\nPlease enter Comm Ref: ");
      memset(inputBuffer, 0x00, sizeof(inputBuffer));
      bQuit = naiapp_query_ForQuitResponse(sizeof(inputBuffer), NAI_QUIT_CHAR, inputBuffer, &inputResponseCnt);

      if (!bQuit)
      {
         int32_t commRef = 0;
         naiapp_query_NumberFromResponse(&commRef, inputBuffer, inputResponseCnt);

         status = naibrd_PB_AbortCommunication(inputPBConfig.cardIndex, inputPBConfig.module, slaveAddr, commRef);
         if (status == NAI_SUCCESS)
         {
            naiif_printf("Abort Communication - Success\r\n");
         }
         else
         {
            naiif_printf("ERROR aborting communication - Status = %d\r\n", status);
         }
      }
   }

   return bQuit;
}

/*****************************************************************************************************************************************/
/* Execute naibrd_PB_GetLockStatusForSegments */
bool_t EXEC_naibrd_PB_GetLockStatusForSegments()
{
   bool_t bQuit = NAI_FALSE;
   nai_status_t status = NAI_SUCCESS;
   uint32_t lockStatusRegValue = 0;

   naiif_printf("-------------------------------------------------\r\n");
   naiif_printf("GetLockStatusForSegment\r\n");
   naiif_printf("-------------------------------------------------\r\n");

   status = naibrd_PB_GetLockStatusForSegments(inputPBConfig.cardIndex, inputPBConfig.module, &lockStatusRegValue);
   if (status == NAI_SUCCESS)
   {
      naiif_printf("Segments Lock Status = 0x%x\r\n", lockStatusRegValue);
      if (lockStatusRegValue & 0x00000001)
         naiif_printf("Segment 1 Lock Status = LOCKED\r\n");
      else
         naiif_printf("Segment 1 Lock Status = NOT LOCKED\r\n");

      if (lockStatusRegValue & 0x00000002)
         naiif_printf("Segment 2 Lock Status = LOCKED\r\n");
      else
         naiif_printf("Segment 2 Lock Status = NOT LOCKED\r\n");

      if (lockStatusRegValue & 0x00000004)
         naiif_printf("Segment 3 Lock Status = LOCKED\r\n");
      else
         naiif_printf("Segment 3 Lock Status = NOT LOCKED\r\n");

      if (lockStatusRegValue & 0x00000008)
         naiif_printf("Segment 4 Lock Status = LOCKED\r\n");
      else
         naiif_printf("Segment 4 Lock Status = NOT LOCKED\r\n");

      if (lockStatusRegValue & 0x00000010)
         naiif_printf("Segment 5 Lock Status = LOCKED\r\n");
      else
         naiif_printf("Segment 5 Lock Status = NOT LOCKED\r\n");

      if (lockStatusRegValue & 0x00000020)
         naiif_printf("Segment 6 Lock Status = LOCKED\r\n");
      else
         naiif_printf("Segment 6 Lock Status = NOT LOCKED\r\n");

      if (lockStatusRegValue & 0x00000040)
         naiif_printf("Segment 7 Lock Status = LOCKED\r\n");
      else
         naiif_printf("Segment 7 Lock Status = NOT LOCKED\r\n");

      if (lockStatusRegValue & 0x00000080)
         naiif_printf("Segment 8 Lock Status = LOCKED\r\n");
      else
         naiif_printf("Segment 8 Lock Status = NOT LOCKED\r\n");

      if (lockStatusRegValue & 0x00000100)
         naiif_printf("Segment Aux Lock Status = LOCKED\r\n");
      else
         naiif_printf("Segment Aux Lock Status = NOT LOCKED\r\n");
   }
   else
   {
      naiif_printf("ERROR naibrd_PB_GetLockStatusForSegments - Status = %d\r\n", status);
   }

   return bQuit;
}

/**************************************************************************************************************/
/**
 * <summary>
 * naiapp_Run_PB_BasicOps illustrates...
 * </summary>
 */
/**************************************************************************************************************/
static bool_t naiapp_Run_PB_BasicOps(void)
{
   bool_t bQuit = NAI_FALSE;
   int8_t inputBuffer[80];
   int32_t inputResponseCnt;

   do
   {
      naiif_printf("\r\n\r\n");
      naiif_printf("**************************************************************************\r\n");
      naiif_printf("* A. Execute naibrd_PB_GetMS0ConnectionStatus (Cyclic Status)            *\r\n");
      naiif_printf("* B. Execute naibrd_PB_ResetMS0ConnectionCounters (Cyclic Counters)      *\r\n");
      naiif_printf("* C. Execute naibrd_PB_GetAlarmCounters                                  *\r\n");
      naiif_printf("* D. Execute naibrd_PB_ResetAlarmCounters                                *\r\n");
      naiif_printf("* E. Execute naibrd_PB_GetLastAlarmData                                  *\r\n");
      naiif_printf("* F. Execute naibrd_PB_GeSlaveDiagnostics                                *\r\n");
      naiif_printf("* G. Execute naibrd_PB_SetandEnableMaxCycleCounter                       *\r\n");
      naiif_printf("* H. Execute naibrd_PB_GetCPULoad                                        *\r\n");
      naiif_printf("* I. Execute naibrd_PB_StartReconfiguration                              *\r\n");
      naiif_printf("* J. Execute naibrd_PB_SetSystemTime                                     *\r\n");
#ifdef _FUTURE_CAPABILITY
      naiif_printf("* K. Execute naibrd_PB_EnableRedundancy                                  *\r\n");
#else
      naiif_printf("* K.                                                                     *\r\n");
#endif
      naiif_printf("* L. Execute naibrd_PB_GetLiveList                                       *\r\n");
      naiif_printf("* M.                                                                     *\r\n");
      naiif_printf("* N. Execute naibrd_PB_BusParamReconfiguration                           *\r\n");
      naiif_printf("* O. Execute naibrd_PB_GetOperationMode                                  *\r\n");
      naiif_printf("* P. Execute naibrd_PB_SetPollCycleMode                                  *\r\n");
      naiif_printf("* Q. QUIT                                                                *\r\n");
      naiif_printf("* R. Execute naibrd_PB_ReadIOData                                        *\r\n");
      naiif_printf("* S. Execute naibrd_PB_GetStatistics                                     *\r\n");
      naiif_printf("* T.                                                                     *\r\n");
      naiif_printf("* U. Execute naibrd_PB_SetNewIOConfig                                    *\r\n");
      naiif_printf("* V. Execute naibrd_PB_GetPSAKVersion                                    *\r\n");
      naiif_printf("* W. Execute naibrd_PB_WriteIOData                                       *\r\n");
      naiif_printf("* X. Execute naibrd_PB_SetDynamicBusParams                               *\r\n");
      naiif_printf("* Y. Execute naibrd_PB_SetBusParams                                      *\r\n");
      naiif_printf("* Z. Execute naibrd_PB_SetTerminationEnableForSegments                   *\r\n");
      naiif_printf("--------------------------------------------------------------------------\r\n");
      naiif_printf("* 0. Execute naibrd_PB_EnableSegmentForUse                               *\r\n");
      naiif_printf("* 1. Execute naibrd_PB_SetOffline                                        *\r\n");
      naiif_printf("* 2. Execute naibrd_PB_SetStop                                           *\r\n");
      naiif_printf("* 3. Execute naibrd_PB_SetClear                                          *\r\n");
      naiif_printf("* 4. Execute naibrd_PB_SetOperate                                        *\r\n");
      naiif_printf("* 5. Execute naibrd_PB_AcyclicRead                                       *\r\n");
      naiif_printf("* 6. Execute naibrd_PB_AcyclicWrite                                      *\r\n");
      naiif_printf("* 7. Execute naibrd_PB_InitiateCommunication                             *\r\n");
      naiif_printf("* 8. Execute naibrd_PB_AbortCommunication                                *\r\n");
      naiif_printf("* 9. Execute naibrd_PB_GetLockStatusForSegments                          *\r\n");
      naiif_printf("**************************************************************************\r\n");

      naiif_printf("\r\nPlease enter your selection: ");
      memset(inputBuffer, 0x00, sizeof(inputBuffer));

      bQuit = naiapp_query_ForQuitResponse(sizeof(inputBuffer), NAI_QUIT_CHAR, inputBuffer, &inputResponseCnt);
      if (!bQuit)
      {
         switch (tolower(inputBuffer[0]))
         {
         case 'a' :
            bQuit = EXEC_naibrd_PB_GetMS0ConnectionStatus();
            break;
         case 'b' :
            bQuit = EXEC_naibrd_PB_ResetMS0ConnectionCounters();
            break;
         case 'c' :
            bQuit = EXEC_naibrd_PB_GetAlarmCounters();
            break;
         case 'd' :
            bQuit = EXEC_naibrd_PB_ResetAlarmCounters();
            break;
         case 'e' :
            bQuit = EXEC_naibrd_PB_GetLastAlarmData();
            break;
         case 'f' :
            bQuit = EXEC_naibrd_PB_GetSlaveDiagnostics();
            break;
         case 'g' :
            bQuit = EXEC_naibrd_PB_SetandEnableMaxCycleCounter();
            break;
         case 'h' :
            bQuit = EXEC_naibrd_PB_GetCPULoad();
            break;
         case 'i' :
            bQuit = EXEC_naibrd_PB_StartReconfiguration();
            break;
         case 'j' :
            bQuit = EXEC_naibrd_PB_SetSystemTime();
            break;
         case 'k' :
#ifdef _FUTURE_CAPABILITY
            bQuit = EXEC_naibrd_PB_GetSystemTime();
#endif
            break;
         case 'l' :
            bQuit = EXEC_naibrd_PB_GetLiveList();
            break;
         case 'm' :
            break;
         case 'n' :
            bQuit = EXEC_naibrd_PB_BusParamReconfiguration();
            break;
         case 'o' :
            bQuit = EXEC_naibrd_PB_GetOperationMode();
            break;
         case 'p' :
            bQuit = EXEC_naibrd_PB_SetPollCycleMode();
            break;
         case 'q' :
            bQuit = NAI_TRUE;
            break;
         case 'r' :
            bQuit = EXEC_naibrd_PB_ReadIOData();
            break;
         case 's' :
            bQuit = EXEC_naibrd_PB_GetStatistics();
            break;
         case 't' :
            break;
         case 'u' :
            bQuit = EXEC_naibrd_PB_SetNewIOConfig();
            break;
         case 'v' :
            bQuit = EXEC_naibrd_PB_GetPSAKVersion();
            break;
         case 'w' :
            bQuit = EXEC_naibrd_PB_WriteIOData();
            break;
         case 'x' :
            bQuit = EXEC_naibrd_PB_SetDynamicBusParams();
            break;
         case 'y' :
            bQuit = EXEC_naibrd_PB_SetBusParams();
            break;
         case 'z' :
#ifdef _FUTURE_CAPABILITY
            bQuit = EXEC_naibrd_PB_EnableRedundancy();
#endif
            bQuit = EXEC_naibrd_PB_TestTermination();
            break;
         case '0' :
            bQuit = EXEC_naibrd_PB_TestSegment();
            break;
         case '1' :
            bQuit = EXEC_naibrd_PB_SetOffline();
            break;
         case '2' :
            bQuit = EXEC_naibrd_PB_SetStop();
            break;
         case '3' :
            bQuit = EXEC_naibrd_PB_SetClear();
            break;
         case '4' :
            bQuit = EXEC_naibrd_PB_SetOperate();
            break;
         case '5' :
            bQuit = EXEC_naibrd_PB_AcyclicRead();
            break;
         case '6' :
            bQuit = EXEC_naibrd_PB_AcyclicWrite();
            break;
         case '7' :
            bQuit = EXEC_naibrd_PB_InitiateCommunication();
            break;
         case '8' :
            bQuit = EXEC_naibrd_PB_AbortCommunication();
            break;
         case '9' :
            bQuit = EXEC_naibrd_PB_GetLockStatusForSegments();
            break;
         }
      }
   } while (!bQuit);

   return bQuit;
}

static void printMasterState(NAIBRD_PB_DPM_MASTER_STATE masterState)
{
   switch (masterState)
   {
   case DPM_MASTER_STATE_OK :
      naiif_printf("Master state: OK\r\n");
      break;
   case DPM_MASTER_STATE_AUTOCLEAR :
      naiif_printf("WARNING: Master state: AUTOCLEAR\r\n");
      break;
   case DPM_MASTER_STATE_DISTURBED_BUS_ERROR :
      naiif_printf("WARNING: Master state: DISTURBED BUS ERROR\r\n");
      break;
   case DPM_MASTER_STATE_DOUBLE_ADDRESS_ERROR :
      naiif_printf("WARNING: Master state: DOUBLE ADDRESS ERROR\r\n");
      break;
   case DPM_MASTER_STATE_PROTOCOL_ERROR :
      naiif_printf("WARNING: Master state: PROTOCOL ERROR\r\n");
      break;
   case DPM_MASTER_STATE_HARDWARE_ERROR :
      naiif_printf("WARNING: Master state: HARDWARE ERROR\r\n");
      break;
   case DPM_MASTER_STATE_APPL_WATCHDOG_EXPIRED :
      naiif_printf("WARNING: Master state: APPL WATCHDOG EXPIRED\r\n");
      break;
   case DPM_MASTER_STATE_ASPC2_WATCHDOG_EXPIRED :
      naiif_printf("WARNING: Master state: ASPC2 WATCHDOG EXPIRED\r\n");
      break;
   case DPM_MASTER_STATE_NO_TRAFFIC :
      naiif_printf("WARNING: Master state: NO TRAFFIC\r\n");
      break;
   case DPM_MASTER_STATE_NO_FREE_ADDRESS :
      naiif_printf("WARNING: Master state: NO FREE ADDRESS\r\n");
      break;
   case DPM_MASTER_STATE_NO_PARAMETERS :
      naiif_printf("WARNING: Master state: NO PARAMETERS\r\n");
      break;
   case DPM_MASTER_STATE_LICENSE_ERROR :
      naiif_printf("WARNING: Master state: LICENSE ERROR\r\n");
      break;
   default :
      naiif_printf("UNKOWN MASTER STATE!\r\n");
      break;
   }
}

static void printOperationMode(NAIBRD_PB_DPM_OPERATION_MODE operationMode)
{
   switch (operationMode)
   {
   case DPM_OPERATION_MODE_OFFLINE :
      naiif_printf("Mode: OFFLINE\r\n");
      break;
   case DPM_OPERATION_MODE_STOP :
      naiif_printf("Mode: STOP\r\n");
      break;
   case DPM_OPERATION_MODE_CLEAR :
      naiif_printf("Mode: CLEAR\r\n");
      break;
   case DPM_OPERATION_MODE_OPERATE :
      naiif_printf("Mode: OPERATE\r\n");
      break;
   case DPM_OPERATION_MODE_RED_CLEAR :
      naiif_printf("Mode: RED CLEAR\r\n");
      break;
   case DPM_OPERATION_MODE_RED_OPERATE :
      naiif_printf("Mode: RED OPERATE\r\n");
      break;
   case DPM_OPERATION_MODE_RED_OFFLINE :
      naiif_printf("Mode: RED OFFLINE\r\n");
      break;
   case DPM_OPERATION_MODE_AUTOBAUD :
      naiif_printf("Mode: AUTOBAUD\r\n");
      break;
   default :
      naiif_printf("Mode is undefined\r\n");
      break;
   }
}

static void naibrd_PB_PrintPBStatus(int32_t pbStatus)
{
   switch (pbStatus)
   {
   case NAI_PB_REQUEST_STILL_RUNNING_ERROR :
      naiif_printf("PB Requested Operation is Still Running! Status = %d\r\n", pbStatus);
      break;
   case NAI_PB_STRING_LENGTH_ERROR :
      naiif_printf("PB String Length Error! Status = %d\r\n", pbStatus);
      break;
   case NAI_PB_TIMEOUT_ERROR :
      naiif_printf("PB Function Request Timed Out Prior to Completion! Status = %d\r\n", pbStatus);
      break;
   case NAI_PB_ARRAY_BOUNDS_EXCEEDED_ERROR :
      naiif_printf("PB Array Bounds Were Exceeded! Status = %d\r\n", pbStatus);
      break;
   case NAI_PB_BUSY_ERROR :
      naiif_printf("PB Busy Processing! Status = %d\r\n", pbStatus);
      break;
   case NAI_PB_SUCCESS :
      naiif_printf("PB Success! Status = %d\r\n", pbStatus);
      break;
   default:
      naiif_printf("PB UNKNOWN ERROR CODE! Status = %d\r\n", pbStatus);
      break;
   }
}

PB BasicOps

Table of Contents

Integrator Resources

PB BasicOps

PB BasicOps Sample Application (SSK 2.x)

Overview

Prerequisites

How to Run

Board Connection and Module Selection

Program Structure

Entry Point

Command Loop

Connection Status and Diagnostics

I/O Data Operations

Master State Control

Troubleshooting Reference

Full Source

Help Bot