Analog Peripherals Debugging and Error Handling (SiWx91x Devices)#

This section provides best practices for debugging and error handling when working with analog peripherals on SiWx917 devices. It covers common issues, diagnostic techniques, error recovery patterns, and callback-based fault detection for analog-to-digital converter (ADC) and digital-to-analog converter (DAC) peripherals.

Common Debugging Tips#

Using a Logic Analyzer#

A logic analyzer is an essential tool for verifying timing and signal integrity in ADC and DAC operations. Use it to inspect:

Clock signals. Verify that sampling clocks operate at the expected frequencies.
Control signals. Check enable, trigger, and DMA control signals.
Interrupt timing. Measure callback response times for data-ready events.
FIFO activity. Monitor FIFO fill levels and detect underflow or overflow conditions.

ADC Debugging Strategies#

Signal Integrity#

Ensure that the analog input signal remains within the 0 V to VREF range.
Verify reference voltage stability and analog ground connections.
Confirm that analog input pins are not shared with digital I/O functions.

Configuration Validation#

Verify that ADC channel mappings match physical pin assignments.
Check sampling rates and FIFO thresholds for the intended use case.
Confirm that the input mode (single-ended or differential) matches the hardware design.

Data Analysis#

Compare digital output values with expected analog input levels.
Verify conversion timing consistency across repeated samples.
Use known reference voltages to validate accuracy.

DAC Debugging Strategies#

Output Verification#

Measure DAC output using an oscilloscope to confirm expected voltage levels.
Verify load impedance and avoid heavy loads below 1 kΩ.
Confirm that sample rate and update frequency match the configuration.

Data Path Validation#

Confirm input data format (12-bit unsigned).
Verify correct scaling to match expected voltage output range.
Ensure FIFO ordering matches the intended waveform sequence.

Error Code Handling#

Analog peripheral APIs return status codes of type sl_status_t to indicate success or failure. Consistent handling of these codes ensures reliability and smooth recovery from runtime faults.

Error Code Reference Table#

Analog peripheral driver APIs return standardized status codes (sl_status_t) that help identify issues and guide recovery actions.
Always check for SL_STATUS_OK after each API call to ensure successful operation.


Error Code	Description	Recommended Recovery Action
`SL_STATUS_OK`	Operation completed successfully.	Continue normal operation.
`SL_STATUS_INVALID_PARAMETER`	Invalid configuration or argument.	Verify and correct parameters (such as channel, VREF, and sample rate).
`SL_STATUS_NOT_INITIALIZED`	Peripheral not initialized.	Call initialization function before performing operations.
`SL_STATUS_INVALID_RANGE`	Value out of acceptable range.	Check input values against valid ranges (such as voltage or channel).
`SL_STATUS_INVALID_COUNT`	Invalid count or size parameter.	Verify buffer sizes and sample counts.
`SL_STATUS_FAIL`	General failure detected.	Reset and reinitialize the peripheral.

Interrupt Error Handling#

The SiWx917 ADC peripherals generate interrupts to signal events that require software handling.


Event Type	Description	Recommended Action
`SL_INTERNAL_DMA`	Internal DMA transfer event triggered.	Handle DMA completion, verify data integrity, and prepare the next transfer.
`SL_ADC_STATIC_MODE_EVENT`	ADC static mode conversion completed.	Read conversion result and clear the event flag.

Common Error Codes and Recovery Strategies#

ADC Error Codes#

SL_STATUS_INVALID_PARAMETER

Occurs when invalid arguments are passed to initialization or configuration API functions.

if (status == SL_STATUS_INVALID_PARAMETER) {
  printf("ADC initialization failed: Invalid parameters\n");
  // Validate channel index, VREF, and sampling rate
}if (status == SL_STATUS_INVALID_PARAMETER) {
  printf("ADC initialization failed: Invalid parameters\n");
  // Validate channel index, VREF, and sampling rate
}

SL_STATUS_NOT_READY

Indicates that ADC is not fully initialized or configured.

if (status == SL_STATUS_NOT_READY) {
  printf("ADC not ready – reinitializing...\n");
  sl_si91x_adc_init(adc_channel_config, adc_config, vref_value);
}if (status == SL_STATUS_NOT_READY) {
  printf("ADC not ready – reinitializing...\n");
  sl_si91x_adc_init(adc_channel_config, adc_config, vref_value);
}

SL_STATUS_BUSY

The ADC is performing another conversion or DMA transaction.

if (status == SL_STATUS_BUSY) {
  printf("ADC busy – waiting for completion\n");
  sl_sleeptimer_delay_millisecond(10);
}if (status == SL_STATUS_BUSY) {
  printf("ADC busy – waiting for completion\n");
  sl_sleeptimer_delay_millisecond(10);
}

DAC Error Codes#

