AD Summary

ad_summary

Table of Contents

Integrator Resources

• The official home for NAI Support

Not sure where to start? Try Quick Start Guide or ask a question below!

Toggle Components with Visual Button
JavaScript Form Processing

AD Summary

Edit this on GitLab

AD Summary Sample Application (SSK 2.x)

Overview

The AD Summary sample application demonstrates how to read and manage fault status across all channels of an A/D (Analog-to-Digital) 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 and summary status for every channel, clearing latched status registers, 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 its BIT status. This gives you a single register to poll for any fault condition across the entire module, rather than reading BIT status individually for each channel.

This sample supports AD module types: AD1-AD6 and ADE-ADG. It serves as a practical API reference — each menu command maps directly to one or more naibrd_AD_*() 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 A/D samples, see AD BasicOps (SSK 1.x).

Prerequisites

Before running this sample, make sure you have:

  • An NAI board with an A/D module installed (AD1-AD6 or ADE-ADG).

  • 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 ad_summary executable from your build output directory. On startup the application looks for a configuration file (default_AD_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, and clear status registers.

The recommended sequence for exploring this sample is:

  1. CLEAR — clear all latched status registers to start from a clean state.

  2. STAT — display all latched statuses (should all be zero after clearing).

  3. INT — configure the interrupt subsystem on your selected channel.

  4. STAT — display statuses again to observe any changes.

  5. 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 A/D.

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

  1. Call naiapp_RunBoardMenu() to load a saved configuration file (if one exists) or present the interactive board menu. The configuration file (default_AD_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.

  2. Query the user for a card index with naiapp_query_CardIndex().

  3. Query for a module slot with naiapp_query_ModuleNumber().

  4. Retrieve the module ID with naibrd_GetModuleName() so downstream code can adapt to the specific A/D variant installed.

#if defined (NAIBSP_CONFIG_SOFTWARE_OS_VXWORKS)
int32_t ad_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_AD_CARD_INDEX, &cardIndex);
         if (stop != NAI_TRUE)
         {
            check_status(naibrd_GetModuleCount(cardIndex, &moduleCnt));
            stop = naiapp_query_ModuleNumber(moduleCnt, DEF_AD_MODULE, &module);
            if (stop != NAI_TRUE)
            {
               check_status(naibrd_GetModuleName(cardIndex, module, &moduleID));
               if ((moduleID != 0))
               {
                  Run_AD_Summary(cardIndex, module, moduleID);
               }
            }
         }
      }
   }

   naiapp_access_CloseAllOpenCards();
   return 0;
}

After module selection, Run_AD_Summary() calls naibrd_AD_GetChannelCount() to determine how many channels the installed module supports, then hands off to the command loop in Cfg_AD_Channel().

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

  • modid — the module ID returned by naibrd_GetModuleName().

  • naibrd_AD_GetChannelCount() — returns 0 if the module ID does not match a known A/D module type.

Program Structure

Application Parameters

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

naiapp_AppParameters_t  adparams;
p_naiapp_AppParameters_t adParams = &adparams;

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

  • cardIndex — identifies the board.

  • module — the slot containing the A/D 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.

Command Menu

The sample presents three commands through its menu system:

Command Menu Label Operation

INT

AD Configure Interrupt

Configure interrupt on the selected channel

STAT

AD Display Status

Display latched BIT and summary status for all channels

CLEAR

AD Clear Status

Clear all latched status registers across all channels

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 an A/D module in your own application, call naibrd_AD_GetChanMappedStatus() with each status type. The sample reads two status registers per channel:

nai_status_bit_t statusBit;

for (chan = 1; chan <= adParams->maxChannels; chan++)
{
   check_status(naibrd_AD_GetChanMappedStatus(cardIndex, module, chan,
      NAIBRD_AD_STATUS_BIT_LATCHED, &statusBit));

   check_status(naibrd_AD_GetChanMappedStatus(cardIndex, module, chan,
      NAIBRD_AD_STATUS_SUMMARY_LATCHED, &statusBit));
}

  • cardIndex — identifies the board.

  • module — the slot containing the A/D module.

  • chan — the channel number (1-based).

  • NAIBRD_AD_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_AD_STATUS_SUMMARY_LATCHED — the latched summary status. Reads 1 if a BIT fault has been detected on this channel. This is the aggregated fault indicator.

The sample also reads raw status words using naibrd_AD_GetChanMappedStatusRaw() to display the entire register in hexadecimal, giving a consolidated view of all channels at once.

Understanding the Summary Register

The summary register provides a consolidated view of all fault conditions on a channel. Rather than polling BIT status separately for each channel, you can check the summary bit — 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_AD_ClearChanMappedStatusRaw() for each status type with a bitmask of 0xFFFFFFFF to clear all channels at once:

status = check_status(naibrd_AD_ClearChanMappedStatusRaw(cardIndex, module,
   NAIBRD_AD_STATUS_BIT_LATCHED, 0xFFFFFFFFu));
