TTL Summary

TTL Summary Sample Application (SSK 2.x)

Overview

The TTL Summary sample application demonstrates how to read and manage fault status across all channels of a TTL module using the NAI Software Support Kit (SSK 2.x). It covers the core status operations you will need in your own application: displaying latched BIT, overcurrent, and summary status for every channel, clearing latched status registers, forcing a BIT error for diagnostic testing, and configuring interrupts on the summary status register.

The summary register is the key concept in this sample. It is a bit-mapped register where each bit corresponds to a channel (bit 0 = channel 1). A bit reads 1 when the corresponding channel has detected a fault in either its BIT status or overcurrent status. This gives you a single register to poll for any fault condition across the entire module, rather than reading BIT and overcurrent status individually for each channel.

This sample supports TTL module types: TL1 and TL2. It serves as a practical API reference — each menu command maps directly to one or more naibrd_TTL_*() API calls that you can lift into your own code.

Note	This pattern is new to SSK 2.x and has no SSK 1.x counterpart. For related TTL samples, see TTL Interrupt (SSK 1.x) and TTL BasicOps (SSK 1.x).

Prerequisites

Before running this sample, make sure you have:

An NAI board with a TTL module installed (TL1 or TL2).
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.

How to Run

Launch the ttl_summary executable from your build output directory. On startup the application looks for a configuration file (default_TTL_Summary.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, select a channel for interrupt operations, then use the command menu to display status, configure interrupts, force BIT errors, and clear status registers.

The recommended sequence for exploring this sample is:

CLEAR — clear all latched status registers to start from a clean state.
STAT — display all latched statuses (should all be zero after clearing).
INT — configure the interrupt subsystem on your selected channel.
FAULT — force a BIT error on the selected channel.
STAT — display statuses again to see the BIT and summary bits set.
CLEAR — clear all statuses to reset.

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 TTL.

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_TTL_Summary.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() so downstream code can adapt to the specific TTL variant installed.

#if defined (NAIBSP_CONFIG_SOFTWARE_OS_VXWORKS)
int32_t ttl_summary(void)
#else
int32_t main(void)
#endif
{
   int32_t cardIndex;
   int32_t moduleCnt;
   int32_t module;
   bool_t stop = NAI_FALSE;
   uint32_t moduleID;
   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(), DEF_TTL_CARD_INDEX, &cardIndex);
         if (stop != NAI_TRUE)
         {
            check_status(naibrd_GetModuleCount(cardIndex, &moduleCnt));
            stop = naiapp_query_ModuleNumber(moduleCnt, DEF_TTL_MODULE, &module);
            if (stop != NAI_TRUE)
            {
               check_status(naibrd_GetModuleName(cardIndex, module, &moduleID));
               if ((moduleID != 0))
               {
                  Run_TTL_Summary(cardIndex, module, moduleID);
               }
            }
         }
      }
   }

   naiapp_access_CloseAllOpenCards();
   return 0;
}

After module selection, Run_TTL_Summary() calls naibrd_TTL_GetChannelCount() to determine how many channels the installed module supports, then hands off to the command loop in Cfg_TTL_Channel().

maxchannel = naibrd_TTL_GetChannelCount(modid);
if (maxchannel == 0)
{
   naiif_printf(" *** Module selection not recognized as TTL module. ***\r\n\r\n");
}
else
{
   Cfg_TTL_Channel(cardIndex, module, maxchannel);
}

modid — the module ID returned by naibrd_GetModuleName().
naibrd_TTL_GetChannelCount() — returns 0 if the module ID does not match a known TTL module type.

Program Structure

Application Parameters

The sample stores connection and module context in an naiapp_AppParameters_t struct:

naiapp_AppParameters_t  ttlparams;
p_naiapp_AppParameters_t ttlParams = &ttlparams;

ttlParams->cardIndex = cardIndex;
ttlParams->module = module;
ttlParams->maxChannels = MaxChannel;
ttlParams->channel = chan;

cardIndex — identifies the board.
module — the slot containing the TTL module.
maxChannels — the channel count for the installed module.
channel — the channel selected for interrupt operations. This is queried once when entering the command loop.

In your own application, you will track these same values however is convenient — the struct is a sample convenience, not an API requirement.

The sample presents four commands through its menu system:

Command Menu Label Operation

Command	Menu Label	Operation
`INT`	TTL Configure Interrupt	Configure interrupt on the selected channel
`STAT`	TTL Display Status	Display latched BIT, overcurrent, and summary status for all channels
`CLEAR`	TTL Clear Status	Clear all latched status registers across all channels
`FAULT`	TTL Force BIT Error	Force a BIT error on the selected channel

