Running the same measurement 500 times, logging data overnight, or feeding captured samples directly into a Python analysis pipeline is where the WaveForms graphical application may start to fall short.
The WaveForms SDK gives you programmatic control of Digilent test and measurement devices from your own scripts. It is a C-callable API that Python can access through ctypes, making it useful for automation, data logging, and integration with other tools. You get access to the same instruments without needing someone to operate them manually.
If you already know that you want ready-to-run code, head directly to the Getting Started With WaveForms SDK reference guide. It covers installation, device connection, oscilloscope capture, waveform generation, DMM readings, logic analysis, and UART, SPI, and I2C protocol control.
Still deciding whether the SDK fits your project? Keep reading.
What Is the WaveForms SDK, and What Isn’t It?
The WaveForms SDK is the public, C-callable API for Digilent test and measurement devices. It is included with the WaveForms installer. Python programs access it through ctypes, which loads the DWF dynamic library and calls its functions directly.
It is not a separate product, a REST service, or a casual replacement for the graphical interface. It is a programming interface.
Think of the WaveForms application and the SDK as two doors into the same hardware. The application provides graphical instrument panels, while the SDK makes those instruments available as callable functions. Both communicate with the device through the DWF library, so settings that can be adjusted with controls in the GUI can also be configured with function calls in your code.
The primary difference is control. The SDK allows you to script, loop, schedule, and integrate measurements in ways the GUI cannot. That flexibility also means you are responsible for writing and maintaining the program logic instead of clicking through the application.
Supported Devices at a Glance
The WaveForms SDK supports a wide range of Digilent test and measurement devices, including:
- Analog Discovery 2 (previous-generation product)
- Analog Discovery 3 (AD3)
- Analog Discovery Studio Max (ADS Max)
- Analog Discovery Studio (legacy product)
- Digital Discovery
- ADP2230
- ADP2440
- ADP2450
- ADP 3000 Series, including ADP3450
- ADP 5000 Series, including ADP5250
- Electronics Explorer (legacy/retired product)
Supported Programming Languages
The WaveForms SDK is not limited to Python. It supports:
- C
- C++
- C#
- Python
- Visual Basic
Python is a popular choice for scripting because it integrates with tools such as NumPy, SciPy, pandas, and Matplotlib.
When Is the WaveForms SDK the Right Choice?
When does using the SDK make sense? Reach for it when the WaveForms GUI cannot support the scale, repetition, or integration your project requires. The most common reasons to use it are automation, headless operation, and integration with a larger software pipeline.
If your work is interactive and involves one-off measurements, the GUI is usually the better tool.
For Automated Testing
The SDK can run a fixed measurement sequence hundreds or thousands of times, branch based on the result, and automatically record every pass or failure.
This type of repeatable, scripted control is useful for:
- Production-line testing
- Incoming quality control
- Parameter sweeps across a device under test (DUT)
- Repeated validation procedures
- Unattended overnight captures
The WaveForms GUI includes its own scripting environment, but those scripts operate within an active WaveForms session. The SDK is a better fit when you need a standalone program or a workflow that runs without someone operating the graphical application.
For Headless or Remote Operation
A Digilent device operating in a remote laboratory, on a continuous integration system, or inside a manufacturing computer may not have a monitor attached.
The SDK does not require the WaveForms graphical interface to remain open. It can run from the command line, making it useful when the instrument is accessed remotely or through SSH.
When You Need to Integrate With a Larger Pipeline
Use the SDK when measurement data needs to flow directly into other tools.
For example, you might send captured samples to:
- NumPy for an FFT or other numerical analysis
- pandas for statistical analysis and data organization
- Matplotlib for custom plots
- PyTorch for machine-learning classification
- A database or custom logging system
- A larger automated test framework
Where the GUI may end with exporting a CSV file, the SDK can place captured data directly into the Python data structures your code already uses.
When the WaveForms GUI Is the Better Choice
The SDK is not a complete replacement for the WaveForms graphical application. The two tools complement each other.
The GUI is usually the better choice for:
- One-time measurements
- Teaching demonstrations
- Quick sanity checks
- Interactive troubleshooting
- Workflows that require a live view of the signal
- Experimenting with instrument settings
When you want to see a waveform update in real time and adjust a few controls, the GUI is usually faster. The SDK pays off when repetition, scale, unattended operation, or data integration enters the picture.
What Do You Need to Get Started?
Getting started requires three things:
- A supported Digilent test and measurement device
- The free WaveForms software, which includes the SDK
- A working knowledge of Python
You do not need to download the SDK separately.
Hardware
Supported options include Analog Discovery 2, Analog Discovery 3, Digital Discovery, Analog Discovery Studio, and ADP-series devices.
Analog Discovery 3 is a current-generation option supported by the vendor examples included with WaveForms.
Devices use the same general API structure, allowing many SDK examples to work across multiple products. However, available instruments, channels, sample rates, and other capabilities will depend on the connected hardware.
If you are purchasing new hardware specifically to explore the SDK, Analog Discovery 3 is a practical starting point for working with current examples and features.
Software
Install the WaveForms application. For installation instructions, follow the Getting Started With WaveForms SDK guide.
Python 3.x is the primary additional requirement. The ctypes module used to access the DWF library is included with Python.
On Linux, make sure you install the WaveForms package and device-support components appropriate for your distribution and system architecture.
Skills You’ll Want
Basic Python skills, including variables, functions, loops, and imports, will cover many common SDK workflows.
It is also helpful to understand C-style function signatures because the DWF API is accessed through ctypes, and its calls resemble C functions. For example:
FDwfAnalogInStatus()
Familiarity with the WaveForms GUI is useful because the SDK exposes many of the instruments and configuration options found in the graphical panels.
If you have previously automated instruments with LabVIEW, MATLAB, PyVISA, or a similar environment, many of the basic workflow concepts will feel familiar.
How Does the WaveForms SDK Workflow Feel in Practice?
Most WaveForms SDK programs follow a familiar pattern. The details change depending on the instrument and measurement, but the overall workflow remains largely the same.
The Enumerate, Open, Configure, Run, Read, and Close Pattern
A typical SDK program follows these steps:
- Enumerate: List connected devices with a call such as
FDwfEnum(). - Open: Acquire a handle, called
hdwf, to one device. - Configure: Select the instrument and configure settings such as sample rate, buffer size, channel range, or trigger conditions.
- Run: Start the acquisition or signal generation.
- Read: Pull captured samples or measurement results into memory.
- Close: Release the handle so that another process can access the device.
This general pattern applies whether you are capturing a waveform, generating a sine wave, reading a DMM value, or working with digital signals.
The WaveForms SDK reference guide provides runnable examples that demonstrate the different stages of this process.
How the SDK Differs From CLI and REST Interfaces
The WaveForms SDK is a library, not a standalone service.
Your Python process loads the DWF library and calls functions such as FDwfAnalogInStatus() directly. This provides low-level access to the connected device without requiring a separate REST service or remote API.
A device handle also gives your program direct control of that device. If you need several programs or remote users to share the same instrument, you will need to build an additional application or service layer on top of the SDK.
Common Use Cases That Make the SDK Worth Learning
The SDK is particularly useful when repetition, duration, or integration with other software matters.
Automated Production Test Benches
A production-test script might read a serial number from a barcode scanner, run a fixed measurement sequence, compare the results against defined limits, and record a pass-or-fail result.
By following the enumerate, open, configure, run, read, and close pattern, the same program can evaluate multiple devices using a repeatable procedure.
This transforms a manual bench check into an automated and documented workflow.
Long-Duration or Scheduled Data Logging
Monitoring overnight temperature drift or tracking power-supply behavior over a long period is not something you want to watch manually.
With the SDK, you can capture data and write it to disk at defined intervals. The script can continue running for as long as the measurement requires, subject to the hardware, operating system, storage, and program configuration.
Custom Analysis Pipelines With NumPy, pandas, and Matplotlib
You can use the SDK to capture samples and then:
- Run an FFT or other numerical analysis in NumPy
- Organize and summarize results with pandas
- Create custom plots with Matplotlib
- Export results as CSV, Parquet, or another supported format
This is where the SDK begins to repay its learning curve. Instead of working only with the GUI’s built-in tools, you can use measurement data throughout the Python ecosystem.
Integration Into Laboratory or Manufacturing Workflows
Developers can wrap SDK calls inside a Python class or application and connect them to other laboratory or manufacturing systems.
For example, a custom application could trigger a measurement, process the result, store it in a database, and make it available to another internal system. Developers who need network access can also build a REST, gRPC, or other service layer around the SDK.
Embedded Control on Raspberry Pi and Edge Devices
For supported operating systems and processor architectures, pairing a compact computer such as a Raspberry Pi with a Digilent device can support portable, remote, or lower-power instrumentation.
This can be useful for:
- Remote monitoring
- Portable test systems
- Compact laboratory stations
- Edge-based data collection
- Automated educational setups
Before selecting a Raspberry Pi or another ARM-based system, confirm that the available WaveForms package supports the board’s operating system and architecture.
Third-Party Python Wrappers: pydwf and dwfpy
Third-party Python packages can make the SDK easier to use for developers who prefer a more Pythonic interface.
Two wrappers you may encounter are pydwf and dwfpy. Both communicate with the same underlying DWF library, but they organize SDK access differently.
Because these are community-maintained projects rather than the core vendor API, check their current documentation, maintenance status, hardware support, and release history before selecting one for a new project.
When to Use pydwf
You may encounter pydwf in existing projects that require broad access to the DWF API.
It may still be relevant when maintaining an established codebase. However, evaluate its current project status and compatibility before choosing it for new development.
When to Use dwfpy
dwfpy provides a higher-level, more Pythonic interface for common workflows such as oscilloscope capture, arbitrary waveform generation, and DMM readings.
A higher-level wrapper may require less setup code, although it may not expose every advanced capability available through the underlying DWF API.
When Should You Skip Both and Use Raw ctypes?
Use raw ctypes when following Digilent’s vendor examples or when you need direct access to the C API.
This approach keeps your code close to the official function names and reference documentation. When something goes wrong, each function in your program maps directly to an entry in the WaveForms SDK Reference Manual.
Using raw ctypes may require more setup code, but it reduces your dependence on a third-party abstraction.
Where to Find Working Code Examples
You can find WaveForms SDK examples in Digilent’s documentation, in the files installed with WaveForms, and through community support resources.
The Official Getting Started With WaveForms SDK Guide
Digilent’s Getting Started With WaveForms SDK guide is the primary starting point.
It covers:
- Installing the required software
- Connecting to a device
- Capturing oscilloscope data
- Generating waveforms
- Taking DMM readings
- Performing logic analysis
- Generating digital patterns
- Controlling static I/O
- Working with UART, SPI, and I2C protocols
The examples focus on Python and demonstrate the structure of common SDK workflows.
The Vendor Examples Included With WaveForms
Once WaveForms is installed, its SDK samples folder contains example programs for supported programming languages.
The standard locations include:
- Windows 64-bit:
C:\Program Files (x86)\Digilent\WaveFormsSDK\samples - Linux:
/usr/share/digilent/waveforms/samples/ - macOS:
/Applications/WaveForms.app/Contents/Resources/SDK/samples/
These examples are useful when you need a starting point for a particular instrument or function.
The Digilent Test and Measurement Forum
For specific questions, visit the Test and Measurement section of the Digilent Forum.
Existing discussions may already cover the device, function, operating system, error message, or SDK workflow you are troubleshooting.
The WaveForms SDK Reference Manual
For the full function list and parameter documentation, consult the WaveForms SDK Reference Manual.
The manual documents the FDwf* functions, their parameters, return values, and other implementation details.
Frequently Asked Questions
Is the WaveForms SDK Free?
Yes. The SDK is included with the free WaveForms software, so there is no separate SDK purchase.
A supported Digilent test and measurement device is still required to interact with the hardware.
Does the WaveForms SDK Work With Analog Discovery 3?
Can I Run WaveForms SDK Scripts on a Raspberry Pi?
WaveForms and the SDK are available for certain ARM-based operating systems and architectures.
Before beginning a Raspberry Pi project, check the available WaveForms packages against the exact Raspberry Pi model, processor architecture, and operating system you plan to use.
After installing a compatible package, you can connect a supported Digilent device and run SDK scripts without relying on the desktop GUI.
How Do I Handle a Lost USB Connection During a Long Capture?
Design unattended scripts to check function return values and handle connection errors.
If the USB connection is lost, the program may need to:
- Stop the current acquisition.
- Close the existing device handle.
- Detect the device again.
- Reopen the connection.
- Restore the required configuration.
- Resume the measurement when appropriate.
For long acquisitions, write data to disk in smaller chunks. This can help limit data loss if a connection problem interrupts the session.
How Is the WaveForms SDK Different From the WaveForms Scripting Environment?
The scripting environment inside the WaveForms GUI uses JavaScript and operates as part of an active WaveForms session.
The SDK supports standalone programs written in languages such as Python, C, C++, C#, and Visual Basic. It is generally the better option for unattended automation, headless operation, external data analysis, and integration with larger software systems.
Can I Control Multiple Analog Discovery Devices From One Python Script?
The SDK can enumerate connected devices with functions such as FDwfEnum().
A program can then open devices individually and maintain a separate handle for each connection. This can be useful for multi-device test systems, multi-DUT benches, and measurements that require more channels than a single device provides.
The application should close each handle properly after completing the measurements.
