Getting Started with WaveForms SDK

Before measuring with the oscilloscope, it must be set up. Change the values to fit your needs.

class data:
    """ stores the sampling frequency and the buffer size """
    sampling_frequency = 20e06
    buffer_size = 8192
 
def open(device_data, sampling_frequency=20e06, buffer_size=8192, offset=0, amplitude_range=5):
    """
        initialize the oscilloscope
        parameters: - device data
                    - sampling frequency in Hz, default is 20MHz
                    - buffer size, default is 8192
                    - offset voltage in Volts, default is 0V
                    - amplitude range in Volts, default is ±5V
    """
    # enable all channels
    dwf.FDwfAnalogInChannelEnableSet(device_data.handle, ctypes.c_int(0), ctypes.c_bool(True))
 
    # set offset voltage (in Volts)
    dwf.FDwfAnalogInChannelOffsetSet(device_data.handle, ctypes.c_int(0), ctypes.c_double(offset))
 
    # set range (maximum signal amplitude in Volts)
    dwf.FDwfAnalogInChannelRangeSet(device_data.handle, ctypes.c_int(0), ctypes.c_double(amplitude_range))
 
    # set the buffer size (data point in a recording)
    dwf.FDwfAnalogInBufferSizeSet(device_data.handle, ctypes.c_int(buffer_size))
 
    # set the acquisition frequency (in Hz)
    dwf.FDwfAnalogInFrequencySet(device_data.handle, ctypes.c_double(sampling_frequency))
 
    # disable averaging (for more info check the documentation)
    dwf.FDwfAnalogInChannelFilterSet(device_data.handle, ctypes.c_int(-1), constants.filterDecimate)
    data.sampling_frequency = sampling_frequency
    data.buffer_size = buffer_size
    return

You can measure voltages, like with the Voltmeter instrument in WaveForms.

def measure(device_data, channel):
    """
        measure a voltage
        parameters: - device data
                    - the selected oscilloscope channel (1-2, or 1-4)
 
        returns:    - the measured voltage in Volts
    """
    # set up the instrument
    dwf.FDwfAnalogInConfigure(device_data.handle, ctypes.c_bool(False), ctypes.c_bool(False))
 
    # read data to an internal buffer
    dwf.FDwfAnalogInStatus(device_data.handle, ctypes.c_bool(False), ctypes.c_int(0))
 
    # extract data from that buffer
    voltage = ctypes.c_double()   # variable to store the measured voltage
    dwf.FDwfAnalogInStatusSample(device_data.handle, ctypes.c_int(channel - 1), ctypes.byref(voltage))
 
    # store the result as float
    voltage = voltage.value
    return voltage

The most important feature of the oscilloscope is, that it can record signals. The recorded voltages can be stored in a list.

def record(device_data, channel):
    """
        record an analog signal
        parameters: - device data
                    - the selected oscilloscope channel (1-2, or 1-4)
        returns:    - buffer - a list with the recorded voltages
                    - time - a list with the time moments for each voltage in seconds (with the same index as "buffer")
    """
    # set up the instrument
    dwf.FDwfAnalogInConfigure(device_data.handle, ctypes.c_bool(False), ctypes.c_bool(True))
 
    # read data to an internal buffer
    while True:
        status = ctypes.c_byte()    # variable to store buffer status
        dwf.FDwfAnalogInStatus(device_data.handle, ctypes.c_bool(True), ctypes.byref(status))
 
        # check internal buffer status
        if status.value == constants.DwfStateDone.value:
                # exit loop when ready
                break
 
    # copy buffer
    buffer = (ctypes.c_double * data.buffer_size)()   # create an empty buffer
    dwf.FDwfAnalogInStatusData(device_data.handle, ctypes.c_int(channel - 1), buffer, ctypes.c_int(data.buffer_size))
 
    # calculate aquisition time
    time = range(0, data.buffer_size)
    time = [moment / data.sampling_frequency for moment in time]
 
    # convert into list
    buffer = [float(element) for element in buffer]
    return buffer, time

After usage, reset the oscilloscope to the default settings.

def close(device_data):
    """
        reset the scope
    """
    dwf.FDwfAnalogInReset(device_data.handle)
    return

Use the waveform generator to generate different signals.

class function:
    """ function names """
    custom = constants.funcCustom
    sine = constants.funcSine
    square = constants.funcSquare
    triangle = constants.funcTriangle
    noise = constants.funcNoise
    dc = constants.funcDC
    pulse = constants.funcPulse
    trapezium = constants.funcTrapezium
    sine_power = constants.funcSinePower
    ramp_up = constants.funcRampUp
    ramp_down = constants.funcRampDown