INT

TTL Configure Interrupt

Configure interrupt on the selected channel

STAT

TTL Display Status

Display latched BIT, overcurrent, and summary status for all channels

CLEAR

TTL Clear Status

Clear all latched status registers across all channels

FAULT

TTL Force BIT Error

Force a BIT error on the selected channel

The menu system is a sample convenience — in your own code, call these API functions directly. The command table and menu handling use the standard naiapp_cmdtbl_params_t pattern shared across all SSK 2.x samples.

Display Configuration

Reading Latched Status

To read the latched fault status for every channel on a TTL module in your own application, call naibrd_TTL_GetChanMappedStatus() with each status type. The sample reads three status registers per channel:

nai_status_bit_t statusBit;

for (chan = 1; chan <= ttlParams->maxChannels; chan++)
{
   check_status(naibrd_TTL_GetChanMappedStatus(cardIndex, module, chan,
      NAIBRD_TTL_STATUS_BIT_LATCHED, &statusBit));

   check_status(naibrd_TTL_GetChanMappedStatus(cardIndex, module, chan,
      NAIBRD_TTL_STATUS_OVERCURRENT_LATCHED, &statusBit));

   check_status(naibrd_TTL_GetChanMappedStatus(cardIndex, module, chan,
      NAIBRD_TTL_STATUS_SUMMARY_LATCHED, &statusBit));
}

cardIndex — identifies the board.
module — the slot containing the TTL module.
chan — the channel number (1-based).
NAIBRD_TTL_STATUS_BIT_LATCHED — the latched built-in test status. Reads 1 if the channel has detected a BIT failure since the status was last cleared.
NAIBRD_TTL_STATUS_OVERCURRENT_LATCHED — the latched overcurrent status. Reads 1 if the channel has detected an overcurrent condition.
NAIBRD_TTL_STATUS_SUMMARY_LATCHED — the latched summary status. Reads 1 if either BIT or overcurrent has been detected on this channel. This is the aggregated fault indicator.

The sample formats the output as a table showing all three status values per channel, making it easy to identify which channels have active faults and what type of fault was detected.

Understanding the Summary Register

The summary register provides a consolidated view of all fault conditions on a channel. Rather than polling BIT and overcurrent status separately, you can check the summary bit for a channel — if it reads 1, at least one fault condition exists. This is particularly useful in applications that monitor many channels and need a fast way to detect any fault.

A latched summary bit remains set until you explicitly clear it by writing a 1 to the corresponding bit position.

Clearing Latched Status

To clear all latched status registers in your own application, call naibrd_TTL_ClearChanMappedStatus() for each status type on each channel:

for (chan = 1; chan <= ttlParams->maxChannels; chan++)
{
   status = check_status(naibrd_TTL_ClearChanMappedStatus(cardIndex, module, chan,
      NAIBRD_TTL_STATUS_BIT_LATCHED));
   if (status == NAI_SUCCESS)
   {
      status = check_status(naibrd_TTL_ClearChanMappedStatus(cardIndex, module, chan,
         NAIBRD_TTL_STATUS_OVERCURRENT_LATCHED));
      if (status == NAI_SUCCESS)
      {
         status = check_status(naibrd_TTL_ClearChanMappedStatus(cardIndex, module, chan,
            NAIBRD_TTL_STATUS_SUMMARY_LATCHED));
      }
   }
}

The sample clears all three status types (BIT, overcurrent, and summary) for every channel. The order matters — if you clear summary without clearing the underlying BIT or overcurrent status, the summary bit may reassert on the next status scan. Clear all three to ensure a clean state.

Important

Common Errors

Summary bit reasserts after clearing — If the underlying fault condition (BIT or overcurrent) is still active, the summary bit will reassert. Clear BIT and overcurrent status as well, or resolve the underlying hardware condition.
NAI_ERROR_NOT_SUPPORTED — The module at the selected slot is not a recognized TTL module type. Verify the module type with naibrd_TTL_GetChannelCount().

Optional Interrupt Setup

The sample provides optional interrupt configuration on the summary status register. When enabled, the module generates a hardware interrupt whenever a summary status bit transitions, rather than requiring your application to poll the status registers.

Note	The interrupt callback mechanism requires POSIX thread support. This sample is available on Petalinux and VxWorks but not on DEOS. Consult the SSK 2.x Software Development Guide for platform-specific build configuration.

Configuring the Interrupt

To set up an interrupt on the summary status register in your own application, call the following sequence of API functions:

