Examples¶
You can download all nifgen examples here
nifgen_arb_waveform.py¶
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 | #!/usr/bin/python
import argparse
import math
import nifgen
import sys
import time
def create_waveform_data(number_of_samples):
waveform_data = []
angle_per_sample = (2 * math.pi) / number_of_samples
for i in range(number_of_samples):
waveform_data.append(math.sin(i * angle_per_sample) * math.sin(i * angle_per_sample * 20))
return waveform_data
def example(resource_name, options, samples, gain, offset, gen_time):
waveform_data = create_waveform_data(samples)
with nifgen.Session(resource_name=resource_name, options=options) as session:
session.output_mode = nifgen.OutputMode.ARB
waveform = session.create_waveform(waveform_data_array=waveform_data)
session.configure_arb_waveform(waveform_handle=waveform, gain=gain, offset=offset)
with session.initiate():
time.sleep(gen_time)
def _main(argsv):
parser = argparse.ArgumentParser(description='Continuously generates an arbitrary waveform.', formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument('-n', '--resource-name', default='PXI1Slot2', help='Resource name of a National Instruments Arbitrary Waveform Generator')
parser.add_argument('-s', '--samples', default=100000, type=int, help='Number of samples')
parser.add_argument('-g', '--gain', default=1.0, type=float, help='Gain')
parser.add_argument('-o', '--offset', default=0.0, type=float, help='DC offset (V)')
parser.add_argument('-t', '--time', default=5.0, type=float, help='Generation time (s)')
parser.add_argument('-op', '--option-string', default='', type=str, help='Option string')
args = parser.parse_args(argsv)
example(args.resource_name, args.option_string, args.samples, args.gain, args.offset, args.time)
def main():
_main(sys.argv[1:])
def test_example():
options = {'simulate': True, 'driver_setup': {'Model': '5433 (2CH)', 'BoardType': 'PXIe', }, }
example('PXI1Slot2', options, 100000, 1.0, 0.0, 5.0)
def test_main():
cmd_line = ['--option-string', 'Simulate=1, DriverSetup=Model:5433 (2CH);BoardType:PXIe', ]
_main(cmd_line)
if __name__ == '__main__':
main()
|
nifgen_script.py¶
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 | #!/usr/bin/python
import argparse
import nifgen
import numpy as np
from scipy import signal
import sys
import time
number_of_points = 256
def calculate_sinewave():
time = np.linspace(start=0, stop=10, num=number_of_points) # np.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)
amplitude = np.sin(time)
sinewave = amplitude.tolist() # List of Float
return sinewave
def calculate_rampup():
ramp = np.linspace(start=0, stop=0.5, num=number_of_points) # np.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)
ramp_up = ramp.tolist() # List of Float
return ramp_up
def calculate_rampdown():
ramp = np.linspace(start=0, stop=0.5, num=number_of_points) # np.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)
ramp_down = ramp.tolist() # List of Float
ramp_down.reverse() # Reverse list to get a ramp down
return ramp_down
def calculate_square():
time = np.linspace(start=0, stop=10, num=number_of_points) # np.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)
square_build = signal.square(t=time, duty=0.5) # signal.square(t, duty=0.5)
square = square_build.tolist() # List of Float
return square
def calculate_triangle():
time = np.linspace(start=0, stop=1, num=number_of_points) # np.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)
triangle_build = signal.sawtooth(t=time) # signal.sawtooth(t, width=1)
triangle = triangle_build.tolist() # List of Float
return triangle
def calculate_gaussian_noise():
random_noise = np.random.normal(loc=0, scale=0.1, size=number_of_points) # random.normal(loc=0.0, scale=1.0, size=None)
noise = random_noise.tolist() # List of Float
return noise
SCRIPT_ALL = '''
script scriptmulti
repeat until scriptTrigger0
generate rampup
generate sine
generate rampdown
end repeat
repeat until scriptTrigger0
generate rampdown
generate square
generate rampup
end repeat
repeat until scriptTrigger0
generate rampup
generate rampdown
end repeat
repeat until scriptTrigger0
generate sine
end repeat
repeat until scriptTrigger0
generate triangle
end repeat
repeat until scriptTrigger0
generate rampdown
generate noise
generate rampup
end repeat
end script
script scriptsine
repeat until scriptTrigger0
generate sine
end repeat
end script
script scriptrampup
repeat until scriptTrigger0
generate rampup
end repeat
end script
script scriptrampdown
repeat until scriptTrigger0
generate rampdown
end repeat
end script
script scriptsquare
repeat until scriptTrigger0
generate square
end repeat
end script
script scripttriangle
repeat until scriptTrigger0
generate triangle
end repeat
end script
script scriptnoise
repeat until scriptTrigger0
generate noise
end repeat
end script
'''
def example(resource_name, options, shape, channel):
with nifgen.Session(resource_name=resource_name, options=options, channel_name=channel) as session:
# CONFIGURATION
# 1 - Set the mode to Script
session.output_mode = nifgen.OutputMode.SCRIPT
# 2 - Configure Trigger:
# SOFTWARE TRIGGER: used in the script
session.script_triggers[0].script_trigger_type = nifgen.ScriptTriggerType.SOFTWARE_EDGE # TRIG_NONE / DIGITAL_EDGE / DIGITAL_LEVEL / SOFTWARE_EDGE
session.script_triggers[0].digital_edge_script_trigger_edge = nifgen.ScriptTriggerDigitalEdgeEdge.RISING # RISING / FAILING
# 3 - Calculate and write different waveform data to the device's onboard memory
session.channels[channel].write_waveform('sine', calculate_sinewave()) # (waveform_name, data)
session.channels[channel].write_waveform('rampup', calculate_rampup())
session.channels[channel].write_waveform('rampdown', calculate_rampdown())
session.channels[channel].write_waveform('square', calculate_square())
session.channels[channel].write_waveform('triangle', calculate_triangle())
session.channels[channel].write_waveform('noise', calculate_gaussian_noise())
# 4 - Script to generate
# supported shapes: SINE / SQUARE / TRIANGLE / RAMPUP / RAMPDOWN / NOISE / MULTI
script_name = 'script{}'.format(shape.lower())
num_triggers = 6 if shape.upper() == 'MULTI' else 1 # Only multi needs two triggers, all others need one
session.channels[channel].write_script(SCRIPT_ALL)
session.script_to_generate = script_name
# LAUNCH
with session.initiate():
for x in range(num_triggers):
time.sleep(10)
session.script_triggers[0].send_software_edge_trigger()
def _main(argsv):
parser = argparse.ArgumentParser(description='Generate different shape waveforms.', formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument('-n', '--resource-name', default='PXI1Slot2', help='Resource name of a National Instruments Arbitrary Waveform Generator')
parser.add_argument('-s', '--shape', default='SINE', help='Shape of the signal to generate')
parser.add_argument('-c', '--channel', default='0', help='Channel to use when generating')
parser.add_argument('-op', '--option-string', default='', type=str, help='Option string')
args = parser.parse_args(argsv)
example(args.resource_name, args.option_string, args.shape.upper(), args.channel)
def test_example():
options = {'simulate': True, 'driver_setup': {'Model': '5433 (2CH)', 'BoardType': 'PXIe', }, }
example('PXI1Slot2', options, 'SINE', '0')
def test_main():
cmd_line = ['--option-string', 'Simulate=1, DriverSetup=Model:5433 (2CH);BoardType:PXIe', '--channel', '0', ]
_main(cmd_line)
def main():
_main(sys.argv[1:])
if __name__ == '__main__':
main()
|
nifgen_standard_function.py¶
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 | #!/usr/bin/python
import argparse
import nifgen
import sys
import time
def example(resource_name, options, waveform, frequency, amplitude, offset, phase, gen_time):
with nifgen.Session(resource_name=resource_name, options=options) as session:
session.output_mode = nifgen.OutputMode.FUNC
session.configure_standard_waveform(waveform=nifgen.Waveform[waveform], amplitude=amplitude, frequency=frequency, dc_offset=offset, start_phase=phase)
with session.initiate():
time.sleep(gen_time)
def _main(argsv):
supported_waveforms = list(nifgen.Waveform.__members__.keys())[:-1] # no support for user-defined waveforms in example
parser = argparse.ArgumentParser(description='Generates the standard function.', formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument('-n', '--resource-name', default='PXI1Slot2', help='Resource name of a National Instruments Function Generator')
parser.add_argument('-w', '--waveform', default=supported_waveforms[0], choices=supported_waveforms, type=str.upper, help='Standard waveform')
parser.add_argument('-f', '--frequency', default=1000, type=float, help='Frequency (Hz)')
parser.add_argument('-a', '--amplitude', default=1.0, type=float, help='Amplitude (Vpk-pk)')
parser.add_argument('-o', '--offset', default=0.0, type=float, help='DC offset (V)')
parser.add_argument('-p', '--phase', default=0.0, type=float, help='Start phase (deg)')
parser.add_argument('-t', '--time', default=5.0, type=float, help='Generation time (s)')
parser.add_argument('-op', '--option-string', default='', type=str, help='Option string')
args = parser.parse_args(argsv)
example(args.resource_name, args.option_string, args.waveform, args.frequency, args.amplitude, args.offset, args.phase, args.time)
def main():
_main(sys.argv[1:])
def test_example():
options = {'simulate': True, 'driver_setup': {'Model': '5433 (2CH)', 'BoardType': 'PXIe', }, }
example('PXI1Slot2', options, 'SINE', 1000, 1.0, 0.0, 0.0, 5.0)
def test_main():
cmd_line = ['--option-string', 'Simulate=1, DriverSetup=Model:5433 (2CH);BoardType:PXIe', ]
_main(cmd_line)
if __name__ == '__main__':
main()
|
nifgen_trigger.py¶
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 | import argparse
import nifgen
import sys
import time
def example(resource_name1, resource_name2, options, waveform, gen_time):
with nifgen.Session(resource_name=resource_name1, options=options) as session1, nifgen.Session(resource_name=resource_name2, options=options) as session2:
session_list = [session1, session2]
for session in session_list:
session.output_mode = nifgen.OutputMode.FUNC
session.configure_standard_waveform(waveform=nifgen.Waveform[waveform], amplitude=1.0, frequency=1000, dc_offset=0.0, start_phase=0.0)
session1.start_trigger_type = nifgen.StartTriggerType.SOFTWARE_EDGE
session2.start_trigger_type = nifgen.StartTriggerType.DIGITAL_EDGE
session2.digital_edge_start_trigger_edge = nifgen.StartTriggerDigitalEdgeEdge.RISING
session2.digital_edge_start_trigger_source = '/' + resource_name1 + '/0/StartTrigger'
with session2.initiate():
with session1.initiate():
session1.send_software_edge_trigger(nifgen.Trigger.START)
time.sleep(gen_time)
def _main(argsv):
supported_waveforms = list(nifgen.Waveform.__members__.keys())[:-1] # no support for user-defined waveforms in example
parser = argparse.ArgumentParser(description='Triggers one device on the start trigger of another device.', formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument('-n1', '--resource-name1', default='PXI1Slot2', help='Resource name of a NI Function Generator')
parser.add_argument('-n2', '--resource-name2', default='PXI1Slot3', help='Resource name of a NI Function Generator')
parser.add_argument('-w', '--waveform', default=supported_waveforms[0], choices=supported_waveforms, type=str.upper, help='Standard waveform')
parser.add_argument('-t', '--time', default=5.0, type=float, help='Generation time (s)')
parser.add_argument('-op', '--option-string', default='', type=str, help='Option string')
args = parser.parse_args(argsv)
example(args.resource_name1, args.resource_name2, args.option_string, args.waveform, args.time)
def main():
_main(sys.argv[1:])
def test_example():
options = {'simulate': True, 'driver_setup': {'Model': '5433 (2CH)', 'BoardType': 'PXIe', }, }
example('PXI1Slot2', 'PXI1Slot3', options, 'SINE', 5.0)
def test_main():
cmd_line = ['--option-string', 'Simulate=1, DriverSetup=Model:5433 (2CH);BoardType:PXIe', ]
_main(cmd_line)
if __name__ == '__main__':
main()
|