if (status == NAI_SUCCESS)
{
   status = check_status(naibrd_AD_ClearChanMappedStatusRaw(cardIndex, module,
      NAIBRD_AD_STATUS_SUMMARY_LATCHED, 0xFFFFFFFFu));
}

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

Important

Common Errors

  • Summary bit reasserts after clearing — If the underlying fault condition (BIT) is still active, the summary bit will reassert. Clear BIT status as well, or resolve the underlying hardware condition.

  • NAI_ERROR_NOT_SUPPORTED — The module at the selected slot is not a recognized A/D module type. Verify the module type with naibrd_AD_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_AD_SetChanMappedInterruptTriggerType(cardIndex, module, chan,
   NAIBRD_AD_STATUS_SUMMARY_LATCHED, NAIBRD_INT_TRIGGER_TYPE_EDGE));

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

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

/* Step 5: Enable the interrupt on the selected channel */
check_status(naibrd_AD_SetChanMappedInterruptEnable(cardIndex, module, chan,
   NAIBRD_AD_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_AD_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.

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 (AD1-AD3 Manual, AD4-AD6 Manual) for hardware-specific diagnostic procedures.

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_AD_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 A/D

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

Select a different module slot. Verify that an AD1-AD6 or ADE-ADG module is installed at the selected position.

NAI_ERROR_NOT_SUPPORTED

Feature not available for this module type, or calling an A/D function on a non-A/D module

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

Summary bit reasserts after clearing

Underlying BIT fault still active

Clear BIT status along with summary status. 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.

Full Source

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

Full Source — ad_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_ad.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_AD_Summary.txt";

/* Function prototypes */
static int32_t Run_AD_Summary(int32_t cardIndex, int32_t module, uint32_t modid);
static void Cfg_AD_Channel(int32_t cardIndex, int32_t module, int32_t MaxChannel);
static void Verify_AD_ParamCnt(int32_t paramCnt);
static nai_status_t Display_AD_Status(int32_t paramCnt, int32_t* p_params);
static nai_status_t Clear_AD_Status(int32_t paramCnt, int32_t* p_params);
static nai_status_t Configure_AD_Interrupt(int32_t paramCnt, int32_t* p_params);
static void SampleCallBack(uint32_t vector);

static const int32_t DEF_AD_CARD_INDEX    = 0;
static const int32_t DEF_AD_MODULE        = 1;
static const int32_t DEF_AD_CHANNEL       = 1;

/****** Command Table *******/
enum ad_basic_interrupt_commands
{
   AD_SUMMARY_INTERRUPT_CMD_CONFIGURE,
   AD_SUMMARY_INTERRUPT_CMD_STATUS_READ,
   AD_SUMMARY_INTERRUPT_CMD_STATUS_CLEAR,
   AD_SUMMARY_INTERRUPT_CMD_COUNT
};

/****** Command Tables *******/
static naiapp_cmdtbl_params_t AD_SummaryMenuCmds[] = {
   {"INT",      "AD Configure Interrupt",    AD_SUMMARY_INTERRUPT_CMD_CONFIGURE,         Configure_AD_Interrupt},
   {"STAT",     "AD Display Status",         AD_SUMMARY_INTERRUPT_CMD_STATUS_READ,       Display_AD_Status},
   {"CLEAR",    "AD Clear Status",           AD_SUMMARY_INTERRUPT_CMD_STATUS_CLEAR,      Clear_AD_Status}
};

/**************************************************************************************************************/
/** \defgroup ADSummary

\brief This sample application demonstrates how to use an A/D module's summary registers.

This sample application illustrates how to perform some basic A/D operations using the `naibrd` library. It is
intended to help users understand how to use the library API's to access the basic features of the A/D.

The main steps include actions such as:
- Querying the user for the card index and module number
- Configuring the module for Range and Polarity
- Reading and displaying A/D summary data

The Summary feature is accessed through the Main Menu:
- Main Menu: Configure an A/D Summary Interrupt. Display and Clear Summary Status.
*/
/**************************************************************************************************************/
#if defined (NAIBSP_CONFIG_SOFTWARE_OS_VXWORKS)
int32_t ad_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_AD_CARD_INDEX, &cardIndex);
         if (stop != NAI_TRUE)
         {
            check_status(naibrd_GetModuleCount(cardIndex, &moduleCnt));

            /* Select Module */
            stop = naiapp_query_ModuleNumber(moduleCnt, DEF_AD_MODULE, &module);
            if (stop != NAI_TRUE)
            {
               check_status(naibrd_GetModuleName(cardIndex, module, &moduleID));
               if ((moduleID != 0))
               {
                  Run_AD_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;
}

static void Verify_AD_ParamCnt(int32_t paramCnt)
{
   if (paramCnt != APP_PARAM_COUNT)
   {
      naiif_printf(" *** Parameter count specified is incorrect!!! ***\r\n");
   }
}

static int32_t Run_AD_Summary(int32_t cardIndex, int32_t module, uint32_t modid)
{
   bool_t bQuit = NAI_FALSE;
   int32_t maxchannel;

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

static void Cfg_AD_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  adparams;
   p_naiapp_AppParameters_t adParams = &adparams;
   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_AD_CHANNEL;

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

      naiapp_utils_LoadParamMenuCommands(AD_SUMMARY_INTERRUPT_CMD_COUNT, AD_SummaryMenuCmds);
      while (bContinue)
      {
         naiapp_display_ParamMenuCommands((int8_t *)"AD Summary Interrupt Menu");
         naiif_printf("\r\nType AD 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 AD_SUMMARY_INTERRUPT_CMD_CONFIGURE:
                  case AD_SUMMARY_INTERRUPT_CMD_STATUS_READ:
                  case AD_SUMMARY_INTERRUPT_CMD_STATUS_CLEAR:
                     AD_SummaryMenuCmds[cmd].func(APP_PARAM_COUNT, (int32_t*)adParams);
                     break;
                  default:
                     naiif_printf("Invalid command entered\r\n");
                     break;
                  }
               }
               else
               {
                  naiif_printf("Invalid command entered\r\n");
               }
            }
         }
         else
         {
            bContinue = NAI_FALSE;
         }
      }
   }
}