uint32_t vector = 0xB0u;

/* Step 1: Connect the ISR callback (once per card) */
check_status(naibrd_ConnectISR(cardIndex, SampleCallBack));

/* Step 2: Set trigger type to edge */
check_status(naibrd_TTL_SetChanMappedInterruptTriggerType(cardIndex, module, chan,
   NAIBRD_TTL_STATUS_SUMMARY_LATCHED, NAIBRD_INT_TRIGGER_TYPE_EDGE));

/* Step 3: Steer interrupts to the on-board ARM processor */
check_status(naibrd_TTL_SetChanMappedInterruptSteering(cardIndex, module,
   NAIBRD_TTL_STATUS_SUMMARY_LATCHED, NAIBRD_INT_STEERING_ONBOARD_ARM));

/* Step 4: Set the interrupt vector */
check_status(naibrd_TTL_SetChanMappedInterruptVector(cardIndex, module,
   NAIBRD_TTL_STATUS_SUMMARY_LATCHED, vector));

/* Step 5: Enable the interrupt on the selected channel */
check_status(naibrd_TTL_SetChanMappedInterruptEnable(cardIndex, module, chan,
   NAIBRD_TTL_STATUS_SUMMARY_LATCHED, NAI_TRUE));

naibrd_ConnectISR() — registers your callback function with the NAI interrupt subsystem. Call this once per card, not once per interrupt type. The callback receives the interrupt vector as its argument.
NAIBRD_TTL_STATUS_SUMMARY_LATCHED — specifies which status register the interrupt is tied to. This sample uses the summary register so that a single interrupt fires for any fault type on the channel.
NAIBRD_INT_TRIGGER_TYPE_EDGE — the interrupt fires on a status transition (0 to 1), not while the status is held high. Edge triggering is the typical choice for latched status registers.
NAIBRD_INT_STEERING_ONBOARD_ARM — routes the interrupt to the on-board ARM processor. Other steering options include PCIe or VME backplane delivery.
vector — the interrupt vector value (0xB0 in this sample). Your callback receives this value so it can identify which interrupt source fired.
The final SetChanMappedInterruptEnable() call arms the interrupt on the specified channel. Until this call, the interrupt is configured but will not fire.

Interrupt Callback

The sample provides a minimal callback that logs the interrupt vector:

static void SampleCallBack(uint32_t vector)
{
   NAIBSP_UNREFERENCED_PARAMETER(vector);

#if defined (NAIBSP_CONFIG_SOFTWARE_OS_VXWORKS)
   logMsg("Interrupt Received!!! Vector:0x%x\n Clear Status to receive new interrupt!!!\r\n",
      vector, 0, 0, 0, 0, 0);
#endif
}

In your own application, the callback is where you would read status registers to identify the fault, log the event, or signal a processing thread. Keep the callback short — perform extended processing outside the ISR context.

Note	On VxWorks, the callback uses `logMsg()` because `printf()` is not safe in interrupt context. On Petalinux, the callback body is empty in this sample because the status is read through the menu commands. In your own application, use interrupt-safe I/O functions within the callback.

For background on interrupt concepts — including edge vs. level triggering, interrupt vector numbering, steering architecture, and latency measurement — see the Interrupts API Guide.

Important

Common Errors

Interrupt does not fire — The most common cause is missing one of the five configuration steps. All five calls (connect ISR, set trigger type, set steering, set vector, enable) must succeed before the interrupt will fire.
Interrupt fires once but not again — With edge triggering, the interrupt fires on the 0-to-1 transition. You must clear the latched status to allow the next transition to trigger a new interrupt.
Callback not invoked on Petalinux — Verify that the ISR connection was successful. Check that the steering is set to NAIBRD_INT_STEERING_ONBOARD_ARM.

Forcing a BIT Error

The sample provides a diagnostic command that forces a BIT error on the selected channel. This lets you verify that the status registers and interrupt configuration are working without requiring external hardware changes.

To force a BIT error on a TTL channel, the sample sets the I/O format to push-pull output, drives the output high (with no external VCC connected), waits briefly, then drives the output low and restores the channel to input mode:

/* Step 1: Set channel to push-pull output mode */
status = check_status(naibrd_TTL_SetIOFormat(cardIndex, module, chan,
   NAIBRD_TTL_IOFORMAT_OUTPUT));

/* Step 2: Drive output high -- with no external VCC, this creates a BIT error */
check_status(naibrd_TTL_SetOutputState(cardIndex, module, chan, NAIBRD_TTL_STATE_HI));