def generate(device_data, channel, function, offset, frequency=1e03, amplitude=1, symmetry=50, wait=0, run_time=0, repeat=0, data=[]):
    """
        generate an analog signal
        parameters: - device data
                    - the selected wavegen channel (1-2)
                    - function - possible: custom, sine, square, triangle, noise, ds, pulse, trapezium, sine_power, ramp_up, ramp_down
                    - offset voltage in Volts
                    - frequency in Hz, default is 1KHz
                    - amplitude in Volts, default is 1V
                    - signal symmetry in percentage, default is 50%
                    - wait time in seconds, default is 0s
                    - run time in seconds, default is infinite (0)
                    - repeat count, default is infinite (0)
                    - data - list of voltages, used only if function=custom, default is empty
    """
    # enable channel
    channel = ctypes.c_int(channel - 1)
    dwf.FDwfAnalogOutNodeEnableSet(device_data.handle, channel, constants.AnalogOutNodeCarrier, ctypes.c_bool(True))
 
    # set function type
    dwf.FDwfAnalogOutNodeFunctionSet(device_data.handle, channel, constants.AnalogOutNodeCarrier, function)
 
    # load data if the function type is custom
    if function == constants.funcCustom:
        data_length = len(data)
        buffer = (ctypes.c_double * data_length)()
        for index in range(0, len(buffer)):
            buffer[index] = ctypes.c_double(data[index])
        dwf.FDwfAnalogOutNodeDataSet(device_data.handle, channel, constants.AnalogOutNodeCarrier, buffer, ctypes.c_int(data_length))
 
    # set frequency
    dwf.FDwfAnalogOutNodeFrequencySet(device_data.handle, channel, constants.AnalogOutNodeCarrier, ctypes.c_double(frequency))
 
    # set amplitude or DC voltage
    dwf.FDwfAnalogOutNodeAmplitudeSet(device_data.handle, channel, constants.AnalogOutNodeCarrier, ctypes.c_double(amplitude))
 
    # set offset
    dwf.FDwfAnalogOutNodeOffsetSet(device_data.handle, channel, constants.AnalogOutNodeCarrier, ctypes.c_double(offset))
 
    # set symmetry
    dwf.FDwfAnalogOutNodeSymmetrySet(device_data.handle, channel, constants.AnalogOutNodeCarrier, ctypes.c_double(symmetry))
 
    # set running time limit
    dwf.FDwfAnalogOutRunSet(device_data.handle, channel, ctypes.c_double(run_time))
 
    # set wait time before start
    dwf.FDwfAnalogOutWaitSet(device_data.handle, channel, ctypes.c_double(wait))
 
    # set number of repeating cycles
    dwf.FDwfAnalogOutRepeatSet(device_data.handle, channel, ctypes.c_int(repeat))
 
    # start
    dwf.FDwfAnalogOutConfigure(device_data.handle, channel, ctypes.c_bool(True))
    return

After usage, reset the wavegen to the default settings.

def close(device_data, channel=0):
    """
        reset a wavegen channel, or all channels (channel=0)
    """
    channel = ctypes.c_int(channel - 1)
    dwf.FDwfAnalogOutReset(device_data.handle, channel)
    return

To make the usage of the above functions easier, you can create a wrapper function, which is able to call the function you need (if the device name is set).

class data:
    """ power supply parameters """
    master_state = False    # master switch
    state = False           # digital/6V/positive supply state
    positive_state = False  # positive supply switch
    negative_state = False  # negative supply switch
    positive_voltage = 0    # positive supply voltage
    negative_voltage = 0    # negative supply voltage
    voltage = 0             # digital/positive supply voltage
    positive_current = 0    # positive supply current
    negative_current = 0    # negative supply current
    current = 0             # digital/6V supply current
 
def switch(device_data, supplies_data):
    """
        turn the power supplies on/off
        parameters: - device data
                    - class containing supplies data:
                        - master_state
                        - state and/or positive_state and negative_state
                        - voltage and/or positive_voltage and negative_voltage
                        - current and/or positive_current and negative_current
    """
    if device_data.name == "Analog Discovery":
        # switch fixed supplies on AD
        supply_state = supplies_data.state or supplies_data.positive_state
        _switch_fixed_(device_data, supplies_data.master_state, supply_state, supplies_data.negative_state)
 
    elif device_data.name == "Analog Discovery 2" or device_data.name == "Analog Discovery Studio":
        # switch variable supplies on AD2
        supply_state = supplies_data.state or supplies_data.positive_state
        supply_voltage = supplies_data.voltage + supplies_data.positive_voltage
        _switch_variable_(device_data, supplies_data.master_state, supply_state, supplies_data.negative_state, supply_voltage, supplies_data.negative_voltage)
 
    elif device_data.name == "Digital Discovery" or device_data.name == "Analog Discovery Pro 3X50":
        # switch the digital supply on DD, or ADP3x50
        supply_state = supplies_data.master_state and (supplies_data.state or supplies_data.positive_state)
        supply_voltage = supplies_data.voltage + supplies_data.positive_voltage
        _switch_digital_(device_data, supply_state, supply_voltage)
 
    elif device_data.name == "Analog Discovery Pro 5250":
        # switch the 6V supply on ADP5250
        supply_state = supplies_data.master_state and supplies_data.state
        _switch_6V_(device_data, supply_state, supplies_data.voltage, supplies_data.current)
        # switch the 25V supplies on ADP5250
        supply_positive_state = supplies_data.master_state and supplies_data.positive_state
        supply_negative_state = supplies_data.master_state and supplies_data.negative_state
        _switch_25V_(device_data, supply_positive_state, supply_negative_state, supplies_data.positive_voltage, supplies_data.negative_voltage, supplies_data.positive_current, supplies_data.negative_current)
    return