SL_STATUS_INVALID_CONFIGURATION

Occurs when configuration parameters are invalid.

if (status == SL_STATUS_INVALID_CONFIGURATION) {
  printf("Invalid DAC configuration\n");
  // Check sample rate, FIFO settings, and pin mapping
}if (status == SL_STATUS_INVALID_CONFIGURATION) {
  printf("Invalid DAC configuration\n");
  // Check sample rate, FIFO settings, and pin mapping
}

SL_STATUS_FAIL

Indicates that the DAC encountered an error during a write or update operation.

if (status == SL_STATUS_FAIL) {
  printf("DAC write failed\n");
  // Re-verify initialization and data format
}if (status == SL_STATUS_FAIL) {
  printf("DAC write failed\n");
  // Re-verify initialization and data format
}

Error Recovery Patterns#

Implementing retry-based recovery improves robustness in the presence of transient failures.

sl_status_t adc_operation_with_recovery(void) {
  sl_status_t status;
  int retries = 0;
  const int max_retries = 3;

  do {
    status = sl_si91x_adc_start(adc_config);
    if (status == SL_STATUS_OK) break;

    switch (status) {
      case SL_STATUS_NOT_READY:
        sl_si91x_adc_deinit(adc_config);
        sl_si91x_adc_init(adc_channel_config, adc_config, vref_value);
        break;

      case SL_STATUS_BUSY:
        sl_sleeptimer_delay_millisecond(10);
        break;

      default:
        printf("Unexpected ADC error: 0x%lx\n", status);
        break;
    }

    retries++;
  } while (retries < max_retries);

  return status;
}sl_status_t adc_operation_with_recovery(void) {
  sl_status_t status;
  int retries = 0;
  const int max_retries = 3;

  do {
    status = sl_si91x_adc_start(adc_config);
    if (status == SL_STATUS_OK) break;

    switch (status) {
      case SL_STATUS_NOT_READY:
        sl_si91x_adc_deinit(adc_config);
        sl_si91x_adc_init(adc_channel_config, adc_config, vref_value);
        break;

      case SL_STATUS_BUSY:
        sl_sleeptimer_delay_millisecond(10);
        break;

      default:
        printf("Unexpected ADC error: 0x%lx\n", status);
        break;
    }

    retries++;
  } while (retries < max_retries);

  return status;
}

Callback-Based Error Detection#

Callbacks provide an efficient mechanism for asynchronous event monitoring and error reporting.

ADC Callback Example#

static void adc_callback_handler(uint8_t channel_no, uint8_t event) {
  switch (event) {
    case SL_ADC_DATA_READY:
      sl_si91x_adc_read_data(adc_config, &channel_id, &adc_data);
      break;

    case SL_ADC_STATIC_MODE_CALLBACK:
      printf("ADC static mode conversion complete\n");
      break;

    default:
      printf("Unexpected ADC event: %d\n", event);
      break;
  }
}static void adc_callback_handler(uint8_t channel_no, uint8_t event) {
  switch (event) {
    case SL_ADC_DATA_READY:
      sl_si91x_adc_read_data(adc_config, &channel_id, &adc_data);
      break;

    case SL_ADC_STATIC_MODE_CALLBACK:
      printf("ADC static mode conversion complete\n");
      break;

    default:
      printf("Unexpected ADC event: %d\n", event);
      break;
  }
}

DAC Callback Example#

static void dac_callback_handler(uint8_t event) {
  switch (event) {
    case SL_DAC_FIFO_EMPTY:
      printf("DAC FIFO empty – refilling buffer\n");
      sl_si91x_dac_write_data(next_samples, sample_count);
      break;

    default:
      printf("Unexpected DAC event: %d\n", event);
      break;
  }
}static void dac_callback_handler(uint8_t event) {
  switch (event) {
    case SL_DAC_FIFO_EMPTY:
      printf("DAC FIFO empty – refilling buffer\n");
      sl_si91x_dac_write_data(next_samples, sample_count);
      break;

    default:
      printf("Unexpected DAC event: %d\n", event);
      break;
  }
}

Troubleshooting Common Issues#

ADC Troubleshooting#


Problem	Cause	Solution
Inconsistent readings	Unstable VREF or poor grounding	Stabilize reference and ground; add bypass capacitors.
Conversion timeout	Power state or clock misconfiguration	Ensure the ADC clock and power state support active operation.
Incorrect readings	Input voltage out of range	Verify scaling and VREF calibration.

DAC Troubleshooting#


Problem	Cause	Solution
Incorrect output voltage	VREF or scaling mismatch	Reconfigure reference voltage and verify data format.
FIFO underrun	Insufficient buffer refill	Use callbacks to maintain FIFO fill levels.
Distorted output	Incorrect sample rate or load	Adjust sample frequency and verify proper output impedance.