/* Step 3: Wait for the BIT logic to detect the error */
naibrd_msDelay(300);

/* Step 4: Drive output low and restore input mode */
check_status(naibrd_TTL_SetOutputState(cardIndex, module, chan, NAIBRD_TTL_STATE_LO));
check_status(naibrd_TTL_SetIOFormat(cardIndex, module, chan,
   NAIBRD_TTL_IOFORMAT_INPUT));

NAIBRD_TTL_IOFORMAT_OUTPUT — configures the channel for push-pull output.
NAIBRD_TTL_STATE_HI — drives the output high.
naibrd_msDelay(300) — a 300 ms delay gives the BIT logic time to detect the open-circuit condition.
After the test, the channel is returned to input mode (NAIBRD_TTL_IOFORMAT_INPUT) and the output driven low.

The BIT error occurs because the channel is configured for push-pull output with a high state, but there is no external VCC to complete the circuit. The hardware BIT logic detects this open-circuit condition and sets the BIT latched status bit, which in turn sets the summary latched status bit for that channel.

After running this command, use the STAT command to verify that the BIT and summary status bits are set on the channel you selected. If you configured an interrupt, you should also observe the callback firing.

Important

Common Errors

BIT error not detected — External VCC must be disconnected from the channel for this test to work. If VCC is connected, the output will drive normally and no BIT error will occur.
Status bits not set after forcing error — The 300 ms delay may not be sufficient on all hardware configurations. If status bits are not set, try running the FAULT command again or increasing the delay in your own code.
Channel left in output mode — If the sample exits abnormally during the force-error sequence, the channel may remain configured as an output. Re-run the sample and clear status, or call naibrd_TTL_SetIOFormat() to restore input mode.

Troubleshooting Reference

This table summarizes common errors and symptoms covered in the sections above. For detailed context on each entry, refer to the relevant section. Consult your module’s manual (TL1 Manual, TL2 Manual) for hardware-specific diagnostic procedures.

Error / Symptom Possible Causes Suggested Resolution

Error / Symptom	Possible Causes	Suggested Resolution
No board found or connection timeout	Board not powered, incorrect or missing configuration file, network issue	Verify hardware is powered and connected. If `default_TTL_Summary.txt` exists, check that it lists the correct interface and address. If it does not exist, the board menu will appear — configure and save your connection settings.
Module not detected at selected slot	No module installed at the specified slot, incorrect module number entered	Verify hardware configuration and module slot assignment
Module not recognized as TTL	Module ID does not match a known TTL type — wrong slot selected or non-TTL module installed	Select a different module slot. Verify that a TL1 or TL2 module is installed at the selected position.
`NAI_ERROR_NOT_SUPPORTED`	Feature not available for this module type, or calling a TTL function on a non-TTL module	Check your module type with `naibrd_TTL_GetChannelCount()`. Consult your module’s manual for supported features.
Summary bit reasserts after clearing	Underlying BIT or overcurrent fault still active	Clear all three status types (BIT, overcurrent, summary). If the condition persists, resolve the hardware fault.
Interrupt does not fire	Missing one or more interrupt configuration steps (ISR connect, trigger type, steering, vector, enable)	Verify all five configuration calls completed successfully. Check that steering is set to `NAIBRD_INT_STEERING_ONBOARD_ARM`.
Interrupt fires once but not again	Latched status not cleared after first interrupt	Clear the latched summary status to allow the next edge transition to trigger a new interrupt.
BIT error not detected after FAULT command	External VCC still connected to the test channel	Disconnect external VCC from the channel before running the force-error test.
Channel left in output mode after abnormal exit	Sample interrupted during the force-error sequence before restoring input mode	Call `naibrd_TTL_SetIOFormat()` with `NAIBRD_TTL_IOFORMAT_INPUT` to restore the channel to input mode.

No board found or connection timeout

Board not powered, incorrect or missing configuration file, network issue

Verify hardware is powered and connected. If default_TTL_Summary.txt exists, check that it lists the correct interface and address. If it does not exist, the board menu will appear — configure and save your connection settings.

Module not detected at selected slot

No module installed at the specified slot, incorrect module number entered

Verify hardware configuration and module slot assignment

Module not recognized as TTL

Module ID does not match a known TTL type — wrong slot selected or non-TTL module installed

Select a different module slot. Verify that a TL1 or TL2 module is installed at the selected position.

NAI_ERROR_NOT_SUPPORTED

Feature not available for this module type, or calling a TTL function on a non-TTL module

Check your module type with naibrd_TTL_GetChannelCount(). Consult your module’s manual for supported features.