After usage, reset the supplies to the default settings.

def close(device_data):
    """
        reset the supplies
    """
    dwf.FDwfAnalogIOReset(device_data.handle)
    return

Before measuring with the digital multimeter, it must be enabled.

def open(device_data):
    """
        initialize the digital multimeter
    """
    # enable the DMM
    dwf.FDwfAnalogIOChannelNodeSet(device_data.handle, ctypes.c_int(3), ctypes.c_int(0), ctypes.c_double(1.0))
    return

You can use the digital multimeter to measure AC, or DC voltages (in Volts), with an input impedance of 10MΩ, or 10GΩ, low (<100mA), or high AC, or DC currents (up to 10A), resistance, conductance, temperature and more, with automatic, or fixed range.

def measure(device_data, mode, ac=False, range=0, high_impedance=False):
    """
        measure a voltage/current/resistance/continuity/temperature
        parameters: - device data
                    - mode: "voltage", "low current", "high current", "resistance", "continuity", "diode", "temperature"
                    - ac: True means AC value, False means DC value, default is DC
                    - range: voltage/current/resistance/temperature range, 0 means auto, default is auto
                    - high_impedance: input impedance for DC voltage measurement, False means 10MΩ, True means 10GΩ, default is 10MΩ
 
        returns:    - the measured value in V/A/Ω/°C, or None on error
    """
    # set voltage mode
    if mode == "voltage":
        # set coupling
        if ac:
            dwf.FDwfAnalogIOChannelNodeSet(device_data.handle, ctypes.c_int(3), ctypes.c_int(1), constants.DwfDmmACVoltage)
        else:
            dwf.FDwfAnalogIOChannelNodeSet(device_data.handle, ctypes.c_int(3), ctypes.c_int(1), constants.DwfDmmDCVoltage)
 
        # set input impedance
        if high_impedance:
            dwf.FDwfAnalogIOChannelNodeSet(device_data.handle, ctypes.c_int(3), ctypes.c_int(5), ctypes.c_double(1))
        else:
            dwf.FDwfAnalogIOChannelNodeSet(device_data.handle, ctypes.c_int(3), ctypes.c_int(5), ctypes.c_double(0))
 
    # set high current mode
    elif mode == "high current":
        # set coupling
        if ac:
            dwf.FDwfAnalogIOChannelNodeSet(device_data.handle, ctypes.c_int(3), ctypes.c_int(1), constants.DwfDmmACCurrent)
        else:
            dwf.FDwfAnalogIOChannelNodeSet(device_data.handle, ctypes.c_int(3), ctypes.c_int(1), constants.DwfDmmDCCurrent)
 
    # set low current mode
    elif mode == "low current":
        # set coupling
        if ac:
            dwf.FDwfAnalogIOChannelNodeSet(device_data.handle, ctypes.c_int(3), ctypes.c_int(1), constants.DwfDmmACLowCurrent)
        else:
            dwf.FDwfAnalogIOChannelNodeSet(device_data.handle, ctypes.c_int(3), ctypes.c_int(1), constants.DwfDmmDCLowCurrent)
 
    # set resistance mode
    elif mode == "resistance":
        dwf.FDwfAnalogIOChannelNodeSet(device_data.handle, ctypes.c_int(3), ctypes.c_int(1), constants.DwfDmmResistance)
 
    # set continuity mode
    elif mode == "continuity":
        dwf.FDwfAnalogIOChannelNodeSet(device_data.handle, ctypes.c_int(3), ctypes.c_int(1), constants.DwfDmmContinuity)
 
    # set diode mode
    elif mode == "diode":
        dwf.FDwfAnalogIOChannelNodeSet(device_data.handle, ctypes.c_int(3), ctypes.c_int(1), constants.DwfDmmDiode)
 
    # set temperature mode
    elif mode == "temperature":
        dwf.FDwfAnalogIOChannelNodeSet(device_data.handle, ctypes.c_int(3), ctypes.c_int(1), constants.DwfDmmTemperature)
 
    # set range
    dwf.FDwfAnalogIOChannelNodeSet(device_data.handle, ctypes.c_int(3), ctypes.c_int(2), ctypes.c_double(range))
 
    # fetch analog I/O status
    if dwf.FDwfAnalogIOStatus(device_data.handle) == 0:
        # signal error
        return None
 
    # get reading
    measurement = ctypes.c_double()
    dwf.FDwfAnalogIOChannelNodeStatus(device_data.handle, ctypes.c_int(3), ctypes.c_int(3), ctypes.byref(measurement))
 
    return measurement.value