static nai_status_t Display_AD_Status(int32_t paramCnt, int32_t* p_params)
{
   p_naiapp_AppParameters_t adParams = (p_naiapp_AppParameters_t)p_params;
   int32_t cardIndex = adParams->cardIndex;
   int32_t module = adParams->module;
   int32_t chan;
   nai_status_bit_t statusBit;
   uint32_t rawValue;
   Verify_AD_ParamCnt(paramCnt);

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

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

      check_status(naibrd_AD_GetChanMappedStatus(cardIndex, module, chan, NAIBRD_AD_STATUS_BIT_LATCHED, &statusBit));
      naiif_printf("    %3i   ", statusBit);

      check_status(naibrd_AD_GetChanMappedStatus(cardIndex, module, chan, NAIBRD_AD_STATUS_SUMMARY_LATCHED, &statusBit));
      naiif_printf("      %3i   ", statusBit);

      naiif_printf("\r\n");
   }

   /* Print status words in hex */
   naiif_printf("  All   ");

   check_status(naibrd_AD_GetChanMappedStatusRaw(cardIndex, module, NAIBRD_AD_STATUS_BIT_LATCHED, &rawValue));
   naiif_printf(" 0x%08X ", rawValue);

   check_status(naibrd_AD_GetChanMappedStatusRaw(cardIndex, module, NAIBRD_AD_STATUS_SUMMARY_LATCHED, &rawValue));
   naiif_printf(" 0x%08X ", rawValue);

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

   return NAI_SUCCESS;
}

static nai_status_t Clear_AD_Status(int32_t paramCnt, int32_t* p_params)
{
   nai_status_t status = NAI_ERROR_NOT_SUPPORTED;
   p_naiapp_AppParameters_t adParams = (p_naiapp_AppParameters_t)p_params;
   int32_t cardIndex = adParams->cardIndex;
   int32_t module = adParams->module;
   Verify_AD_ParamCnt(paramCnt);

   status = check_status(naibrd_AD_ClearChanMappedStatusRaw(cardIndex, module, NAIBRD_AD_STATUS_BIT_LATCHED, 0xFFFFFFFFu));
   if (status == NAI_SUCCESS)
   {
      status = check_status(naibrd_AD_ClearChanMappedStatusRaw(cardIndex, module, NAIBRD_AD_STATUS_SUMMARY_LATCHED, 0xFFFFFFFFu));
   }

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

   return status;
}

static nai_status_t Configure_AD_Interrupt(int32_t paramCnt, int32_t* p_params)
{
   p_naiapp_AppParameters_t adParams = (p_naiapp_AppParameters_t)p_params;
   int32_t cardIndex = adParams->cardIndex;
   int32_t module = adParams->module;
   int32_t chan = adParams->channel;   /* Channel to generate interrupt on */
   uint32_t vector = 0xB0u;
   Verify_AD_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_AD_SetChanMappedInterruptTriggerType(cardIndex, module, chan, NAIBRD_AD_STATUS_SUMMARY_LATCHED,
         NAIBRD_INT_TRIGGER_TYPE_EDGE));
   check_status(naibrd_AD_SetChanMappedInterruptSteering(cardIndex, module, NAIBRD_AD_STATUS_SUMMARY_LATCHED,
         NAIBRD_INT_STEERING_ONBOARD_ARM));
   check_status(naibrd_AD_SetChanMappedInterruptVector(cardIndex, module, NAIBRD_AD_STATUS_SUMMARY_LATCHED, vector));
   check_status(naibrd_AD_SetChanMappedInterruptEnable(cardIndex, module, chan, NAIBRD_AD_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
}
© 2026 North Atlantic Industries · https://naii.com

Help Bot

X