Summary bit reasserts after clearing

Underlying BIT or overcurrent fault still active

Clear all three status types (BIT, overcurrent, summary). If the condition persists, resolve the hardware fault.

Interrupt does not fire

Missing one or more interrupt configuration steps (ISR connect, trigger type, steering, vector, enable)

Verify all five configuration calls completed successfully. Check that steering is set to NAIBRD_INT_STEERING_ONBOARD_ARM.

Interrupt fires once but not again

Latched status not cleared after first interrupt

Clear the latched summary status to allow the next edge transition to trigger a new interrupt.

BIT error not detected after FAULT command

External VCC still connected to the test channel

Disconnect external VCC from the channel before running the force-error test.

Channel left in output mode after abnormal exit

Sample interrupted during the force-error sequence before restoring input mode

Call naibrd_TTL_SetIOFormat() with NAIBRD_TTL_IOFORMAT_INPUT to restore the channel to input mode.

Full Source

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

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

/* 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_ttl.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_display.h"
#include "nai_sample_apps/naiapp_common/include/naiapp_boardaccess_utils.h"

#if defined (NAIBSP_CONFIG_SOFTWARE_OS_VXWORKS)
#include "logLib.h"
#endif
static const int8_t *DEF_CONFIG_FILE = (const int8_t *)"default_TTL_Summary.txt";

/* Function prototypes */
static int32_t Run_TTL_Summary(int32_t cardIndex, int32_t module, uint32_t modid);
static void Cfg_TTL_Channel(int32_t cardIndex, int32_t module, int32_t MaxChannel);
static void Verify_TTL_ParamCnt(int32_t paramCnt);
static nai_status_t Display_TTL_Status(int32_t paramCnt, int32_t* p_params);
static nai_status_t Clear_TTL_Status(int32_t paramCnt, int32_t* p_params);
static nai_status_t Force_BIT_Error(int32_t paramCnt, int32_t* p_params);
static nai_status_t Configure_TTL_Interrupt(int32_t paramCnt, int32_t* p_params);
static void SampleCallBack(uint32_t vector);

static const int32_t DEF_TTL_CARD_INDEX    = 0;
static const int32_t DEF_TTL_MODULE        = 1;
static const int32_t DEF_TTL_CHANNEL       = 1;

/****** Command Table *******/
enum ttl_basic_interrupt_commands
{
   TTL_SUMMARY_INTERRUPT_CMD_CONFIGURE,
   TTL_SUMMARY_INTERRUPT_CMD_STATUS_READ,
   TTL_SUMMARY_INTERRUPT_CMD_STATUS_CLEAR,
   TTL_SUMMARY_INTERRUPT_CMD_FORCE_ERROR,
   TTL_SUMMARY_INTERRUPT_CMD_COUNT
};

/****** Command Tables *******/
static naiapp_cmdtbl_params_t TTL_SummaryMenuCmds[] = {
   {"INT",      "TTL Configure Interrupt",    TTL_SUMMARY_INTERRUPT_CMD_CONFIGURE,        Configure_TTL_Interrupt},
   {"STAT",     "TTL Display Status",         TTL_SUMMARY_INTERRUPT_CMD_STATUS_READ,      Display_TTL_Status},
   {"CLEAR",    "TTL Clear Status",           TTL_SUMMARY_INTERRUPT_CMD_STATUS_CLEAR,     Clear_TTL_Status},
   {"FAULT",    "TTL Force BIT Error",        TTL_SUMMARY_INTERRUPT_CMD_FORCE_ERROR,      Force_BIT_Error},
};

/**************************************************************************************************************/
/**
 * <summary>
 * The purpose of the ttl_summary example is to illustrate the methods to call in the naibrd library to perform basic
 * operations with the ttl modules for interrupt configuration, reading fault statuses including the summary
 * status register, clearing status bits and forcing a BIT error to observe status bits getting set in both the
 * BIT status and summary registers. The summary register is bit-mapped by channel (bit index zero is channel 1)
 * and reports a '1' if the corresponding channel has detected a fault in either BIT or over-current status. A
 * latched summary bit can be cleared by writing a '1' to the bit. A BIT error condition can be forced in a DT
 * channel by configuring the IO format for Push-Pull and setting the output state HIGH while an external VCC is
 * unconnected. To demonstrate the aforementioned concepts, the user should run this sample application and enter
 * the following sequence of menu commands (though in reality the user is free to follow any sequence):
 *
 *    clear - to clear all latched status registers (BIT, Overcurrent and Summary statuses)
 *    stat  - to display all latched statuses
 *    int   - to configure the interrupt subsystem on the user-selected channel
 *    fault - to generate a BIT error on the user-selected channel
 *    stat  - to display all latched statuses
 *    clear - to clear all latched status registers
 *
 * </summary>
 */