After usage, reset the instrument to the default settings.

def close(device_data):
    """
        reset the instrument
    """
    # disable the DMM
    dwf.FDwfAnalogIOChannelNodeSet(device_data.handle, ctypes.c_int(3), ctypes.c_int(0), ctypes.c_double(0))
    # reset the instrument
    dwf.FDwfAnalogIOReset(device_data.handle)
    return

Before measuring with the logic analyzer, it must be set up. Change the values to fit your needs.

class data:
    """ stores the sampling frequency and the buffer size """
    sampling_frequency = 100e06
    buffer_size = 4096
 
def open(device_data, sampling_frequency=100e06, buffer_size=4096):
    """
        initialize the logic analyzer
        parameters: - device data
                    - sampling frequency in Hz, default is 100MHz
                    - buffer size, default is 4096
    """
    # get internal clock frequency
    internal_frequency = ctypes.c_double()
    dwf.FDwfDigitalInInternalClockInfo(device_data.handle, ctypes.byref(internal_frequency))
 
    # set clock frequency divider (needed for lower frequency input signals)
    dwf.FDwfDigitalInDividerSet(device_data.handle, ctypes.c_int(int(internal_frequency.value / sampling_frequency)))
 
    # set 16-bit sample format
    dwf.FDwfDigitalInSampleFormatSet(device_data.handle, ctypes.c_int(16))
 
    # set buffer size
    dwf.FDwfDigitalInBufferSizeSet(device_data.handle, ctypes.c_int(buffer_size))
    data.sampling_frequency = sampling_frequency
    data.buffer_size = buffer_size
    return

Record logic signals in a list of lists, then select the one specific for the required DIO line.

def record(device_data, channel):
    """
        initialize the logic analyzer
        parameters: - device data
                    - channel - the selected DIO line number
        returns:    - buffer - a list with the recorded logic values
                    - time - a list with the time moments for each value in seconds (with the same index as "buffer")
    """
    # set up the instrument
    dwf.FDwfDigitalInConfigure(device_data.handle, ctypes.c_bool(False), ctypes.c_bool(True))
 
    # read data to an internal buffer
    while True:
        status = ctypes.c_byte()    # variable to store buffer status
        dwf.FDwfDigitalInStatus(device_data.handle, ctypes.c_bool(True), ctypes.byref(status))
 
        if status.value == constants.stsDone.value:
            # exit loop when finished
            break
 
    # get samples
    buffer = (ctypes.c_uint16 * data.buffer_size)()
    dwf.FDwfDigitalInStatusData(device_data.handle, buffer, ctypes.c_int(2 * data.buffer_size))
 
    # convert buffer to list of lists of integers
    buffer = [int(element) for element in buffer]
    result = [[] for _ in range(16)]
    for point in buffer:
        for index in range(16):
            result[index].append(point & (1 << index))
 
    # calculate acquisition time
    time = range(0, data.buffer_size)
    time = [moment / data.sampling_frequency for moment in time]
 
    # get channel specific data
    buffer = result[channel]
    return buffer, time

After usage, reset the logic analyzer to the default settings.

def close(device_data):
    """
        reset the instrument
    """
    dwf.FDwfDigitalInReset(device_data.handle)
    return

Configure the pattern generator to generate logic signals.

class function:
    """ function names """
    pulse = constants.DwfDigitalOutTypePulse
    custom = constants.DwfDigitalOutTypeCustom
    random = constants.DwfDigitalOutTypeRandom
 
class trigger_source:
    """ trigger source names """
    none = constants.trigsrcNone
    analog = constants.trigsrcDetectorAnalogIn
    digital = constants.trigsrcDetectorDigitalIn
    external = [None, constants.trigsrcExternal1, constants.trigsrcExternal2, constants.trigsrcExternal3, constants.trigsrcExternal4]
 
class idle_state:
    """ channel idle states """
    initial = constants.DwfDigitalOutIdleInit
    high = constants.DwfDigitalOutIdleHigh
    low = constants.DwfDigitalOutIdleLow
    high_impedance = constants.DwfDigitalOutIdleZet

