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.

Interrupt Error Handling#

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

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
}

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);
}

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);
}

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
}

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
}

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;
}

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;
  }
}

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;
  }
}

Troubleshooting Common Issues#

ADC Troubleshooting#

DAC Troubleshooting#