/**************************************************************************************************************/
#if defined (NAIBSP_CONFIG_SOFTWARE_OS_VXWORKS)
int32_t ttl_summary(void)
#else
int32_t main(void)
#endif
{
   int32_t cardIndex;
   int32_t moduleCnt;
   int32_t module;
   bool_t stop = NAI_FALSE;
   uint32_t moduleID;
   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(), DEF_TTL_CARD_INDEX, &cardIndex);
         if (stop != NAI_TRUE)
         {
            check_status(naibrd_GetModuleCount(cardIndex, &moduleCnt));

            /* Select Module */
            stop = naiapp_query_ModuleNumber(moduleCnt, DEF_TTL_MODULE, &module);
            if (stop != NAI_TRUE)
            {
               check_status(naibrd_GetModuleName(cardIndex, module, &moduleID));
               if ((moduleID != 0))
               {
                  Run_TTL_Summary(cardIndex, module, moduleID);
                  naiif_printf("\r\nType Q to quit or Enter to continue:\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;
}
/**************************************************************************************************************/
/**
 * <summary>
 * Verify_TTL_ParamCnt verifies parameter count and displays error message if invalid.
 * </summary>
 */
 /**************************************************************************************************************/
static void Verify_TTL_ParamCnt(int32_t paramCnt)
{
   if (paramCnt != APP_PARAM_COUNT)
   {
      naiif_printf(" *** Parameter count specified is incorrect!!! ***\r\n");
   }
}
/**************************************************************************************************************/
/**
 * <summary>
 * Run_TTL_Summary prompts the user for the card, module and channel to use for the application and calls
 * Cfg_TTL_Channel if the card, module, channel is valid for as a ttl module.
 * </summary>
 */
/**************************************************************************************************************/
static int32_t Run_TTL_Summary(int32_t cardIndex, int32_t module, uint32_t modid)
{
   bool_t bQuit = NAI_FALSE;
   int32_t maxchannel;

   if (!bQuit)
   {
      maxchannel = naibrd_TTL_GetChannelCount(modid);
      if (maxchannel == 0)
      {
         naiif_printf(" *** Module selection not recognized as TTL module. ***\r\n\r\n");
      }
      else
      {
         Cfg_TTL_Channel(cardIndex, module, maxchannel);
      }
   }
   return cardIndex;
}

/**************************************************************************************************************/
/**
 * <summary>
 * Cfg_TTL_Channel handles calling the Display_TTL_ChannelCfg routine to display the ttl channel configuration
 * and calling the routines associated with the user's menu commands.
 * </summary>
 */
/**************************************************************************************************************/
static void Cfg_TTL_Channel(int32_t cardIndex, int32_t module, int32_t MaxChannel)
{
   bool_t bQuit = NAI_FALSE;
   bool_t bContinue = NAI_TRUE;
   bool_t bCmdFound = NAI_FALSE;
   int32_t chan, defaultchan = 1;   /* This is channel selection for interrupt only */
   int32_t cmd;
   naiapp_AppParameters_t  ttlparams;
   p_naiapp_AppParameters_t ttlParams = &ttlparams;
   int8_t inputBuffer[80];
   int32_t inputResponseCnt;

   while (bContinue)
   {
      naiif_printf("\r\n\r\n");
      naiif_printf("Channel selection for Interrupt\r\n");
      naiif_printf("=================\r\n");
      defaultchan = DEF_TTL_CHANNEL;

      bQuit = naiapp_query_ChannelNumber(MaxChannel, defaultchan, &chan);
      ttlParams->cardIndex = cardIndex;
      ttlParams->module = module;
      ttlParams->maxChannels = MaxChannel;
      ttlParams->channel = chan;

      naiapp_utils_LoadParamMenuCommands(TTL_SUMMARY_INTERRUPT_CMD_COUNT, TTL_SummaryMenuCmds);
      while (bContinue)
      {
         naiapp_display_ParamMenuCommands((int8_t *)"TTL Summary Interrupt Menu");
         naiif_printf("\r\nType TTL command or %c to quit : ", NAI_QUIT_CHAR);
         bQuit = naiapp_query_ForQuitResponse(sizeof(inputBuffer), NAI_QUIT_CHAR, inputBuffer, &inputResponseCnt);
         if (!bQuit)
         {
            if (inputResponseCnt > 0)
            {
               bCmdFound = naiapp_utils_GetParamMenuCmdNum(inputResponseCnt, inputBuffer, &cmd);
               if (bCmdFound)
               {
                  switch (cmd)
                  {
                  case TTL_SUMMARY_INTERRUPT_CMD_CONFIGURE:
                  case TTL_SUMMARY_INTERRUPT_CMD_STATUS_READ:
                  case TTL_SUMMARY_INTERRUPT_CMD_STATUS_CLEAR:
                  case TTL_SUMMARY_INTERRUPT_CMD_FORCE_ERROR:
                     TTL_SummaryMenuCmds[cmd].func(APP_PARAM_COUNT, (int32_t*)ttlParams);
                     break;
                  default:
                     naiif_printf("Invalid command entered\r\n");
                     break;
                  }
               }
               else
               {
                  naiif_printf("Invalid command entered\r\n");
               }
            }
         }
         else
         {
            bContinue = NAI_FALSE;
         }
      }
   }
}

/**************************************************************************************************************/
/**
 * <summary>
 * Display_TTL_Status illustrate the methods to call in the naibrd library to retrieve the status states.
 * </summary>
 */
/**************************************************************************************************************/
static nai_status_t Display_TTL_Status(int32_t paramCnt, int32_t* p_params)
{
   p_naiapp_AppParameters_t ttlParams = (p_naiapp_AppParameters_t)p_params;
   int32_t cardIndex = ttlParams->cardIndex;
   int32_t module = ttlParams->module;
   int32_t chan;
   nai_status_bit_t statusBit;
   Verify_TTL_ParamCnt(paramCnt);

   naiif_printf("\r\n");
   naiif_printf("  --------------Latched Status--------------\r\n");
   naiif_printf("   Chan      BIT        OC        SUMMARY   \r\n");
   naiif_printf("  ------ ---------- ---------- -------------\r\n");

   for (chan = 1; chan <= ttlParams->maxChannels; chan++)
   {
      naiif_printf("  %3i   ", chan);

      check_status(naibrd_TTL_GetChanMappedStatus(cardIndex, module, chan, NAIBRD_TTL_STATUS_BIT_LATCHED, &statusBit));
      naiif_printf("    %3i   ", statusBit);

      check_status(naibrd_TTL_GetChanMappedStatus(cardIndex, module, chan, NAIBRD_TTL_STATUS_OVERCURRENT_LATCHED, &statusBit));
      naiif_printf("     %3i   ", statusBit);

      check_status(naibrd_TTL_GetChanMappedStatus(cardIndex, module, chan, NAIBRD_TTL_STATUS_SUMMARY_LATCHED, &statusBit));
      naiif_printf("      %3i   ", statusBit);

      naiif_printf("\r\n");
   }
   naiif_printf("\r\n\r\n");

   return NAI_SUCCESS;
}

static nai_status_t Clear_TTL_Status(int32_t paramCnt, int32_t* p_params)
{
   nai_status_t status = NAI_ERROR_NOT_SUPPORTED;
   p_naiapp_AppParameters_t ttlParams = (p_naiapp_AppParameters_t)p_params;
   int32_t cardIndex = ttlParams->cardIndex;
   int32_t module = ttlParams->module;
   int32_t chan = 0;
   Verify_TTL_ParamCnt(paramCnt);

   for (chan = 1; chan <= ttlParams->maxChannels; chan++)
   {
      status = check_status(naibrd_TTL_ClearChanMappedStatus(cardIndex, module, chan, NAIBRD_TTL_STATUS_BIT_LATCHED));
      if (status == NAI_SUCCESS)
      {
         status = check_status(naibrd_TTL_ClearChanMappedStatus(cardIndex, module,chan, NAIBRD_TTL_STATUS_OVERCURRENT_LATCHED));
         if (status == NAI_SUCCESS)
         {
            status = check_status(naibrd_TTL_ClearChanMappedStatus(cardIndex, module, chan, NAIBRD_TTL_STATUS_SUMMARY_LATCHED));
         }
      }
   }

   if (status == NAI_SUCCESS)
   {
      naiif_printf("Cleared all statuses...\r\n");
   }

   return status;
}

static nai_status_t Force_BIT_Error(int32_t paramCnt, int32_t* p_params)
{
   nai_status_t status = NAI_ERROR_NOT_SUPPORTED;
   p_naiapp_AppParameters_t ttlParams = (p_naiapp_AppParameters_t)p_params;
   int32_t cardIndex = ttlParams->cardIndex;
   int32_t module = ttlParams->module;
   int32_t chan = ttlParams->channel;

   NAIBSP_UNREFERENCED_PARAMETER(paramCnt);


   naiif_printf("Forcing BIT Error on Channel %d. Make sure external VCC is off...\r\n", chan);

   status = check_status(naibrd_TTL_SetIOFormat( cardIndex, module, chan, NAIBRD_TTL_IOFORMAT_OUTPUT));
   if (status == NAI_SUCCESS)
   {
      naiif_printf("Setting IO Format to Push-Pull on Channel %d...\r\n", chan);
      check_status(naibrd_TTL_SetOutputState( cardIndex, module, chan, NAIBRD_TTL_STATE_HI));
      if (status == NAI_SUCCESS)
      {
         naiif_printf("Setting TTL Output State High on Channel %d...\r\n", chan);

         naibrd_msDelay(300);

         check_status(naibrd_TTL_SetOutputState( cardIndex, module, chan, NAIBRD_TTL_STATE_LO));
         if (status == NAI_SUCCESS)
         {
            naiif_printf("Setting TTL Output State Low on Channel %d...\r\n", chan);
            if (status == NAI_SUCCESS)
            {
               status = check_status(naibrd_TTL_SetIOFormat( cardIndex, module, chan, NAIBRD_TTL_IOFORMAT_INPUT));
               naiif_printf("Setting IO Format to Input on Channel %d...\r\n", chan);
            }
         }
      }
   }

   if (status != NAI_SUCCESS)
   {
      naiif_printf("Failed to generate BIT Error on Channel %d...\r\n", chan);
   }

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

   return status;
}

static nai_status_t Configure_TTL_Interrupt(int32_t paramCnt, int32_t* p_params)
{
   p_naiapp_AppParameters_t ttlParams = (p_naiapp_AppParameters_t)p_params;
   int32_t cardIndex = ttlParams->cardIndex;
   int32_t module = ttlParams->module;
   int32_t chan = ttlParams->channel;   /* Channel to generate interrupt on */
   uint32_t vector = 0xB0u;
   Verify_TTL_ParamCnt(paramCnt);

   /* Specify callback function for interrupt type */
   check_status(naibrd_ConnectISR(cardIndex, SampleCallBack)); /* Invoked once per card, not per interrupt type */
   check_status(naibrd_TTL_SetChanMappedInterruptTriggerType(cardIndex, module, chan, NAIBRD_TTL_STATUS_SUMMARY_LATCHED,
         NAIBRD_INT_TRIGGER_TYPE_EDGE));
   check_status(naibrd_TTL_SetChanMappedInterruptSteering(cardIndex, module, NAIBRD_TTL_STATUS_SUMMARY_LATCHED,
         NAIBRD_INT_STEERING_ONBOARD_ARM));
   check_status(naibrd_TTL_SetChanMappedInterruptVector(cardIndex, module, NAIBRD_TTL_STATUS_SUMMARY_LATCHED, vector));
   check_status(naibrd_TTL_SetChanMappedInterruptEnable(cardIndex, module, chan, NAIBRD_TTL_STATUS_SUMMARY_LATCHED, NAI_TRUE));

   naiif_printf("\r\nInterrupt Configuration\r\n");
   naiif_printf("=======================\r\n");
   naiif_printf("Card Index:%d\r\n", cardIndex);
   naiif_printf("Module Number:%d\r\n", module);
   naiif_printf("Channel:%d\r\n", chan);
   naiif_printf("Vector:0x%X\r\n", vector);
   naiif_printf("Status:Summary\r\n");
   naiif_printf("\r\n\r\n Waiting for Summary Latched interrupt on channel %d...\r\n", chan);

   return NAI_SUCCESS;
}

static void SampleCallBack(uint32_t vector)
{
   NAIBSP_UNREFERENCED_PARAMETER(vector);

#if defined (NAIBSP_CONFIG_SOFTWARE_OS_VXWORKS)
   logMsg("Interrupt Received!!! Vector:0x%x\n Clear Status to receive new interrupt!!!\r\n",vector,0,0,0,0,0);
#endif
}

TTL Summary

Table of Contents

Integrator Resources

TTL Summary

TTL Summary Sample Application (SSK 2.x)

Overview

Prerequisites

How to Run

Board Connection and Module Selection

Program Structure

Application Parameters

Command Menu

Display Configuration

Reading Latched Status

Understanding the Summary Register

Clearing Latched Status

Optional Interrupt Setup

Configuring the Interrupt

Interrupt Callback

Forcing a BIT Error

Troubleshooting Reference

Full Source

Help Bot