def generate(device_data, channel, function, frequency, duty_cycle=50, data=[], wait=0, repeat=0, run_time=0, idle=idle_state.initial, trigger_enabled=False, trigger_source=trigger_source.none, trigger_edge_rising=True):
    """
        generate a logic signal
 
        parameters: - channel - the selected DIO line number
                    - function - possible: pulse, custom, random
                    - frequency in Hz
                    - duty cycle in percentage, used only if function = pulse, default is 50%
                    - data list, used only if function = custom, default is empty
                    - wait time in seconds, default is 0 seconds
                    - repeat count, default is infinite (0)
                    - run_time: in seconds, 0=infinite, "auto"=auto
                    - idle - possible: initial, high, low, high_impedance, default = initial
                    - trigger_enabled - include/exclude trigger from repeat cycle
                    - trigger_source - possible: none, analog, digital, external[1-4]
                    - trigger_edge_rising - True means rising, False means falling, None means either, default is rising
    """
    # get internal clock frequency
    internal_frequency = ctypes.c_double()
    dwf.FDwfDigitalOutInternalClockInfo(device_data.handle, ctypes.byref(internal_frequency))
 
    # get counter value range
    counter_limit = ctypes.c_uint()
    dwf.FDwfDigitalOutCounterInfo(device_data.handle, ctypes.c_int(channel), ctypes.c_int(0), ctypes.byref(counter_limit))
 
    # calculate the divider for the given signal frequency
    if function == constants.DwfDigitalOutTypePulse:
        divider = int(-(-(internal_frequency.value / frequency) // counter_limit.value))
    else:
        divider = int(internal_frequency.value / frequency)
 
    # enable the respective channel
    dwf.FDwfDigitalOutEnableSet(device_data.handle, ctypes.c_int(channel), ctypes.c_int(1))
 
    # set output type
    dwf.FDwfDigitalOutTypeSet(device_data.handle, ctypes.c_int(channel), function)
 
    # set frequency
    dwf.FDwfDigitalOutDividerSet(device_data.handle, ctypes.c_int(channel), ctypes.c_int(divider))
 
    # set idle state
    dwf.FDwfDigitalOutIdleSet(device_data.handle, ctypes.c_int(channel), idle)
 
    # set PWM signal duty cycle
    if function == constants.DwfDigitalOutTypePulse:
        # calculate counter steps to get the required frequency
        steps = int(round(internal_frequency.value / frequency / divider))
        # calculate steps for low and high parts of the period
        high_steps = int(steps * duty_cycle / 100)
        low_steps = int(steps - high_steps)
        dwf.FDwfDigitalOutCounterSet(device_data.handle, ctypes.c_int(channel), ctypes.c_int(low_steps), ctypes.c_int(high_steps))
 
    # load custom signal data
    elif function == constants.DwfDigitalOutTypeCustom:
        # format data
        buffer = (ctypes.c_ubyte * ((len(data) + 7) >> 3))(0)
        for index in range(len(data)):
            if data[index] != 0:
                buffer[index >> 3] |= 1 << (index & 7)
 
        # load data
        dwf.FDwfDigitalOutDataSet(device_data.handle, ctypes.c_int(channel), ctypes.byref(buffer), ctypes.c_int(len(data)))
 
    # calculate run length
    if run_time == "auto":
        run_time = len(data) / frequency
 
    # set wait time
    dwf.FDwfDigitalOutWaitSet(device_data.handle, ctypes.c_double(wait))
 
    # set repeat count
    dwf.FDwfDigitalOutRepeatSet(device_data.handle, ctypes.c_int(repeat))
 
    # set run length
    dwf.FDwfDigitalOutRunSet(device_data.handle, ctypes.c_double(run_time))
 
    # enable triggering
    dwf.FDwfDigitalOutRepeatTriggerSet(device_data.handle, ctypes.c_int(trigger_enabled))
 
    if trigger_enabled:
        # set trigger source
        dwf.FDwfDigitalOutTriggerSourceSet(device_data.handle, trigger_source)
 
        # set trigger slope
        if trigger_edge_rising == True:
            # rising edge
            dwf.FDwfDigitalOutTriggerSlopeSet(device_data.handle, constants.DwfTriggerSlopeRise)
        elif trigger_edge_rising == False:
            # falling edge
            dwf.FDwfDigitalOutTriggerSlopeSet(device_data.handle, constants.DwfTriggerSlopeFall)
        elif trigger_edge_rising == None:
            # either edge
            dwf.FDwfDigitalOutTriggerSlopeSet(device_data.handle, constants.DwfTriggerSlopeEither)
 
    # start generating the signal
    dwf.FDwfDigitalOutConfigure(device_data.handle, ctypes.c_int(True))
    return

After usage, reset the pattern generator to the default settings.

def close(device_data):
    """
        reset the instrument
    """
    dwf.FDwfDigitalOutReset(device_data.handle)
    return

Each digital pin of the Test & Measurement device can be used only as input, or as output at a time. The default settings for each line are input states.

def set_mode(device_data, channel, output):
    """
        set a DIO line as input, or as output
        parameters: - device data
                    - selected DIO channel number
                    - True means output, False means input
    """
    # load current state of the output enable buffer
    mask = ctypes.c_uint16()
    dwf.FDwfDigitalIOOutputEnableGet(device_data.handle, ctypes.byref(mask))
 
    # convert mask to list
    mask = list(bin(mask.value)[2:].zfill(16))
 
    # set bit in mask
    if output:
        mask[15 - channel] = "1"
    else:
        mask[15 - channel] = "0"
 
    # convert mask to number
    mask = "".join(element for element in mask)
    mask = int(mask, 2)
 
    # set the pin to output
    dwf.FDwfDigitalIOOutputEnableSet(device_data.handle, ctypes.c_int(mask))
    return

Read the state of a DIO line with the following code snippet:

def get_state(device_data, channel):
    """
        get the state of a DIO line
        parameters: - device data
                    - selected DIO channel number
        returns:    - True if the channel is HIGH, or False, if the channel is LOW
    """
    # load internal buffer with current state of the pins
    dwf.FDwfDigitalIOStatus(device_data.handle)
 
    # get the current state of the pins
    data = ctypes.c_uint32()  # variable for this current state
    dwf.FDwfDigitalIOInputStatus(device_data.handle, ctypes.byref(data))
 
    # convert the state to a 16 character binary string
    data = list(bin(data.value)[2:].zfill(16))
 
    # check the required bit
    if data[15 - channel] != "0":
        value = True
    else:
        value = False
    return value

To set the state of a DIO line, it must be set as output!

def set_state(device_data, channel, value):
    """
        set a DIO line as input, or as output
        parameters: - device data
                    - selected DIO channel number
                    - True means HIGH, False means LOW
    """
    # load current state of the output state buffer
    mask = ctypes.c_uint16()
    dwf.FDwfDigitalIOOutputGet(device_data.handle, ctypes.byref(mask))
 
    # convert mask to list
    mask = list(bin(mask.value)[2:].zfill(16))
 
    # set bit in mask
    if value:
        mask[15 - channel] = "1"
    else:
        mask[15 - channel] = "0"
 
    # convert mask to number
    mask = "".join(element for element in mask)
    mask = int(mask, 2)
 
    # set the pin state
    dwf.FDwfDigitalIOOutputSet(device_data.handle, ctypes.c_int(mask))
    return

After usage, reset the instrument to the default settings.

def close(device_data):
    """
        reset the instrument
    """
    dwf.FDwfDigitalIOReset(device_data.handle)
    return

Before using a communication interface, it must be initialized by setting the communication parameters to the desired values.

def open(device_data, rx, tx, baud_rate=9600, parity=None, data_bits=8, stop_bits=1):
    """
        initializes UART communication
 
        parameters: - device data
                    - rx (DIO line used to receive data)
                    - tx (DIO line used to send data)
                    - baud_rate (communication speed, default is 9600 bits/s)
                    - parity possible: None (default), True means even, False means odd
                    - data_bits (default is 8)
                    - stop_bits (default is 1)
    """
    # set baud rate
    dwf.FDwfDigitalUartRateSet(device_data.handle, ctypes.c_double(baud_rate))
 
    # set communication channels
    dwf.FDwfDigitalUartTxSet(device_data.handle, ctypes.c_int(tx))
    dwf.FDwfDigitalUartRxSet(device_data.handle, ctypes.c_int(rx))
 
    # set data bit count
    dwf.FDwfDigitalUartBitsSet(device_data.handle, ctypes.c_int(data_bits))
 
    # set parity bit requirements
    if parity == True:
        parity = 2
    elif parity == False:
        parity = 1
    else:
        parity = 0
    dwf.FDwfDigitalUartParitySet(device_data.handle, ctypes.c_int(parity))
 
    # set stop bit count
    dwf.FDwfDigitalUartStopSet(device_data.handle, ctypes.c_double(stop_bits))
 
    # initialize channels with idle levels
 
    # dummy read
    dummy_buffer = ctypes.create_string_buffer(0)
    dummy_buffer = ctypes.c_int(0)
    dummy_parity_flag = ctypes.c_int(0)
    dwf.FDwfDigitalUartRx(device_data.handle, dummy_buffer, ctypes.c_int(0), ctypes.byref(dummy_buffer), ctypes.byref(dummy_parity_flag))
 
    # dummy write
    dwf.FDwfDigitalUartTx(device_data.handle, dummy_buffer, ctypes.c_int(0))
    return

Use the function to the right to read data on an initialized UART interface.

def read(device_data):
    """
        receives data from UART
 
        parameters: - device data
        return:     - integer list containing the received bytes
                    - error message or empty string
    """
    # variable to store results
    error = ""
    rx_data = []
 
    # create empty string buffer
    data = (ctypes.c_ubyte * 8193)()
 
    # character counter
    count = ctypes.c_int(0)
 
    # parity flag
    parity_flag= ctypes.c_int(0)
 
    # read up to 8k characters
    dwf.FDwfDigitalUartRx(device_data.handle, data, ctypes.c_int(ctypes.sizeof(data)-1), ctypes.byref(count), ctypes.byref(parity_flag))
 
    # append current data chunks
    for index in range(0, count.value):
        rx_data.append(int(data[index]))
 
    # ensure data integrity
    while count.value > 0:
        # create empty string buffer
        data = (ctypes.c_ubyte * 8193)()
 
        # character counter
        count = ctypes.c_int(0)
 
        # parity flag
        parity_flag= ctypes.c_int(0)
 
        # read up to 8k characters
        dwf.FDwfDigitalUartRx(device_data.handle, data, ctypes.c_int(ctypes.sizeof(data)-1), ctypes.byref(count), ctypes.byref(parity_flag))
        # append current data chunks
        for index in range(0, count.value):
            rx_data.append(int(data[index]))
 
        # check for not acknowledged
        if error == "":
            if parity_flag.value < 0:
                error = "Buffer overflow"
            elif parity_flag.value > 0:
                error = "Parity error: index {}".format(parity_flag.value)
    return rx_data, 

Use the function to the right to send data on an initialized UART interface to another device.

def write(device_data, data):
    """
        send data through UART
 
        parameters: - data of type string, int, or list of characters/integers
    """
    # cast data
    if type(data) == int:
        data = "".join(chr (data))
    elif type(data) == list:
        data = "".join(chr (element) for element in data)
 
    # encode the string into a string buffer
    data = ctypes.create_string_buffer(data.encode("UTF-8"))
 
    # send text, trim zero ending
    dwf.FDwfDigitalUartTx(device_data.handle, data, ctypes.c_int(ctypes.sizeof(data)-1))
    return

After usage, reset the instrument to the default settings.

def close(device_data):
    """
        reset the uart interface
    """
    dwf.FDwfDigitalUartReset(device_data.handle)
    return

Before using a communication interface, it must be initialized by setting the communication parameters to the desired values.

def open(device_data, cs, sck, miso=None, mosi=None, clk_frequency=1e06, mode=0, order=True):
    """
        initializes SPI communication
        parameters: - device data
                    - cs (DIO line used for chip select)
                    - sck (DIO line used for serial clock)
                    - miso (DIO line used for master in - slave out, optional)
                    - mosi (DIO line used for master out - slave in, optional)
                    - frequency (communication frequency in Hz, default is 1MHz)
                    - mode (SPI mode: 0: CPOL=0, CPHA=0; 1: CPOL-0, CPHA=1; 2: CPOL=1, CPHA=0; 3: CPOL=1, CPHA=1)
                    - order (endianness, True means MSB first - default, False means LSB first)
    """
    # set the clock frequency
    dwf.FDwfDigitalSpiFrequencySet(device_data.handle, ctypes.c_double(clk_frequency))
 
    # set the clock pin
    dwf.FDwfDigitalSpiClockSet(device_data.handle, ctypes.c_int(sck))
 
    if mosi != None:
        # set the mosi pin
        dwf.FDwfDigitalSpiDataSet(device_data.handle, ctypes.c_int(0), ctypes.c_int(mosi))
 
        # set the initial state
        dwf.FDwfDigitalSpiIdleSet(device_data.handle, ctypes.c_int(0), constants.DwfDigitalOutIdleZet)
 
    if miso != None:
        # set the miso pin
        dwf.FDwfDigitalSpiDataSet(device_data.handle, ctypes.c_int(1), ctypes.c_int(miso))
 
        # set the initial state
        dwf.FDwfDigitalSpiIdleSet(device_data.handle, ctypes.c_int(1), constants.DwfDigitalOutIdleZet)
 
    # set the SPI mode
    dwf.FDwfDigitalSpiModeSet(device_data.handle, ctypes.c_int(mode))
 
    # set endianness
    if order:
        # MSB first
        dwf.FDwfDigitalSpiOrderSet(device_data.handle, ctypes.c_int(1))
    else:
        # LSB first
        dwf.FDwfDigitalSpiOrderSet(device_data.handle, ctypes.c_int(0))
 
    # set the cs pin HIGH
    dwf.FDwfDigitalSpiSelect(device_data.handle, ctypes.c_int(cs), ctypes.c_int(1))
 
    # dummy write
    dwf.FDwfDigitalSpiWriteOne(device_data.handle, ctypes.c_int(1), ctypes.c_int(0), ctypes.c_int(0))
    return

Use the function to the right to read data on an initialized SPI interface.

def read(device_data, count, cs):
    """
        receives data from SPI
        parameters: - device data
                    - count (number of bytes to receive)
                    - chip select line number
        return:     - integer list containing the received bytes
    """
    # enable the chip select line
    dwf.FDwfDigitalSpiSelect(device_data.handle, ctypes.c_int(cs), ctypes.c_int(0))
 
    # create buffer to store data
    buffer = (ctypes.c_ubyte*count)()
 
    # read array of 8 bit elements
    dwf.FDwfDigitalSpiRead(device_data.handle, ctypes.c_int(1), ctypes.c_int(8), buffer, ctypes.c_int(len(buffer)))
 
    # disable the chip select line
    dwf.FDwfDigitalSpiSelect(device_data.handle, ctypes.c_int(cs), ctypes.c_int(1))
 
    # decode data
    data = [int(element) for element in buffer]
    return data

Use the function to the right to send data on an initialized SPI interface to another device.

def write(device_data, data, cs):
    """
        send data through SPI
        parameters: - device data
                    - data of type string, int, or list of characters/integers
                    - chip select line number
    """
    # cast data
    if type(data) == int:
        data = "".join(chr (data))
    elif type(data) == list:
        data = "".join(chr (element) for element in data)
 
    # enable the chip select line
    dwf.FDwfDigitalSpiSelect(device_data.handle, ctypes.c_int(cs), ctypes.c_int(0))
 
    # create buffer to write
    data = bytes(data, "utf-8")
    buffer = (ctypes.c_ubyte * len(data))()
    for index in range(0, len(buffer)):
        buffer[index] = ctypes.c_ubyte(data[index])
 
    # write array of 8 bit elements
    dwf.FDwfDigitalSpiWrite(device_data.handle, ctypes.c_int(1), ctypes.c_int(8), buffer, ctypes.c_int(len(buffer)))
 
    # disable the chip select line
    dwf.FDwfDigitalSpiSelect(device_data.handle, ctypes.c_int(cs), ctypes.c_int(1))
    return

After usage, reset the instrument to the default settings.

def close(device_data):
    """
        reset the spi interface
    """
    dwf.FDwfDigitalSpiReset(device_data.handle)
    return

Before using a communication interface, it must be initialized by setting the communication parameters to the desired values.

def open(device_data, sda, scl, clk_rate=100e03, stretching=True):
    """
        initializes I2C communication
        parameters: - device data
                    - sda (DIO line used for data)
                    - scl (DIO line used for clock)
                    - rate (clock frequency in Hz, default is 100KHz)
                    - stretching (enables/disables clock stretching)
        returns:    - error message or empty string
    """
    # reset the interface
    dwf.FDwfDigitalI2cReset(device_data.handle)
 
    # clock stretching
    if stretching:
        dwf.FDwfDigitalI2cStretchSet(device_data.handle, ctypes.c_int(1))
    else:
        dwf.FDwfDigitalI2cStretchSet(device_data.handle, ctypes.c_int(0))
 
    # set clock frequency
    dwf.FDwfDigitalI2cRateSet(device_data.handle, ctypes.c_double(clk_rate))
 
    #  set communication lines
    dwf.FDwfDigitalI2cSclSet(device_data.handle, ctypes.c_int(scl))
    dwf.FDwfDigitalI2cSdaSet(device_data.handle, ctypes.c_int(sda))
 
    # check bus
    nak = ctypes.c_int()
    dwf.FDwfDigitalI2cClear(device_data.handle, ctypes.byref(nak))
    if nak.value == 0:
        return "Error: I2C bus lockup"
 
    # write 0 bytes
    dwf.FDwfDigitalI2cWrite(device_data.handle, ctypes.c_int(0), ctypes.c_int(0), ctypes.c_int(0), ctypes.byref(nak))
    if nak.value != 0:
        return "NAK: index " + str(nak.value)
    return ""

Use the function to the right to read data on an initialized I2C interface.

def read(device_data, count, address):
    """
        receives data from I2C
 
        parameters: - device data
                    - count (number of bytes to receive)
                    - address (8-bit address of the slave device)
 
        return:     - integer list containing the received bytes
                    - error message or empty string
    """
    # create buffer to store data
    buffer = (ctypes.c_ubyte * count)()
 
    # receive
    nak = ctypes.c_int()
    dwf.FDwfDigitalI2cRead(device_data.handle, ctypes.c_int(address << 1), buffer, ctypes.c_int(count), ctypes.byref(nak))
 
    # decode data
    data = [int(element) for element in buffer]
 
    # check for not acknowledged
    if nak.value != 0:
        return data, "NAK: index " + str(nak.value)
    return data, ""

Use the function to the right to send data on an initialized I2C interface to another device.

def write(device_data, data, address):
    """
        send data through I2C
 
        parameters: - device data
                    - data of type string, int, or list of characters/integers
                    - address (8-bit address of the slave device)
 
        returns:    - error message or empty string
    """
    # cast data
    if type(data) == int:
        data = "".join(chr (data))
    elif type(data) == list:
        data = "".join(chr (element) for element in data)
 
    # encode the string into a string buffer
    data = bytes(data, "utf-8")
    buffer = (ctypes.c_ubyte * len(data))()
    for index in range(0, len(buffer)):
        buffer[index] = ctypes.c_ubyte(data[index])
 
    # send
    nak = ctypes.c_int()
    dwf.FDwfDigitalI2cWrite(device_data.handle, ctypes.c_int(address << 1), buffer, ctypes.c_int(ctypes.sizeof(buffer)), ctypes.byref(nak))
 
    # check for not acknowledged
    if nak.value != 0:
        return "NAK: index " + str(nak.value)
    return ""

After usage, reset the instrument to the default settings.

def close(device_data):
    """
        reset the i2c interface
    """
    dwf.FDwfDigitalI2cReset(device_data.handle)
    return