diff --git a/.idea/.gitignore b/.idea/.gitignore
new file mode 100644
index 0000000000000000000000000000000000000000..26d33521af10bcc7fd8cea344038eaaeb78d0ef5
--- /dev/null
+++ b/.idea/.gitignore
@@ -0,0 +1,3 @@
+# Default ignored files
+/shelf/
+/workspace.xml
diff --git a/.idea/awg-control.iml b/.idea/awg-control.iml
new file mode 100644
index 0000000000000000000000000000000000000000..d0876a78d06ac03b5d78c8dcdb95570281c6f1d6
--- /dev/null
+++ b/.idea/awg-control.iml
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="PYTHON_MODULE" version="4">
+ <component name="NewModuleRootManager">
+ <content url="file://$MODULE_DIR$" />
+ <orderEntry type="inheritedJdk" />
+ <orderEntry type="sourceFolder" forTests="false" />
+ </component>
+</module>
\ No newline at end of file
diff --git a/.idea/inspectionProfiles/Project_Default.xml b/.idea/inspectionProfiles/Project_Default.xml
new file mode 100644
index 0000000000000000000000000000000000000000..8fa1450f3c52680f12350a62bdd046aaae25f015
--- /dev/null
+++ b/.idea/inspectionProfiles/Project_Default.xml
@@ -0,0 +1,23 @@
+<component name="InspectionProjectProfileManager">
+ <profile version="1.0">
+ <option name="myName" value="Project Default" />
+ <inspection_tool class="PyPep8Inspection" enabled="true" level="WEAK WARNING" enabled_by_default="true">
+ <option name="ignoredErrors">
+ <list>
+ <option value="E265" />
+ <option value="E501" />
+ <option value="E231" />
+ </list>
+ </option>
+ </inspection_tool>
+ <inspection_tool class="PyPep8NamingInspection" enabled="true" level="WEAK WARNING" enabled_by_default="true">
+ <option name="ignoredErrors">
+ <list>
+ <option value="N802" />
+ <option value="N806" />
+ <option value="N803" />
+ </list>
+ </option>
+ </inspection_tool>
+ </profile>
+</component>
\ No newline at end of file
diff --git a/.idea/inspectionProfiles/profiles_settings.xml b/.idea/inspectionProfiles/profiles_settings.xml
new file mode 100644
index 0000000000000000000000000000000000000000..105ce2da2d6447d11dfe32bfb846c3d5b199fc99
--- /dev/null
+++ b/.idea/inspectionProfiles/profiles_settings.xml
@@ -0,0 +1,6 @@
+<component name="InspectionProjectProfileManager">
+ <settings>
+ <option name="USE_PROJECT_PROFILE" value="false" />
+ <version value="1.0" />
+ </settings>
+</component>
\ No newline at end of file
diff --git a/.idea/misc.xml b/.idea/misc.xml
new file mode 100644
index 0000000000000000000000000000000000000000..d56657add3eb3c246989284ec6e6a8475603cf1d
--- /dev/null
+++ b/.idea/misc.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+ <component name="ProjectRootManager" version="2" project-jdk-name="Python 3.9" project-jdk-type="Python SDK" />
+</project>
\ No newline at end of file
diff --git a/.idea/modules.xml b/.idea/modules.xml
new file mode 100644
index 0000000000000000000000000000000000000000..1688f4e6a3003e7cebf2c693f8afce34ccf2b4c0
--- /dev/null
+++ b/.idea/modules.xml
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+ <component name="ProjectModuleManager">
+ <modules>
+ <module fileurl="file://$PROJECT_DIR$/.idea/awg-control.iml" filepath="$PROJECT_DIR$/.idea/awg-control.iml" />
+ </modules>
+ </component>
+</project>
\ No newline at end of file
diff --git a/.idea/vcs.xml b/.idea/vcs.xml
new file mode 100644
index 0000000000000000000000000000000000000000..94a25f7f4cb416c083d265558da75d457237d671
--- /dev/null
+++ b/.idea/vcs.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+ <component name="VcsDirectoryMappings">
+ <mapping directory="$PROJECT_DIR$" vcs="Git" />
+ </component>
+</project>
\ No newline at end of file
diff --git a/arrayPhase.mat b/Matlab/arrayPhase.mat
similarity index 100%
rename from arrayPhase.mat
rename to Matlab/arrayPhase.mat
diff --git a/createTweezers.m b/Matlab/createTweezers.m
similarity index 97%
rename from createTweezers.m
rename to Matlab/createTweezers.m
index b3112ced2e8e8af7ab3f0f25cb146354df601788..f9c78225a1922755f98ad69333113905d83844c0 100644
--- a/createTweezers.m
+++ b/Matlab/createTweezers.m
@@ -1,108 +1,108 @@
-%% Define awg structure and init
-if ~exist('awg_trap', 'var') || ~isfield(awg_trap, 'running') || ~awg_trap.running
- awg_trap = struct();
- awg_trap.active_channels = [1, 1, 0, 0];
- % Here you set which channels of the AWG you are using.
- % Note that the only available options are 1, 1+2, 1+2+3+4
-
- awg_trap.chAmp = [2500, 1320, 2500, 2500];
- % mVp. Max possible 2500mVp, min 80mVp.
-
- awg_trap.samplerate = 614.4e6;
- % Maximum of 625e6, must be multiple of 512
-
- awg_trap.numMemBlocks = 8192;
- % Must be power of 2. In general, for the maximum array size
- % you want to rearrange with BubbleSort, N, this should be at least N*(N+2).
- % If not using BubbleSort just set to maybe 32.
-
- awg_trap.freq_resolution = 100e3;
- % GCD of trap frequencies. If you make an array with a different
- % frequency resolution, then it might fail because when the waveform
- % tries to loop there will be a phase jump (which kills the atoms)
-
- awg_trap.memSamples = 512 * 240;
- % Define memory in number of samples.
- % First factor must be 512. Other factor must be an even integer multiple of
- % the sampling rate / (freq_resolution * 512) , such that
- % the total memSamples < 2^31/numMemBlocks/numActiveChannels.
- % 2^31 comes from the total AWG memory limit. Note that the
- % requirements here are again to avoid phase jumps.
-
- awg_trap.running = false;
-else
- fprintf('To change these parameters you must turn the AWG off first!\n');
-end
-
-%% Init
-[awg_trap, success] = initTrapAWG(wfms, awg_trap);
-if success
- awg_trap.running = true;
-end
-if awg_trap.cardInfo.serialNumber ~= 11198
- % When using a system with multiple AWGs, sometimes the internal awg
- % indexing gets switched around when the computer restarts - to avoid
- % outputting the wrong signal to the wrong card, we make sure we are
- % talking to the correct serial number.
- fprintf('Talking to serial number %i', awg_trap.cardInfo.serialNumber);
- disp('This is the wrong card! Turn it off immediately and diagnose!');
-end
-
-%% Update
-if awg_trap.running
- awg_trap = updateTrapAWG(wfms, awg_trap);
- if isfield(wfms, 'name')
- fprintf('Updating to %s\n', wfms.name);
- else
- fprintf('Updating to unnamed wfms\n');
- end
-else
- fprintf('AWG must be running to update!\n');
-end
-
-%% Stop
-% Look out, because oftentimes if a bug happens with the AWG initialization
-% or termination it will hard crash MATLAB. The "running" variable tries to
-% help this, but is not perfect.
-if awg_trap.running
- stopTrapAWG(awg_trap);
- awg_trap.running = false;
-else
- fprintf('AWG is already off!\n');
-end
-
-%% Generate naive waveforms
-% Schematic for how to generate an array of tweezers for two crossed AODs.
-
-wfms = struct();
-
-% Ch 0 (Old AOD)
-numTweezers_0 = 67;
-f0_0 = 98.2e6;
-df_0 = 750e3;
-ampScaling_0 = 0.25; % DO NOT EXCEED 0.25 when chAmp(1) = 2500mVp.
-wfms.ch0 = staticArrayWfm(numTweezers_0, f0_0, df_0, ampScaling_0);
-
-% Ch 1 (New AOD)
-numTweezers_1 = 1;
-f0_1 = 97e6;
-df_1 = 10 * 350e3;
-ampScaling_1 = 0.25; % DO NOT EXCEED 0.25 when chAmp(2) = 1320mVp.
-wfms.ch1 = staticArrayWfm(numTweezers_1, f0_1, df_1, ampScaling_1);
-
-wfms.name = sprintf('wfms_%d_%0.0f_%d_%0.0f_%s', numTweezers_0, df_0 / 1e3, numTweezers_1, df_1 / 1e3, '000');
-
-
-%% Check current AWG step
-% There are lots of "GetParam_i32" calls which are very useful. See the
-% manual and programming guide for more information. For instance, this
-% call returns the current block of memory the AWG is outputting.
-[~,currentStep] = spcm_dwGetParam_i32(awg_trap.cardInfo.hDrv, mRegs('SPC_SEQMODE_STATUS'));
-fprintf('AWG is currently on step %d\n',currentStep);
-
-%% Identify the card
-% This will make a little light blink on the back of the card, useful when
-% working with multiple AWGs
-mRegs = spcMCreateRegMap();
-error = spcm_dwSetParam_i32(awg_trap.cardInfo.hDrv, mRegs('SPC_CARDIDENTIFICATION'), 0);
-
+%% Define awg structure and init
+if ~exist('awg_trap', 'var') || ~isfield(awg_trap, 'running') || ~awg_trap.running
+ awg_trap = struct();
+ awg_trap.active_channels = [1, 1, 0, 0];
+ % Here you set which channels of the AWG you are using.
+ % Note that the only available options are 1, 1+2, 1+2+3+4
+
+ awg_trap.chAmp = [2500, 1320, 2500, 2500];
+ % mVp. Max possible 2500mVp, min 80mVp.
+
+ awg_trap.samplerate = 614.4e6;
+ % Maximum of 625e6, must be multiple of 512
+
+ awg_trap.numMemBlocks = 8192;
+ % Must be power of 2. In general, for the maximum array size
+ % you want to rearrange with BubbleSort, N, this should be at least N*(N+2).
+ % If not using BubbleSort just set to maybe 32.
+
+ awg_trap.freq_resolution = 100e3;
+ % GCD of trap frequencies. If you make an array with a different
+ % frequency resolution, then it might fail because when the waveform
+ % tries to loop there will be a phase jump (which kills the atoms)
+
+ awg_trap.memSamples = 512 * 240;
+ % Define memory in number of samples.
+ % First factor must be 512. Other factor must be an even integer multiple of
+ % the sampling rate / (freq_resolution * 512) , such that
+ % the total memSamples < 2^31/numMemBlocks/numActiveChannels.
+ % 2^31 comes from the total AWG memory limit. Note that the
+ % requirements here are again to avoid phase jumps.
+
+ awg_trap.running = false;
+else
+ fprintf('To change these parameters you must turn the AWG off first!\n');
+end
+
+%% Init
+[awg_trap, success] = initTrapAWG(wfms, awg_trap);
+if success
+ awg_trap.running = true;
+end
+if awg_trap.cardInfo.serialNumber ~= 11198
+ % When using a system with multiple AWGs, sometimes the internal awg
+ % indexing gets switched around when the computer restarts - to avoid
+ % outputting the wrong signal to the wrong card, we make sure we are
+ % talking to the correct serial number.
+ fprintf('Talking to serial number %i', awg_trap.cardInfo.serialNumber);
+ disp('This is the wrong card! Turn it off immediately and diagnose!');
+end
+
+%% Update
+if awg_trap.running
+ awg_trap = updateTrapAWG(wfms, awg_trap);
+ if isfield(wfms, 'name')
+ fprintf('Updating to %s\n', wfms.name);
+ else
+ fprintf('Updating to unnamed wfms\n');
+ end
+else
+ fprintf('AWG must be running to update!\n');
+end
+
+%% Stop
+% Look out, because oftentimes if a bug happens with the AWG initialization
+% or termination it will hard crash MATLAB. The "running" variable tries to
+% help this, but is not perfect.
+if awg_trap.running
+ stopTrapAWG(awg_trap);
+ awg_trap.running = false;
+else
+ fprintf('AWG is already off!\n');
+end
+
+%% Generate naive waveforms
+% Schematic for how to generate an array of tweezers for two crossed AODs.
+
+wfms = struct();
+
+% Ch 0 (Old AOD)
+numTweezers_0 = 67;
+f0_0 = 98.2e6;
+df_0 = 750e3;
+ampScaling_0 = 0.25; % DO NOT EXCEED 0.25 when chAmp(1) = 2500mVp.
+wfms.ch0 = staticArrayWfm(numTweezers_0, f0_0, df_0, ampScaling_0);
+
+% Ch 1 (New AOD)
+numTweezers_1 = 1;
+f0_1 = 97e6;
+df_1 = 10 * 350e3;
+ampScaling_1 = 0.25; % DO NOT EXCEED 0.25 when chAmp(2) = 1320mVp.
+wfms.ch1 = staticArrayWfm(numTweezers_1, f0_1, df_1, ampScaling_1);
+
+wfms.name = sprintf('wfms_%d_%0.0f_%d_%0.0f_%s', numTweezers_0, df_0 / 1e3, numTweezers_1, df_1 / 1e3, '000');
+
+
+%% Check current AWG step
+% There are lots of "GetParam_i32" calls which are very useful. See the
+% manual and programming guide for more information. For instance, this
+% call returns the current block of memory the AWG is outputting.
+[~,currentStep] = spcm_dwGetParam_i32(awg_trap.cardInfo.hDrv, mRegs('SPC_SEQMODE_STATUS'));
+fprintf('AWG is currently on step %d\n',currentStep);
+
+%% Identify the card
+% This will make a little light blink on the back of the card, useful when
+% working with multiple AWGs
+mRegs = spcMCreateRegMap();
+error = spcm_dwSetParam_i32(awg_trap.cardInfo.hDrv, mRegs('SPC_CARDIDENTIFICATION'), 0);
+
diff --git a/initTrapAWG.m b/Matlab/initTrapAWG.m
similarity index 97%
rename from initTrapAWG.m
rename to Matlab/initTrapAWG.m
index a13f2e129f3f06e4f7ee1fabe93e5b7bde1bdf71..78506909e6f790b13ac668396ea14e4e14da65f9 100644
--- a/initTrapAWG.m
+++ b/Matlab/initTrapAWG.m
@@ -1,150 +1,150 @@
-function [awg_trap, success] = initTrapAWG(wfms, awg_trap)
-
- success = false;
-
- %Set AWG parameters
- samplerate = awg_trap.samplerate;
- chAmp = awg_trap.chAmp;
- memSamples = awg_trap.memSamples;
-
- % helper maps to use label names for registers and errors
- mRegs = spcMCreateRegMap();
- mErrors = spcMCreateErrorMap();
-
- % ----- init card and store infos in cardInfo struct -----
- % This is the place where the AWG internal indexing can sometimes get
- % messed up if you have multiple AWGs and the computer restarts
- [success, cardInfo] = spcMInitCardByIdx(1);
-
- if success
- % ----- print info about the board -----
- cardInfoText = spcMPrintCardInfo(cardInfo);
- fprintf(cardInfoText);
- else
- spcMErrorMessageStdOut(cardInfo, 'Error: Could not open card\n', true);
- return;
- end
-
- % ----- set the samplerate and internal PLL, no clock output -----
- [success, cardInfo] = spcMSetupClockPLL(cardInfo, samplerate, 0); % clock output : enable = 1, disable = 0
- if ~success
- spcMErrorMessageStdOut(cardInfo, 'Error: spcMSetupClockPLL:\n\t', true);
- return;
- end
- fprintf ('\n ..... Sampling rate set to %.1f MHz\n', cardInfo.setSamplerate / 1e6);
-
-
- % Here are some examples of different triggering methods, either
- % software triggering or hardware triggering with 4V activation
-
- % ----- set software trigger, no trigger output -----
- % [success, cardInfo] = spcMSetupTrigSoftware (cardInfo, 0); % trigger output : enable = 1, disable = 0
- % if ~success
- % spcMErrorMessageStdOut (cardInfo, 'Error: spcMSetupTrigSoftware:\n\t', true);
- % return;
- % end
-
- %%%%%%%%%
- % ----- extMode = risingEdge, trigTerm = 0, pulseWidth = 0, singleSrc = 1, extLine = 0 -----
- % [success, cardInfo] = spcMSetupTrigExternal (cardInfo, mRegs('SPC_TM_POS'), 0, 0, 1, 0);
- % if ~success
- % spcMErrorMessageStdOut (cardInfo, 'Error: spcMSetupExternal:\n\t', true);
- % return;
- % end
-
-% [success, cardInfo] = spcMSetupTrigExternalLevel (cardInfo, mRegs('SPC_TM_POS'), 4000, 0, 0, 0, 0, 1, 0);
-% if ~success
-% spcMErrorMessageStdOut (cardInfo, 'Error: spcMSetupExternal:\n\t', true);
-% return;
-% end
-
- %%%%%%%%%
-
- % ----- program all output channels with no offset and no filter -----
- for ii = 0:(cardInfo.maxChannels-1)
- [success, cardInfo] = spcMSetupAnalogOutputChannel(cardInfo, ii, chAmp(ii + 1), 0, 0, mRegs('SPCM_STOPLVL_ZERO'), 0, 0); % doubleOut = disabled, differential = disabled
- if ~success
- spcMErrorMessageStdOut(cardInfo, 'Error: spcMSetupInputChannel:\n\t', true);
- return;
- end
- end
-
- % Divide memory in segments
- % ----- setup sequence mode, 1 channel, numMemBlocks segments, start segment 0 -----
- [success, cardInfo] = spcMSetupModeRepSequence(cardInfo, 0, bi2de(awg_trap.active_channels), awg_trap.numMemBlocks, 0);
- if ~success
- spcMErrorMessageStdOut(cardInfo, 'Error: spcMSetupModeRepSequence:\n\t', true);
- return;
- end
-
- firstStep = 0;
- changeStep = 1;
- firstSeg = 0;
-
- % create signal
- signals = [];
- overPowerFlag = false;
- awg_trap.cardInfo = cardInfo;
- for ind = 1:cardInfo.maxChannels
- if awg_trap.active_channels(ind)
- wfm = wfms.(sprintf('ch%i', ind - 1));
- signal = staticArraySignal(wfm, awg_trap);
-
- else
- signal = zeros(1, memSamples);
- end
- signals = [signals; signal];
- end
- signal_zero = zeros(1,memSamples);
-
- %Step 1 - Set segments
- % ----- set segment 0 -----
- error = spcm_dwSetParam_i32(cardInfo.hDrv, mRegs('SPC_SEQMODE_WRITESEGMENT'), firstSeg);
- error = spcm_dwSetParam_i32(cardInfo.hDrv, mRegs('SPC_SEQMODE_SEGMENTSIZE'), memSamples);
- errorCode = spcm_dwSetData(cardInfo.hDrv, 0, memSamples, numel(awg_trap.active_channels), 0, ...
- signals(1, :), signals(2, :), signals(3, :), signals(4, :));
-
- % ----- set segment 1 -----
- error = spcm_dwSetParam_i32(cardInfo.hDrv, mRegs('SPC_SEQMODE_WRITESEGMENT'), 1);
- error = spcm_dwSetParam_i32(cardInfo.hDrv, mRegs('SPC_SEQMODE_SEGMENTSIZE'), memSamples);
- errorCode = spcm_dwSetData (cardInfo.hDrv, 0, memSamples, numel(awg_trap.active_channels), 0, ...
- signal_zero, signals(2, :), signals(3, :), signals(4, :));
-
- % Step 2 - Set sequence steps
- % step, nextStep, segment, loops, condition (0 => End loop always, 1 => End loop on trigger, 2 => End sequence)
- % Understanding how the sequencereplay works on the AWG is crucial to
- % understanding how to effectively program it. See the manual.
- spcMSetupSequenceStep(cardInfo, firstStep, changeStep, firstSeg, 1, 1);
- spcMSetupSequenceStep(cardInfo, changeStep, firstStep, firstSeg, 1, 0);
-
-
- % Honestly for this next part, it is always a bit of trial and error. I
- % am sure there is a better way to do this though... I've left some
- % things which we don't actually use (like the commandMask syntax) in
- % in case it is useful.
-
- % ----- define series of commands -----
- % commandMask = mRegs('M2CMD_CARD_START');
- % commandMask = bitor (mRegs('M2CMD_CARD_START'), mRegs('M2CMD_CARD_ENABLETRIGGER'));
- % commandMask = bitor (commandMask, mRegs('M2CMD_CARD_WAITREADY'));
-
- % ----- set series of command -----
- errorCode = spcm_dwSetParam_i32(cardInfo.hDrv, mRegs('SPC_M2CMD'), mRegs('M2CMD_CARD_START'));
- errorCode = spcm_dwSetParam_i32(cardInfo.hDrv, mRegs('SPC_M2CMD'), mRegs('M2CMD_CARD_ENABLETRIGGER'));
- if (errorCode ~= 0)
- [~, cardInfo] = spcMCheckSetError(errorCode, cardInfo);
- if errorCode == mErrors('ERR_TIMEOUT')
- error = spcm_dwSetParam_i32(cardInfo.hDrv, mRegs('SPC_M2CMD'), mRegs('M2CMD_CARD_STOP'));
- fprintf (' OK\n ................... replay stopped\n');
- else
- spcMErrorMessageStdOut(cardInfo, 'Error: spcm_dwSetParam_i32:\n\t', true);
- return;
- end
- end
-
- errorCode = spcm_dwSetParam_i32(awg_trap.cardInfo.hDrv, mRegs('SPC_M2CMD'), mRegs('M2CMD_CARD_FORCETRIGGER'));
-
- awg_trap.cardInfo = cardInfo;
- success = true;
-
-end
+function [awg_trap, success] = initTrapAWG(wfms, awg_trap)
+
+ success = false;
+
+ %Set AWG parameters
+ samplerate = awg_trap.samplerate;
+ chAmp = awg_trap.chAmp;
+ memSamples = awg_trap.memSamples;
+
+ % helper maps to use label names for registers and errors
+ mRegs = spcMCreateRegMap();
+ mErrors = spcMCreateErrorMap();
+
+ % ----- init card and store infos in cardInfo struct -----
+ % This is the place where the AWG internal indexing can sometimes get
+ % messed up if you have multiple AWGs and the computer restarts
+ [success, cardInfo] = spcMInitCardByIdx(1);
+
+ if success
+ % ----- print info about the board -----
+ cardInfoText = spcMPrintCardInfo(cardInfo);
+ fprintf(cardInfoText);
+ else
+ spcMErrorMessageStdOut(cardInfo, 'Error: Could not open card\n', true);
+ return;
+ end
+
+ % ----- set the samplerate and internal PLL, no clock output -----
+ [success, cardInfo] = spcMSetupClockPLL(cardInfo, samplerate, 0); % clock output : enable = 1, disable = 0
+ if ~success
+ spcMErrorMessageStdOut(cardInfo, 'Error: spcMSetupClockPLL:\n\t', true);
+ return;
+ end
+ fprintf ('\n ..... Sampling rate set to %.1f MHz\n', cardInfo.setSamplerate / 1e6);
+
+
+ % Here are some examples of different triggering methods, either
+ % software triggering or hardware triggering with 4V activation
+
+ % ----- set software trigger, no trigger output -----
+ % [success, cardInfo] = spcMSetupTrigSoftware (cardInfo, 0); % trigger output : enable = 1, disable = 0
+ % if ~success
+ % spcMErrorMessageStdOut (cardInfo, 'Error: spcMSetupTrigSoftware:\n\t', true);
+ % return;
+ % end
+
+ %%%%%%%%%
+ % ----- extMode = risingEdge, trigTerm = 0, pulseWidth = 0, singleSrc = 1, extLine = 0 -----
+ % [success, cardInfo] = spcMSetupTrigExternal (cardInfo, mRegs('SPC_TM_POS'), 0, 0, 1, 0);
+ % if ~success
+ % spcMErrorMessageStdOut (cardInfo, 'Error: spcMSetupExternal:\n\t', true);
+ % return;
+ % end
+
+% [success, cardInfo] = spcMSetupTrigExternalLevel (cardInfo, mRegs('SPC_TM_POS'), 4000, 0, 0, 0, 0, 1, 0);
+% if ~success
+% spcMErrorMessageStdOut (cardInfo, 'Error: spcMSetupExternal:\n\t', true);
+% return;
+% end
+
+ %%%%%%%%%
+
+ % ----- program all output channels with no offset and no filter -----
+ for ii = 0:(cardInfo.maxChannels-1)
+ [success, cardInfo] = spcMSetupAnalogOutputChannel(cardInfo, ii, chAmp(ii + 1), 0, 0, mRegs('SPCM_STOPLVL_ZERO'), 0, 0); % doubleOut = disabled, differential = disabled
+ if ~success
+ spcMErrorMessageStdOut(cardInfo, 'Error: spcMSetupInputChannel:\n\t', true);
+ return;
+ end
+ end
+
+ % Divide memory in segments
+ % ----- setup sequence mode, 1 channel, numMemBlocks segments, start segment 0 -----
+ [success, cardInfo] = spcMSetupModeRepSequence(cardInfo, 0, bi2de(awg_trap.active_channels), awg_trap.numMemBlocks, 0);
+ if ~success
+ spcMErrorMessageStdOut(cardInfo, 'Error: spcMSetupModeRepSequence:\n\t', true);
+ return;
+ end
+
+ firstStep = 0;
+ changeStep = 1;
+ firstSeg = 0;
+
+ % create signal
+ signals = [];
+ overPowerFlag = false;
+ awg_trap.cardInfo = cardInfo;
+ for ind = 1:cardInfo.maxChannels
+ if awg_trap.active_channels(ind)
+ wfm = wfms.(sprintf('ch%i', ind - 1));
+ signal = staticArraySignal(wfm, awg_trap);
+
+ else
+ signal = zeros(1, memSamples);
+ end
+ signals = [signals; signal];
+ end
+ signal_zero = zeros(1,memSamples);
+
+ %Step 1 - Set segments
+ % ----- set segment 0 -----
+ error = spcm_dwSetParam_i32(cardInfo.hDrv, mRegs('SPC_SEQMODE_WRITESEGMENT'), firstSeg);
+ error = spcm_dwSetParam_i32(cardInfo.hDrv, mRegs('SPC_SEQMODE_SEGMENTSIZE'), memSamples);
+ errorCode = spcm_dwSetData(cardInfo.hDrv, 0, memSamples, numel(awg_trap.active_channels), 0, ...
+ signals(1, :), signals(2, :), signals(3, :), signals(4, :));
+
+ % ----- set segment 1 -----
+ error = spcm_dwSetParam_i32(cardInfo.hDrv, mRegs('SPC_SEQMODE_WRITESEGMENT'), 1);
+ error = spcm_dwSetParam_i32(cardInfo.hDrv, mRegs('SPC_SEQMODE_SEGMENTSIZE'), memSamples);
+ errorCode = spcm_dwSetData (cardInfo.hDrv, 0, memSamples, numel(awg_trap.active_channels), 0, ...
+ signal_zero, signals(2, :), signals(3, :), signals(4, :));
+
+ % Step 2 - Set sequence steps
+ % step, nextStep, segment, loops, condition (0 => End loop always, 1 => End loop on trigger, 2 => End sequence)
+ % Understanding how the sequencereplay works on the AWG is crucial to
+ % understanding how to effectively program it. See the manual.
+ spcMSetupSequenceStep(cardInfo, firstStep, changeStep, firstSeg, 1, 1);
+ spcMSetupSequenceStep(cardInfo, changeStep, firstStep, firstSeg, 1, 0);
+
+
+ % Honestly for this next part, it is always a bit of trial and error. I
+ % am sure there is a better way to do this though... I've left some
+ % things which we don't actually use (like the commandMask syntax) in
+ % in case it is useful.
+
+ % ----- define series of commands -----
+ % commandMask = mRegs('M2CMD_CARD_START');
+ % commandMask = bitor (mRegs('M2CMD_CARD_START'), mRegs('M2CMD_CARD_ENABLETRIGGER'));
+ % commandMask = bitor (commandMask, mRegs('M2CMD_CARD_WAITREADY'));
+
+ % ----- set series of command -----
+ errorCode = spcm_dwSetParam_i32(cardInfo.hDrv, mRegs('SPC_M2CMD'), mRegs('M2CMD_CARD_START'));
+ errorCode = spcm_dwSetParam_i32(cardInfo.hDrv, mRegs('SPC_M2CMD'), mRegs('M2CMD_CARD_ENABLETRIGGER'));
+ if (errorCode ~= 0)
+ [~, cardInfo] = spcMCheckSetError(errorCode, cardInfo);
+ if errorCode == mErrors('ERR_TIMEOUT')
+ error = spcm_dwSetParam_i32(cardInfo.hDrv, mRegs('SPC_M2CMD'), mRegs('M2CMD_CARD_STOP'));
+ fprintf (' OK\n ................... replay stopped\n');
+ else
+ spcMErrorMessageStdOut(cardInfo, 'Error: spcm_dwSetParam_i32:\n\t', true);
+ return;
+ end
+ end
+
+ errorCode = spcm_dwSetParam_i32(awg_trap.cardInfo.hDrv, mRegs('SPC_M2CMD'), mRegs('M2CMD_CARD_FORCETRIGGER'));
+
+ awg_trap.cardInfo = cardInfo;
+ success = true;
+
+end
diff --git a/staticArraySignal.m b/Matlab/staticArraySignal.m
similarity index 96%
rename from staticArraySignal.m
rename to Matlab/staticArraySignal.m
index 5a96909f57faf9cdef9109bc7b6244fcb0f420c8..3d9176b68fa733d720f524272bf256473c6b837b 100644
--- a/staticArraySignal.m
+++ b/Matlab/staticArraySignal.m
@@ -1,25 +1,25 @@
-function [signal] = staticArraySignal(wfm, awg_trap, memSamples)
- %STATICARRAYSIGNAL Summary of this function goes here
- % Detailed explanation goes here
-
- if ~exist('memSamples', 'var')
- memSamples = awg_trap.memSamples;
- end
- samplerate = awg_trap.samplerate;
- t = (1:memSamples) / samplerate;
-
- signal = sum(wfm.amp' .* (sin(2 * pi * wfm.freq' * t + wfm.phase')), 1);
-
-
- numTweezers = length(wfm.freq);
- scale = 2^15 - 1;
- ampMax = scale / sqrt(numTweezers);
- signal = ampMax * signal;
-
- if max(abs(signal)) > 2^15
- signal(signal > 2^15) = 2^15;
- signal(signal < -2^15) = -2^15;
- warnStruct = warning(); warning('on'); warning('Waveform goes above digital limit, signal will be clipped!'); warning(warnStruct);
- end
-
-end
+function [signal] = staticArraySignal(wfm, awg_trap, memSamples)
+ %STATICARRAYSIGNAL Summary of this function goes here
+ % Detailed explanation goes here
+
+ if ~exist('memSamples', 'var')
+ memSamples = awg_trap.memSamples;
+ end
+ samplerate = awg_trap.samplerate;
+ t = (1:memSamples) / samplerate;
+
+ signal = sum(wfm.amp' .* (sin(2 * pi * wfm.freq' * t + wfm.phase')), 1);
+
+
+ numTweezers = length(wfm.freq);
+ scale = 2^15 - 1;
+ ampMax = scale / sqrt(numTweezers);
+ signal = ampMax * signal;
+
+ if max(abs(signal)) > 2^15
+ signal(signal > 2^15) = 2^15;
+ signal(signal < -2^15) = -2^15;
+ warnStruct = warning(); warning('on'); warning('Waveform goes above digital limit, signal will be clipped!'); warning(warnStruct);
+ end
+
+end
diff --git a/staticArrayWfm.m b/Matlab/staticArrayWfm.m
similarity index 97%
rename from staticArrayWfm.m
rename to Matlab/staticArrayWfm.m
index 5e0c7068bf115f03fb188d91131a28fd40eea297..4c64c199f5048641633d6c76df273ea687f6be23 100644
--- a/staticArrayWfm.m
+++ b/Matlab/staticArrayWfm.m
@@ -1,29 +1,29 @@
-function [wfm] = staticArrayWfm(numTweezers, f0, df, ampScaling)
- %STATICARRAYWFM Summary of this function goes here
- % Detailed explanation goes here
-
- % Pretty sure this only works for odd numbers of arrays right now, but
- % simple to make it work for even as well
-
- wfm = struct();
- wfm.amp = ampScaling * ones(1, numTweezers);
-
-
- wfm.freq = f0 + df * ((1:numTweezers) - numTweezers / 2 - 1 / 2);
-
- wfm.freq = wfm.freq;
-
- % This is basically just a random guess of the phases. Ultimately you
- % want to optimize the phases by minimizing mixing into sum and
- % difference fourier modes, so this really is just a first
- % approximation that kinda works.
- phaseStruct = load('arrayPhase.mat');
- phase = phaseStruct.arrayPhase;
-
- if length(phase) < length(wfm.freq)
- phase = repmat(phase, [1, 2]);
- end
- % disp('setting phases to 0!')
- wfm.phase = phase(1:length(wfm.freq));
-
-end
+function [wfm] = staticArrayWfm(numTweezers, f0, df, ampScaling)
+ %STATICARRAYWFM Summary of this function goes here
+ % Detailed explanation goes here
+
+ % Pretty sure this only works for odd numbers of arrays right now, but
+ % simple to make it work for even as well
+
+ wfm = struct();
+ wfm.amp = ampScaling * ones(1, numTweezers);
+
+
+ wfm.freq = f0 + df * ((1:numTweezers) - numTweezers / 2 - 1 / 2);
+
+ wfm.freq = wfm.freq;
+
+ % This is basically just a random guess of the phases. Ultimately you
+ % want to optimize the phases by minimizing mixing into sum and
+ % difference fourier modes, so this really is just a first
+ % approximation that kinda works.
+ phaseStruct = load('arrayPhase.mat');
+ phase = phaseStruct.arrayPhase;
+
+ if length(phase) < length(wfm.freq)
+ phase = repmat(phase, [1, 2]);
+ end
+ % disp('setting phases to 0!')
+ wfm.phase = phase(1:length(wfm.freq));
+
+end
diff --git a/stopTrapAWG.m b/Matlab/stopTrapAWG.m
similarity index 97%
rename from stopTrapAWG.m
rename to Matlab/stopTrapAWG.m
index a5617b85149d6de347799b1c1876c4fe5d5ce2d1..c644a5ade19d3ed78a8132f8ae0f541e0f878ce6 100644
--- a/stopTrapAWG.m
+++ b/Matlab/stopTrapAWG.m
@@ -1,15 +1,15 @@
-function stopTrapAWG(awg_trap)
- % If you try and "stop" when the card wasn't actually running it will
- % hard crash MATLAB
-
- % helper maps to use label names for registers
- mRegs = spcMCreateRegMap();
-
- error = spcm_dwSetParam_i32(awg_trap.cardInfo.hDrv, mRegs('SPC_M2CMD'), mRegs('M2CMD_CARD_STOP'));
- fprintf(' ...................... replay done\n');
-
- % ***** close card *****
- spcMCloseCard(awg_trap.cardInfo);
- disp('AWG stopped');
-
+function stopTrapAWG(awg_trap)
+ % If you try and "stop" when the card wasn't actually running it will
+ % hard crash MATLAB
+
+ % helper maps to use label names for registers
+ mRegs = spcMCreateRegMap();
+
+ error = spcm_dwSetParam_i32(awg_trap.cardInfo.hDrv, mRegs('SPC_M2CMD'), mRegs('M2CMD_CARD_STOP'));
+ fprintf(' ...................... replay done\n');
+
+ % ***** close card *****
+ spcMCloseCard(awg_trap.cardInfo);
+ disp('AWG stopped');
+
end
\ No newline at end of file
diff --git a/updateTrapAWG.m b/Matlab/updateTrapAWG.m
similarity index 96%
rename from updateTrapAWG.m
rename to Matlab/updateTrapAWG.m
index 7a53ac84a6a1dba871813d8c7f584a1957f236cf..3333f693a2460b7b1e8cb7f6e4c7bac12014ad4b 100644
--- a/updateTrapAWG.m
+++ b/Matlab/updateTrapAWG.m
@@ -1,51 +1,51 @@
-function [awg_trap, success] = updateTrapAWG(wfms, awg_trap)
-
- cardInfo = awg_trap.cardInfo;
- memSamples = awg_trap.memSamples;
-
- % helper maps to use label names for registers
- mRegs = spcMCreateRegMap();
-
- %Get currentStep
- [~, currentStep] = spcm_dwGetParam_i32 (cardInfo.hDrv, 349950); % 349950 = SPC_SEQMODE_STATS
-
- if currentStep ~= 0
- fprintf('Current step in memory is not 0! Some things might go wrong!\n')
- end
-
-
- % compute signal
- signals = [];
- overPowerFlag = false;
- for ind = 1:cardInfo.maxChannels
- if awg_trap.active_channels(ind)
- wfm = wfms.(sprintf('ch%i', ind - 1));
- signal = staticArraySignal(wfm, awg_trap);
- else
- signal = zeros(1, memSamples);
- end
-
- signals = [signals; signal];
- end
-
- %Update the current step
- default_memory_segment = 0;
-
- error = spcm_dwSetParam_i32(cardInfo.hDrv, mRegs('SPC_SEQMODE_WRITESEGMENT'), default_memory_segment);
- error = spcm_dwSetParam_i32(cardInfo.hDrv, mRegs('SPC_SEQMODE_SEGMENTSIZE'), memSamples);
- errorCode = spcm_dwSetData(cardInfo.hDrv, 0, memSamples, numel(awg_trap.active_channels),...
- 0, signals(1, :), signals(2, :), signals(3, :), signals(4, :));
-
-
- spcMSetupSequenceStep(cardInfo, currentStep, currentStep + 1, 0, 1, 0);
- spcMSetupSequenceStep(cardInfo, currentStep + 1, 0, default_memory_segment, 1, 0);
- spcMSetupSequenceStep(cardInfo, 0, 1, default_memory_segment, 1, 1);
-
- awg_trap.cardInfo = cardInfo;
- if ~overPowerFlag
- success = true;
- else
- success = false;
- end
-
-end
+function [awg_trap, success] = updateTrapAWG(wfms, awg_trap)
+
+ cardInfo = awg_trap.cardInfo;
+ memSamples = awg_trap.memSamples;
+
+ % helper maps to use label names for registers
+ mRegs = spcMCreateRegMap();
+
+ %Get currentStep
+ [~, currentStep] = spcm_dwGetParam_i32 (cardInfo.hDrv, 349950); % 349950 = SPC_SEQMODE_STATS
+
+ if currentStep ~= 0
+ fprintf('Current step in memory is not 0! Some things might go wrong!\n')
+ end
+
+
+ % compute signal
+ signals = [];
+ overPowerFlag = false;
+ for ind = 1:cardInfo.maxChannels
+ if awg_trap.active_channels(ind)
+ wfm = wfms.(sprintf('ch%i', ind - 1));
+ signal = staticArraySignal(wfm, awg_trap);
+ else
+ signal = zeros(1, memSamples);
+ end
+
+ signals = [signals; signal];
+ end
+
+ %Update the current step
+ default_memory_segment = 0;
+
+ error = spcm_dwSetParam_i32(cardInfo.hDrv, mRegs('SPC_SEQMODE_WRITESEGMENT'), default_memory_segment);
+ error = spcm_dwSetParam_i32(cardInfo.hDrv, mRegs('SPC_SEQMODE_SEGMENTSIZE'), memSamples);
+ errorCode = spcm_dwSetData(cardInfo.hDrv, 0, memSamples, numel(awg_trap.active_channels),...
+ 0, signals(1, :), signals(2, :), signals(3, :), signals(4, :));
+
+
+ spcMSetupSequenceStep(cardInfo, currentStep, currentStep + 1, 0, 1, 0);
+ spcMSetupSequenceStep(cardInfo, currentStep + 1, 0, default_memory_segment, 1, 0);
+ spcMSetupSequenceStep(cardInfo, 0, 1, default_memory_segment, 1, 1);
+
+ awg_trap.cardInfo = cardInfo;
+ if ~overPowerFlag
+ success = true;
+ else
+ success = false;
+ end
+
+end
diff --git a/Python/AWG.py b/Python/AWG.py
new file mode 100644
index 0000000000000000000000000000000000000000..b4af20e89807154408d91592dd2a15152a426273
--- /dev/null
+++ b/Python/AWG.py
@@ -0,0 +1,255 @@
+from pyspcm import *
+from spcm_tools import *
+import sys
+import numpy as np
+
+
+#
+# **************************************************************************
+# Class for controlling the AWG
+#
+# User must install the AWG driver for Windows 8/9/10/11, found in
+# https://spectrum-instrumentation.com/support/downloads.php
+# Look under model M4i 6622-x8
+#
+# The python module provided in pyspcm is in essence a c/c++ wrapper,
+# hence the use of ctype variables in this code.
+# **************************************************************************
+#
+
+
+class AWG:
+
+ def __init__(self):
+ """
+ constructor for the AWG class
+ """
+ self.card = None # holds the spcm card instance, this is used by all internal calls
+ self.card_type = int32(0) # type of card in a 32-bit mask
+ self.serial_number = int32(0) # serial number
+ self.sample_rate = int64(0) # sampling rate of the AWG, this sets the "speed" of the AWG
+ self.mem_size = int64(0) # maximum memory size of the AWG
+ self.full_scale = int32(0) # full scale scaling of output voltage, used for data calculation
+ self.channel = [0,0,0,0] # activated channels
+ self.mode = "" # current mode AWG is running on
+
+ def open(self, remote=False):
+ """
+ opens and initializes instance variables
+ :param remote: flag to determine remote connection, default is False
+ """
+ if remote:
+ self.card = spcm_hOpen(create_string_buffer(b'TCPIP::192.168.1.10::inst0::INSTR'))
+ else:
+ self.card = spcm_hOpen(create_string_buffer(b'/dev/spcm0'))
+ if self.card is None:
+ sys.stdout.write("no card found...\n")
+ else:
+ # initialize variables
+ spcm_dwGetParam_i32(self.card, SPC_PCITYP, byref(self.card_type))
+ spcm_dwGetParam_i32(self.card, SPC_PCISERIALNO, byref(self.serial_number))
+ spcm_dwGetParam_i64(self.card, SPC_SAMPLERATE, byref(self.sample_rate))
+ spcm_dwGetParam_i64(self.card, SPC_PCIMEMSIZE, byref(self.mem_size))
+ spcm_dwGetParam_i32(self.card, SPC_MIINST_MAXADCVALUE,
+ byref(self.full_scale)) # full scale value for data generation purpose
+ name = szTypeToName(self.card_type.value)
+ sys.stdout.write("Found: {0} sn {1:05d}\n".format(name, self.serial_number.value))
+ sys.stdout.write("Sample Rate: {:.1f} MHz\n".format(self.sample_rate.value / 1000000))
+ sys.stdout.write("Memory size: {:.0f} MBytes\n".format(self.mem_size.value / 1024 / 1024))
+ self.check_error()
+
+ def close(self):
+ spcm_vClose(self.card)
+
+ def check_error(self, message="") -> bool:
+ """
+ error checking helper
+ :param message: caller defined string for debugging purposes
+ :return: 1 if error is found, 0 otherwise
+ """
+ flag = 0
+ msg = "Checking error at " + message + " ... "
+ if custom_msg != "":
+ flag = 1
+ sys.stdout.write(msg)
+ err_reg = uint32(0)
+ err_val = int32(0)
+ err_text = ''
+ err_code = spcm_dwGetErrorInfo_i32(self.card, byref(err_reg), byref(err_val), err_text)
+ if err_code:
+ if flag:
+ sys.stdout.write(err_text)
+ else:
+ sys.stdout.write(msg + err_text)
+ return True
+ elif flag:
+ sys.stdout.write("no error\n")
+ return False
+
+ def run(self):
+ """
+ start the card, enable trigger and wait for trigger to start
+ """
+ spcm_dwSetParam_i32(self.card, SPC_M2CMD,
+ M2CMD_CARD_START | M2CMD_CARD_ENABLETRIGGER)
+ self.check_error()
+
+ def stop(self):
+ """
+ stop the card, this is different from closing the card
+ """
+ spcm_dwSetParam_i32(self.card, SPC_M2CMD, M2CMD_CARD_STOP)
+ self.check_error()
+
+ def reset(self):
+ """
+ resets the board, this clears all onboard memory and settings
+ """
+ spcm_dwSetParam_i32(self.card, SPC_M2CMD, M2CMD_CARD_RESET)
+
+ def force_trigger(self):
+ """
+ force a trigger event, this completely mimics an actual trigger event
+ """
+ spcm_dwSetParam_i32(self.card, SPC_M2CMD, M2CMD_CARD_FORCETRIGGER)
+ self.check_error()
+
+ def set_sampling_rate(self, sr):
+ """
+ set sampling rate
+ :param sr: 64bit integer between 50MHz and 625MHz
+ """
+ self.sample_rate = int64(sr)
+ spcm_dwSetParam_i64(self.card, SPC_SAMPLERATE, sr)
+ self.check_error()
+
+ def enable_channel(self, ch: int, amplitude: int=1000, stoplvl: str="ZERO"):
+ """
+ enable/disable individual channel and set its parameters
+ :param ch: enables channel 0-3.
+ :param amplitude: sets output amplitude of each channel between 80-2500mV, default level is 1000mV.
+ :param stoplvl: sets channels pause behavior, "ZERO", "LOW", "HIGH", "HOLDLAST
+ """
+ stopmask = {"ZERO": SPCM_STOPLVL_ZERO,
+ "LOW": SPCM_STOPLVL_LOW,
+ "HIGH": SPCM_STOPLVL_HIGH,
+ "HOLDLAST": SPCM_STOPLVL_HOLDLAST}
+
+ if self.channel[ch] == 0:
+ self.channel[ch] = 1
+ spcm_dwSetParam_i64(self.card, SPC_CHENABLE, int64(2**ch)) # see CHANNEL0-3 in regs.py for detail
+ spcm_dwSetParam_i32(self.card, SPC_ENABLEOUT0 + ch * (SPC_ENABLEOUT1 - SPC_ENABLEOUT0), 1)
+ spcm_dwSetParam_i32(self.card, SPC_AMP0 + ch * (SPC_AMP1 - SPC_AMP0), amplitude)
+ spcm_dwSetParam_i32(self.card, SPC_CH0_STOPLEVEL + ch * (SPC_CH1_STOPLEVEL - SPC_CH0_STOPLEVEL),
+ stopmask[stoplvl])
+ else:
+ self.channel[ch] = 0
+ spcm_dwSetParam_i32(self.card, SPC_ENABLEOUT0 + ch * (SPC_ENABLEOUT1 - SPC_ENABLEOUT0), 0)
+ self.check_error()
+
+ # Deprecated
+ # def set_channel(self, ch: list, amplitude: list=(1000,1000,1000,1000), stoplvl: list=(16,16,16,16)):
+ # """
+ # set and enable channel outputs, max number of channel is 4
+ # :param ch: enables channel 0-3.
+ # Example: [0,1,0,1] enables channel 1 and 3.
+ # :param amplitude: sets output amplitude of each channel between 80-2500mV, default level is 1000mV.
+ # Example: [80,1000,0,0] sets output level for channel 0 and 1 to be 80 and 1000 mV.
+ # :param stoplvl: sets channels pause behavior, ZERO = 16, LOW = 2, HIGH = 4, HOLDLAST = 8.
+ # Example: [16, 2, 8, 8]
+ # """
+ # self.channel = ch
+ # mask = (CHANNEL0 & 1 * ch[0]) | \
+ # (CHANNEL1 & 2 * ch[1]) | \
+ # (CHANNEL2 & 4 * ch[2]) | \
+ # (CHANNEL3 & 8 * ch[3]) # create channel mask
+ # spcm_dwSetParam_i64(self.card, SPC_CHENABLE, int64(mask)) # activate channels
+ # for i in range(4):
+ # # enable channel outputs, set output amplitudes and pause behavior
+ # if ch[i] == 0: continue
+ # spcm_dwSetParam_i32(self.card, SPC_ENABLEOUT0 + i * (SPC_ENABLEOUT1 - SPC_ENABLEOUT0), 1)
+ # spcm_dwSetParam_i32(self.card, SPC_AMP0 + i * (SPC_AMP1 - SPC_AMP0), amplitude[i])
+ # spcm_dwSetParam_i32(self.card, SPC_CH0_STOPLEVEL + i * (SPC_CH1_STOPLEVEL - SPC_CH0_STOPLEVEL), stoplvl[i])
+ # self.check_error()
+
+ def set_trigger(self, **kwargs):
+ """
+ set trigger behavior
+ @TODO: add more functionality
+ :param args:
+ :param kwargs:
+ """
+ for key,value in kwargs.items():
+ if key == "EXT0":
+ spcm_dwSetParam_i32(self.card, SPC_TRIG_ORMASK, SPC_TMASK_EXT0) # using external channel 0 as trigger
+ spcm_dwSetParam_i32(self.card, SPC_TRIG_EXT0_MODE, value)
+ if key == "EXT1":
+ spcm_dwSetParam_i32(self.card, SPC_TRIG_ORMASK, SPC_TMASK_EXT1) # using external channel 1 as trigger
+ spcm_dwSetParam_i32(self.card, SPC_TRIG_EXT1_MODE, value)
+ self.check_error()
+
+ def get_aligned_array(self, size):
+ """
+ returns an array at a page-aligned memory location, necessary for data buffering
+ :param size: number of samples used for data calculation
+ :return: numpy array starting at the correct location
+ """
+ data_length_bytes = uint32(size * 2 * np.sum(self.channel))
+ buffer = pvAllocMemPageAligned(data_length_bytes) # buffer now holds a page-aligned location
+ buffer_data = cast(addressof(pvBuffer), ptr16) # cast it to int16 array
+ array = np.frombuffer(buffer_data, dtype=int16)
+ return array
+
+ def set_sequence_mode(self, nseg: int):
+ """
+ set the AWG mode to sequence replay, and divide memory into segments.
+ :param nseg: number of segments the memory is divided into, must be powers of 2.
+ """
+ self.mode = "Sequence Replay"
+ spcm_dwSetParam_i32(self.card, SPC_CARDMODE, SPC_REP_STD_SEQUENCE) # Sequence replay mode
+ spcm_dwSetParam_i32(self.card, SPC_SEQMODE_MAXSEGMENTS,nseg) # set number of sequences the memory is divided into
+ self.check_error()
+
+ def write_segment(self, data: np.array, segment: int):
+ """
+ write data onto a specified segment.
+ :param data: numpy array containing waveform data
+ :param segment: the segment to write on
+ :return:
+ """
+ if self.mode != "Sequence Replay":
+ print("Wrong method, current mode is: " + self.mode)
+ return
+ nch = np.sum(self.channel) # number of activated channels
+ if data.dtype != int:
+ sys.stdout.write("data must be in int type\n")
+ return
+ if data.size > self.mem_size.value / np.sum(self.channel) / SPC_SEQMODE_MAXSEGMENTS:
+ sys.stdout.write("data is big")
+ return
+ spcm_dwSetParam_i32(self.card, SPC_SEQMODE_WRITESEGMENT, segment) # set current segment to write on
+ spcm_dwSetParam_i32(self.card, SPC_SEQMODE_SEGMENTSIZE, data.size) # set size of segment in unit of samples
+ # data transfer
+ ptr = data.ctypes.data_as(POINTER(int16))
+ buflength = data.size * 2 * nch # samples * (2 bytes/sample) * number of activated channels
+ spcm_dwDefTransfer_i64(self.card, SPCM_BUF_DATA, SPCM_DIR_PCTOCARD, int32(0), ptr, int64(0), buflength)
+ spcm_dwSetParam_i32(self.card, SPC_M2CMD, M2CMD_DATA_STARTDMA | M2CMD_DATA_WAITDMA)
+ self.check_error()
+
+ def configure_step(self, step: int, segment: int, nextstep: int, loop: int, condition: int):
+ """
+ configure a step in the sequence replay mode.
+ :param step: the step to be configured, sequence starts at step 0 on default, max step is 32.
+ :param segment: waveform containing segment to be associated with the configured step.
+ :param nextstep: index of next step in the sequence.
+ :param loop: number of times the current step is repeated before checking for next step condition.
+ :param condition: behavior after current step is repeated "loop" amount of times.
+ list of conditions: SPCSEQ_ENDLOOPALWAYS, SPCSEQ_ENDLOOPONTRIG, SPCSEQ_END, see manual for detail.
+ """
+ if self.mode != "Sequence Replay":
+ print("Wrong method, current mode is: " + self.mode)
+ return
+ mask = (condition << 32) | (loop << 32) | (nextstep << 16) | segment # 64-bit mask
+ spcm_dwSetParam_i64(self.card, SPC_SEQMODE_STEPMEM0 + step, mask)
+ self.check_error()
+
diff --git a/Python/AWG_outdated.py b/Python/AWG_outdated.py
new file mode 100644
index 0000000000000000000000000000000000000000..5c79ca54261bd363fc7c750e63a9d80a660dc022
--- /dev/null
+++ b/Python/AWG_outdated.py
@@ -0,0 +1,70 @@
+from pyspcm import *
+from spcm_tools import *
+import sys
+
+#
+# **************************************************************************
+# Class for controlling the AWG
+#
+# User must install the AWG driver for Windows 8/9/10/11, found in
+# https://spectrum-instrumentation.com/support/downloads.php
+# Look under model M4i 6622-x8
+#
+# The python module provided in pyspcm is in essence a c/c++ wrapper,
+# hence the use of ctype variables in this code.
+# **************************************************************************
+#
+
+
+class AWG:
+ def __init__(self):
+ self.hCard = None # holds the spcm card instance, this is used by all spcm calls
+ self.cardType = int32(0)
+ self.serialNumber = int32(0)
+ self.sampleRate = int64(0)
+ self.memSize = int64(0)
+ self.fncType = int32(0)
+
+ def open(self, remote=False):
+ # check for remote connection
+ if remote:
+ self.hCard = spcm_hOpen(create_string_buffer(b'TCPIP::192.168.1.10::inst0::INSTR'))
+ else:
+ self.hCard = spcm_hOpen(create_string_buffer(b'/dev/spcm0'))
+ if self.hCard is None:
+ sys.stdout.write("no card found...\n")
+ else:
+ # initialize variables
+ spcm_dwGetParam_i32(self.hCard, SPC_PCITYP, byref(self.cardType))
+ spcm_dwGetParam_i32(self.hCard, SPC_PCISERIALNO, byref(self.serialNumber))
+ spcm_dwGetParam_i32(self.hCard, SPC_FNCTYPE, byref(self.fncType))
+ spcm_dwGetParam_i64(self.hCard, SPC_SAMPLERATE, byref(self.sampleRate))
+ spcm_dwGetParam_i64(self.hCard, SPC_PCIMEMSIZE, byref(self.memSize))
+ name = szTypeToName(self.cardType.value)
+ sys.stdout.write("Found: {0} sn {1:05d}\n".format(name, self.serialNumber.value))
+ sys.stdout.write("Sample Rate: {:.1f} MHz\n".format(self.sampleRate.value / 1000000))
+ sys.stdout.write("Memory size: {:.0f} MBytes\n".format(self.memSize.value / 1024 / 1024))
+
+ def close(self):
+ spcm_vClose(self.hCard)
+
+ # Check if an error has occurred, return 1 if true
+ def checkError(self, customMsg=None):
+ toPrint = 0
+ msg = "Checking error at " + customMsg + " ... "
+ if customMsg is not None:
+ toPrint = 1
+ sys.stdout.write(msg)
+ errReg = uint32(0)
+ errVal = int32(0)
+ errText = ''
+ errCode = spcm_dwGetErrorInfo_i32(self.hCard, byref(errReg), byref(errVal), errText)
+ if errCode:
+ if toPrint:
+ sys.stdout.write(errText)
+ else:
+ sys.stdout.write(msg + errText)
+ return 1
+ elif toPrint:
+ sys.stdout.write("no error\n")
+ return 0
diff --git a/Python/py_header/regs.py b/Python/py_header/regs.py
new file mode 100644
index 0000000000000000000000000000000000000000..84a91fffe2772189cc00b848656f0da27a265326
--- /dev/null
+++ b/Python/py_header/regs.py
@@ -0,0 +1,2987 @@
+def KILO(k): return ( 1000 * (k))
+
+def MEGA(m): return ( 1000 * 1000 * (m))
+
+def GIGA(g): return ( 1000 * 1000 * 1000 * (g))
+
+def KILO_B(k): return ( 1024 * (k))
+
+def MEGA_B(m): return ( 1024 * 1024 * (m))
+
+def GIGA_B(g): return ( 1024 * 1024 * 1024 * (g))
+
+TYP_PCIDEVICEID = 0x00000000
+TYP_EVAL = 0x00000010
+TYP_RSDLGA = 0x00000014
+TYP_GMG = 0x00000018
+TYP_VAN8 = 0x00000020
+TYP_VAC = 0x00000028
+TYP_PCIAUTOINSTALL = 0x000000FF
+TYP_DAP116 = 0x00000100
+TYP_PAD82 = 0x00000200
+TYP_PAD82a = 0x00000210
+TYP_PAD82b = 0x00000220
+TYP_PCI212 = 0x00000300
+TYP_PAD1232a = 0x00000400
+TYP_PAD1232b = 0x00000410
+TYP_PAD1232c = 0x00000420
+TYP_PAD1616a = 0x00000500
+TYP_PAD1616b = 0x00000510
+TYP_PAD1616c = 0x00000520
+TYP_PAD1616d = 0x00000530
+TYP_PAD52 = 0x00000600
+TYP_PAD242 = 0x00000700
+TYP_PCK400 = 0x00000800
+TYP_PAD164_2M = 0x00000900
+TYP_PAD164_5M = 0x00000910
+TYP_PCI208 = 0x00001000
+TYP_CPCI208 = 0x00001001
+TYP_PCI412 = 0x00001100
+TYP_PCIDIO32 = 0x00001200
+TYP_PCI248 = 0x00001300
+TYP_PADCO = 0x00001400
+TYP_TRS582 = 0x00001500
+TYP_PCI258 = 0x00001600
+TYP_SERIESMASK = 0x00FF0000
+TYP_VERSIONMASK = 0x0000FFFF
+TYP_FAMILYMASK = 0x0000FF00
+TYP_TYPEMASK = 0x000000FF
+TYP_SPEEDMASK = 0x000000F0
+TYP_CHMASK = 0x0000000F
+TYP_MISERIES = 0x00000000
+TYP_MCSERIES = 0x00010000
+TYP_MXSERIES = 0x00020000
+TYP_M2ISERIES = 0x00030000
+TYP_M2IEXPSERIES = 0x00040000
+TYP_M3ISERIES = 0x00050000
+TYP_M3IEXPSERIES = 0x00060000
+TYP_M4IEXPSERIES = 0x00070000
+TYP_M4XEXPSERIES = 0x00080000
+TYP_M2PEXPSERIES = 0x00090000
+TYP_M5IEXPSERIES = 0x000A0000
+TYP_MI2020 = 0x00002020
+TYP_MI2021 = 0x00002021
+TYP_MI2025 = 0x00002025
+TYP_MI2030 = 0x00002030
+TYP_MI2031 = 0x00002031
+TYP_M2I2020 = 0x00032020
+TYP_M2I2021 = 0x00032021
+TYP_M2I2025 = 0x00032025
+TYP_M2I2030 = 0x00032030
+TYP_M2I2031 = 0x00032031
+TYP_M2I2020EXP = 0x00042020
+TYP_M2I2021EXP = 0x00042021
+TYP_M2I2025EXP = 0x00042025
+TYP_M2I2030EXP = 0x00042030
+TYP_M2I2031EXP = 0x00042031
+TYP_MC2020 = 0x00012020
+TYP_MC2021 = 0x00012021
+TYP_MC2025 = 0x00012025
+TYP_MC2030 = 0x00012030
+TYP_MC2031 = 0x00012031
+TYP_MX2020 = 0x00022020
+TYP_MX2025 = 0x00022025
+TYP_MX2030 = 0x00022030
+TYP_M3I2120 = 0x00052120
+TYP_M3I2122 = 0x00052122
+TYP_M3I2130 = 0x00052130
+TYP_M3I2132 = 0x00052132
+TYP_M3I2120EXP = 0x00062120
+TYP_M3I2122EXP = 0x00062122
+TYP_M3I2130EXP = 0x00062130
+TYP_M3I2132EXP = 0x00062132
+TYP_M4I22XX_X8 = 0x00072200
+TYP_M4I2210_X8 = 0x00072210
+TYP_M4I2211_X8 = 0x00072211
+TYP_M4I2212_X8 = 0x00072212
+TYP_M4I2220_X8 = 0x00072220
+TYP_M4I2221_X8 = 0x00072221
+TYP_M4I2223_X8 = 0x00072223
+TYP_M4I2230_X8 = 0x00072230
+TYP_M4I2233_X8 = 0x00072233
+TYP_M4I2234_X8 = 0x00072234
+TYP_M4I2280_X8 = 0x00072280
+TYP_M4I2281_X8 = 0x00072281
+TYP_M4I2283_X8 = 0x00072283
+TYP_M4I2290_X8 = 0x00072290
+TYP_M4I2293_X8 = 0x00072293
+TYP_M4I2294_X8 = 0x00072294
+TYP_M4X22XX_X4 = 0x00082200
+TYP_M4X2210_X4 = 0x00082210
+TYP_M4X2211_X4 = 0x00082211
+TYP_M4X2212_X4 = 0x00082212
+TYP_M4X2220_X4 = 0x00082220
+TYP_M4X2221_X4 = 0x00082221
+TYP_M4X2223_X4 = 0x00082223
+TYP_M4X2230_X4 = 0x00082230
+TYP_M4X2233_X4 = 0x00082233
+TYP_M4X2234_X4 = 0x00082234
+TYP_M4I23XX_X8 = 0x00072300
+TYP_M4I2320_X8 = 0x00072320
+TYP_M4I2321_X8 = 0x00072321
+TYP_M4I2323_X8 = 0x00072323
+TYP_M4I2330_X8 = 0x00072330
+TYP_M4I2333_X8 = 0x00072333
+TYP_M4I2334_X8 = 0x00072334
+TYP_MI3010 = 0x00003010
+TYP_MI3011 = 0x00003011
+TYP_MI3012 = 0x00003012
+TYP_MI3013 = 0x00003013
+TYP_MI3014 = 0x00003014
+TYP_MI3015 = 0x00003015
+TYP_MI3016 = 0x00003016
+TYP_MI3020 = 0x00003020
+TYP_MI3021 = 0x00003021
+TYP_MI3022 = 0x00003022
+TYP_MI3023 = 0x00003023
+TYP_MI3024 = 0x00003024
+TYP_MI3025 = 0x00003025
+TYP_MI3026 = 0x00003026
+TYP_MI3027 = 0x00003027
+TYP_MI3031 = 0x00003031
+TYP_MI3033 = 0x00003033
+TYP_M2I3010 = 0x00033010
+TYP_M2I3011 = 0x00033011
+TYP_M2I3012 = 0x00033012
+TYP_M2I3013 = 0x00033013
+TYP_M2I3014 = 0x00033014
+TYP_M2I3015 = 0x00033015
+TYP_M2I3016 = 0x00033016
+TYP_M2I3020 = 0x00033020
+TYP_M2I3021 = 0x00033021
+TYP_M2I3022 = 0x00033022
+TYP_M2I3023 = 0x00033023
+TYP_M2I3024 = 0x00033024
+TYP_M2I3025 = 0x00033025
+TYP_M2I3026 = 0x00033026
+TYP_M2I3027 = 0x00033027
+TYP_M2I3031 = 0x00033031
+TYP_M2I3033 = 0x00033033
+TYP_M2I3010EXP = 0x00043010
+TYP_M2I3011EXP = 0x00043011
+TYP_M2I3012EXP = 0x00043012
+TYP_M2I3013EXP = 0x00043013
+TYP_M2I3014EXP = 0x00043014
+TYP_M2I3015EXP = 0x00043015
+TYP_M2I3016EXP = 0x00043016
+TYP_M2I3020EXP = 0x00043020
+TYP_M2I3021EXP = 0x00043021
+TYP_M2I3022EXP = 0x00043022
+TYP_M2I3023EXP = 0x00043023
+TYP_M2I3024EXP = 0x00043024
+TYP_M2I3025EXP = 0x00043025
+TYP_M2I3026EXP = 0x00043026
+TYP_M2I3027EXP = 0x00043027
+TYP_M2I3031EXP = 0x00043031
+TYP_M2I3033EXP = 0x00043033
+TYP_MC3010 = 0x00013010
+TYP_MC3011 = 0x00013011
+TYP_MC3012 = 0x00013012
+TYP_MC3013 = 0x00013013
+TYP_MC3014 = 0x00013014
+TYP_MC3015 = 0x00013015
+TYP_MC3016 = 0x00013016
+TYP_MC3020 = 0x00013020
+TYP_MC3021 = 0x00013021
+TYP_MC3022 = 0x00013022
+TYP_MC3023 = 0x00013023
+TYP_MC3024 = 0x00013024
+TYP_MC3025 = 0x00013025
+TYP_MC3026 = 0x00013026
+TYP_MC3027 = 0x00013027
+TYP_MC3031 = 0x00013031
+TYP_MC3033 = 0x00013033
+TYP_MX3010 = 0x00023010
+TYP_MX3011 = 0x00023011
+TYP_MX3012 = 0x00023012
+TYP_MX3020 = 0x00023020
+TYP_MX3021 = 0x00023021
+TYP_MX3022 = 0x00023022
+TYP_MX3031 = 0x00023031
+TYP_MI3110 = 0x00003110
+TYP_MI3111 = 0x00003111
+TYP_MI3112 = 0x00003112
+TYP_MI3120 = 0x00003120
+TYP_MI3121 = 0x00003121
+TYP_MI3122 = 0x00003122
+TYP_MI3130 = 0x00003130
+TYP_MI3131 = 0x00003131
+TYP_MI3132 = 0x00003132
+TYP_MI3140 = 0x00003140
+TYP_M2I3110 = 0x00033110
+TYP_M2I3111 = 0x00033111
+TYP_M2I3112 = 0x00033112
+TYP_M2I3120 = 0x00033120
+TYP_M2I3121 = 0x00033121
+TYP_M2I3122 = 0x00033122
+TYP_M2I3130 = 0x00033130
+TYP_M2I3131 = 0x00033131
+TYP_M2I3132 = 0x00033132
+TYP_M2I3110EXP = 0x00043110
+TYP_M2I3111EXP = 0x00043111
+TYP_M2I3112EXP = 0x00043112
+TYP_M2I3120EXP = 0x00043120
+TYP_M2I3121EXP = 0x00043121
+TYP_M2I3122EXP = 0x00043122
+TYP_M2I3130EXP = 0x00043130
+TYP_M2I3131EXP = 0x00043131
+TYP_M2I3132EXP = 0x00043132
+TYP_MC3110 = 0x00013110
+TYP_MC3111 = 0x00013111
+TYP_MC3112 = 0x00013112
+TYP_MC3120 = 0x00013120
+TYP_MC3121 = 0x00013121
+TYP_MC3122 = 0x00013122
+TYP_MC3130 = 0x00013130
+TYP_MC3131 = 0x00013131
+TYP_MC3132 = 0x00013132
+TYP_MX3110 = 0x00023110
+TYP_MX3111 = 0x00023111
+TYP_MX3120 = 0x00023120
+TYP_MX3121 = 0x00023121
+TYP_MX3130 = 0x00023130
+TYP_MX3131 = 0x00023131
+TYP_M3I3220 = 0x00053220
+TYP_M3I3221 = 0x00053221
+TYP_M3I3240 = 0x00053240
+TYP_M3I3242 = 0x00053242
+TYP_M3I3220EXP = 0x00063220
+TYP_M3I3221EXP = 0x00063221
+TYP_M3I3240EXP = 0x00063240
+TYP_M3I3242EXP = 0x00063242
+TYP_M5I33XX_X16 = 0x000A3300
+TYP_M5I3330_X16 = 0x000A3330
+TYP_M5I3337_X16 = 0x000A3337
+TYP_MI4020 = 0x00004020
+TYP_MI4021 = 0x00004021
+TYP_MI4022 = 0x00004022
+TYP_MI4030 = 0x00004030
+TYP_MI4031 = 0x00004031
+TYP_MI4032 = 0x00004032
+TYP_M2I4020 = 0x00034020
+TYP_M2I4021 = 0x00034021
+TYP_M2I4022 = 0x00034022
+TYP_M2I4028 = 0x00034028
+TYP_M2I4030 = 0x00034030
+TYP_M2I4031 = 0x00034031
+TYP_M2I4032 = 0x00034032
+TYP_M2I4038 = 0x00034038
+TYP_M2I4020EXP = 0x00044020
+TYP_M2I4021EXP = 0x00044021
+TYP_M2I4022EXP = 0x00044022
+TYP_M2I4028EXP = 0x00044028
+TYP_M2I4030EXP = 0x00044030
+TYP_M2I4031EXP = 0x00044031
+TYP_M2I4032EXP = 0x00044032
+TYP_M2I4038EXP = 0x00044038
+TYP_MC4020 = 0x00014020
+TYP_MC4021 = 0x00014021
+TYP_MC4022 = 0x00014022
+TYP_MC4030 = 0x00014030
+TYP_MC4031 = 0x00014031
+TYP_MC4032 = 0x00014032
+TYP_MX4020 = 0x00024020
+TYP_MX4021 = 0x00024021
+TYP_MX4030 = 0x00024030
+TYP_MX4031 = 0x00024031
+TYP_M3I4110 = 0x00054110
+TYP_M3I4111 = 0x00054111
+TYP_M3I4120 = 0x00054120
+TYP_M3I4121 = 0x00054121
+TYP_M3I4140 = 0x00054140
+TYP_M3I4142 = 0x00054142
+TYP_M3I4110EXP = 0x00064110
+TYP_M3I4111EXP = 0x00064111
+TYP_M3I4120EXP = 0x00064120
+TYP_M3I4121EXP = 0x00064121
+TYP_M3I4140EXP = 0x00064140
+TYP_M3I4142EXP = 0x00064142
+TYP_M4I44XX_X8 = 0x00074400
+TYP_M4I4410_X8 = 0x00074410
+TYP_M4I4411_X8 = 0x00074411
+TYP_M4I4420_X8 = 0x00074420
+TYP_M4I4421_X8 = 0x00074421
+TYP_M4I4450_X8 = 0x00074450
+TYP_M4I4451_X8 = 0x00074451
+TYP_M4I4470_X8 = 0x00074470
+TYP_M4I4471_X8 = 0x00074471
+TYP_M4I4480_X8 = 0x00074480
+TYP_M4I4481_X8 = 0x00074481
+TYP_M4X44XX_X4 = 0x00084400
+TYP_M4X4410_X4 = 0x00084410
+TYP_M4X4411_X4 = 0x00084411
+TYP_M4X4420_X4 = 0x00084420
+TYP_M4X4421_X4 = 0x00084421
+TYP_M4X4450_X4 = 0x00084450
+TYP_M4X4451_X4 = 0x00084451
+TYP_M4X4470_X4 = 0x00084470
+TYP_M4X4471_X4 = 0x00084471
+TYP_M4X4480_X4 = 0x00084480
+TYP_M4X4481_X4 = 0x00084481
+TYP_MI4520 = 0x00004520
+TYP_MI4521 = 0x00004521
+TYP_MI4530 = 0x00004530
+TYP_MI4531 = 0x00004531
+TYP_MI4540 = 0x00004540
+TYP_MI4541 = 0x00004541
+TYP_M2I4520 = 0x00034520
+TYP_M2I4521 = 0x00034521
+TYP_M2I4530 = 0x00034530
+TYP_M2I4531 = 0x00034531
+TYP_M2I4540 = 0x00034540
+TYP_M2I4541 = 0x00034541
+TYP_MC4520 = 0x00014520
+TYP_MC4521 = 0x00014521
+TYP_MC4530 = 0x00014530
+TYP_MC4531 = 0x00014531
+TYP_MC4540 = 0x00014540
+TYP_MC4541 = 0x00014541
+TYP_MX4520 = 0x00024520
+TYP_MX4530 = 0x00024530
+TYP_MX4540 = 0x00024540
+TYP_MI4620 = 0x00004620
+TYP_MI4621 = 0x00004621
+TYP_MI4622 = 0x00004622
+TYP_MI4630 = 0x00004630
+TYP_MI4631 = 0x00004631
+TYP_MI4632 = 0x00004632
+TYP_MI4640 = 0x00004640
+TYP_MI4641 = 0x00004641
+TYP_MI4642 = 0x00004642
+TYP_MI4650 = 0x00004650
+TYP_MI4651 = 0x00004651
+TYP_MI4652 = 0x00004652
+TYP_M2I4620 = 0x00034620
+TYP_M2I4621 = 0x00034621
+TYP_M2I4622 = 0x00034622
+TYP_M2I4630 = 0x00034630
+TYP_M2I4631 = 0x00034631
+TYP_M2I4632 = 0x00034632
+TYP_M2I4640 = 0x00034640
+TYP_M2I4641 = 0x00034641
+TYP_M2I4642 = 0x00034642
+TYP_M2I4650 = 0x00034650
+TYP_M2I4651 = 0x00034651
+TYP_M2I4652 = 0x00034652
+TYP_M2I4620EXP = 0x00044620
+TYP_M2I4621EXP = 0x00044621
+TYP_M2I4622EXP = 0x00044622
+TYP_M2I4630EXP = 0x00044630
+TYP_M2I4631EXP = 0x00044631
+TYP_M2I4632EXP = 0x00044632
+TYP_M2I4640EXP = 0x00044640
+TYP_M2I4641EXP = 0x00044641
+TYP_M2I4642EXP = 0x00044642
+TYP_M2I4650EXP = 0x00044650
+TYP_M2I4651EXP = 0x00044651
+TYP_M2I4652EXP = 0x00044652
+TYP_MC4620 = 0x00014620
+TYP_MC4621 = 0x00014621
+TYP_MC4622 = 0x00014622
+TYP_MC4630 = 0x00014630
+TYP_MC4631 = 0x00014631
+TYP_MC4632 = 0x00014632
+TYP_MC4640 = 0x00014640
+TYP_MC4641 = 0x00014641
+TYP_MC4642 = 0x00014642
+TYP_MC4650 = 0x00014650
+TYP_MC4651 = 0x00014651
+TYP_MC4652 = 0x00014652
+TYP_MX4620 = 0x00024620
+TYP_MX4621 = 0x00024621
+TYP_MX4630 = 0x00024630
+TYP_MX4631 = 0x00024631
+TYP_MX4640 = 0x00024640
+TYP_MX4641 = 0x00024641
+TYP_MX4650 = 0x00024650
+TYP_MX4651 = 0x00024651
+TYP_MI4710 = 0x00004710
+TYP_MI4711 = 0x00004711
+TYP_MI4720 = 0x00004720
+TYP_MI4721 = 0x00004721
+TYP_MI4730 = 0x00004730
+TYP_MI4731 = 0x00004731
+TYP_MI4740 = 0x00004740
+TYP_MI4741 = 0x00004741
+TYP_M2I4710 = 0x00034710
+TYP_M2I4711 = 0x00034711
+TYP_M2I4720 = 0x00034720
+TYP_M2I4721 = 0x00034721
+TYP_M2I4730 = 0x00034730
+TYP_M2I4731 = 0x00034731
+TYP_M2I4740 = 0x00034740
+TYP_M2I4741 = 0x00034741
+TYP_M2I4710EXP = 0x00044710
+TYP_M2I4711EXP = 0x00044711
+TYP_M2I4720EXP = 0x00044720
+TYP_M2I4721EXP = 0x00044721
+TYP_M2I4730EXP = 0x00044730
+TYP_M2I4731EXP = 0x00044731
+TYP_M2I4740EXP = 0x00044740
+TYP_M2I4741EXP = 0x00044741
+TYP_MC4710 = 0x00014710
+TYP_MC4711 = 0x00014711
+TYP_MC4720 = 0x00014720
+TYP_MC4721 = 0x00014721
+TYP_MC4730 = 0x00014730
+TYP_MC4731 = 0x00014731
+TYP_MX4710 = 0x00024710
+TYP_MX4720 = 0x00024720
+TYP_MX4730 = 0x00024730
+TYP_M3I4830 = 0x00054830
+TYP_M3I4831 = 0x00054831
+TYP_M3I4840 = 0x00054840
+TYP_M3I4841 = 0x00054841
+TYP_M3I4860 = 0x00054860
+TYP_M3I4861 = 0x00054861
+TYP_M3I4830EXP = 0x00064830
+TYP_M3I4831EXP = 0x00064831
+TYP_M3I4840EXP = 0x00064840
+TYP_M3I4841EXP = 0x00064841
+TYP_M3I4860EXP = 0x00064860
+TYP_M3I4861EXP = 0x00064861
+TYP_MI4911 = 0x00004911
+TYP_MI4912 = 0x00004912
+TYP_MI4931 = 0x00004931
+TYP_MI4932 = 0x00004932
+TYP_MI4960 = 0x00004960
+TYP_MI4961 = 0x00004961
+TYP_MI4963 = 0x00004963
+TYP_MI4964 = 0x00004964
+TYP_MC4911 = 0x00014911
+TYP_MC4912 = 0x00014912
+TYP_MC4931 = 0x00014931
+TYP_MC4932 = 0x00014932
+TYP_MC4960 = 0x00014960
+TYP_MC4961 = 0x00014961
+TYP_MC4963 = 0x00014963
+TYP_MC4964 = 0x00014964
+TYP_MX4911 = 0x00024911
+TYP_MX4931 = 0x00024931
+TYP_MX4960 = 0x00024960
+TYP_MX4963 = 0x00024963
+TYP_M2I4911 = 0x00034911
+TYP_M2I4912 = 0x00034912
+TYP_M2I4931 = 0x00034931
+TYP_M2I4932 = 0x00034932
+TYP_M2I4960 = 0x00034960
+TYP_M2I4961 = 0x00034961
+TYP_M2I4963 = 0x00034963
+TYP_M2I4964 = 0x00034964
+TYP_M2I4911EXP = 0x00044911
+TYP_M2I4912EXP = 0x00044912
+TYP_M2I4931EXP = 0x00044931
+TYP_M2I4932EXP = 0x00044932
+TYP_M2I4960EXP = 0x00044960
+TYP_M2I4961EXP = 0x00044961
+TYP_M2I4963EXP = 0x00044963
+TYP_M2I4964EXP = 0x00044964
+TYP_M2P59XX_X4 = 0x00095900
+TYP_M2P5911_X4 = 0x00095911
+TYP_M2P5912_X4 = 0x00095912
+TYP_M2P5913_X4 = 0x00095913
+TYP_M2P5916_X4 = 0x00095916
+TYP_M2P5920_X4 = 0x00095920
+TYP_M2P5921_X4 = 0x00095921
+TYP_M2P5922_X4 = 0x00095922
+TYP_M2P5923_X4 = 0x00095923
+TYP_M2P5926_X4 = 0x00095926
+TYP_M2P5930_X4 = 0x00095930
+TYP_M2P5931_X4 = 0x00095931
+TYP_M2P5932_X4 = 0x00095932
+TYP_M2P5933_X4 = 0x00095933
+TYP_M2P5936_X4 = 0x00095936
+TYP_M2P5940_X4 = 0x00095940
+TYP_M2P5941_X4 = 0x00095941
+TYP_M2P5942_X4 = 0x00095942
+TYP_M2P5943_X4 = 0x00095943
+TYP_M2P5946_X4 = 0x00095946
+TYP_M2P5960_X4 = 0x00095960
+TYP_M2P5961_X4 = 0x00095961
+TYP_M2P5962_X4 = 0x00095962
+TYP_M2P5966_X4 = 0x00095966
+TYP_M2P5968_X4 = 0x00095968
+TYP_MI6010 = 0x00006010
+TYP_MI6011 = 0x00006011
+TYP_MI6012 = 0x00006012
+TYP_MI6021 = 0x00006021
+TYP_MI6022 = 0x00006022
+TYP_MI6030 = 0x00006030
+TYP_MI6031 = 0x00006031
+TYP_MI6033 = 0x00006033
+TYP_MI6034 = 0x00006034
+TYP_M2I6010 = 0x00036010
+TYP_M2I6011 = 0x00036011
+TYP_M2I6012 = 0x00036012
+TYP_M2I6021 = 0x00036021
+TYP_M2I6022 = 0x00036022
+TYP_M2I6030 = 0x00036030
+TYP_M2I6031 = 0x00036031
+TYP_M2I6033 = 0x00036033
+TYP_M2I6034 = 0x00036034
+TYP_M2I6010EXP = 0x00046010
+TYP_M2I6011EXP = 0x00046011
+TYP_M2I6012EXP = 0x00046012
+TYP_M2I6021EXP = 0x00046021
+TYP_M2I6022EXP = 0x00046022
+TYP_M2I6030EXP = 0x00046030
+TYP_M2I6031EXP = 0x00046031
+TYP_M2I6033EXP = 0x00046033
+TYP_M2I6034EXP = 0x00046034
+TYP_MC6010 = 0x00016010
+TYP_MC6011 = 0x00016011
+TYP_MC6012 = 0x00016012
+TYP_MC6021 = 0x00016021
+TYP_MC6022 = 0x00016022
+TYP_MC6030 = 0x00016030
+TYP_MC6031 = 0x00016031
+TYP_MC6033 = 0x00016033
+TYP_MC6034 = 0x00016034
+TYP_MX6010 = 0x00026010
+TYP_MX6011 = 0x00026011
+TYP_MX6021 = 0x00026021
+TYP_MX6030 = 0x00026030
+TYP_MX6033 = 0x00026033
+TYP_MI6105 = 0x00006105
+TYP_MI6110 = 0x00006110
+TYP_MI6111 = 0x00006111
+TYP_M2I6105 = 0x00036105
+TYP_M2I6110 = 0x00036110
+TYP_M2I6111 = 0x00036111
+TYP_M2I6105EXP = 0x00046105
+TYP_M2I6110EXP = 0x00046110
+TYP_M2I6111EXP = 0x00046111
+TYP_MC6110 = 0x00016110
+TYP_MC6111 = 0x00016111
+TYP_MX6110 = 0x00026110
+TYP_M2P65XX_X4 = 0x00096500
+TYP_M2P6522_X4 = 0x00096522
+TYP_M2P6523_X4 = 0x00096523
+TYP_M2P6530_X4 = 0x00096530
+TYP_M2P6531_X4 = 0x00096531
+TYP_M2P6532_X4 = 0x00096532
+TYP_M2P6536_X4 = 0x00096536
+TYP_M2P6533_X4 = 0x00096533
+TYP_M2P6540_X4 = 0x00096540
+TYP_M2P6541_X4 = 0x00096541
+TYP_M2P6546_X4 = 0x00096546
+TYP_M2P6560_X4 = 0x00096560
+TYP_M2P6561_X4 = 0x00096561
+TYP_M2P6562_X4 = 0x00096562
+TYP_M2P6566_X4 = 0x00096566
+TYP_M2P6568_X4 = 0x00096568
+TYP_M2P6570_X4 = 0x00096570
+TYP_M2P6571_X4 = 0x00096571
+TYP_M2P6576_X4 = 0x00096576
+TYP_M4I66XX_X8 = 0x00076600
+TYP_M4I6620_X8 = 0x00076620
+TYP_M4I6621_X8 = 0x00076621
+TYP_M4I6622_X8 = 0x00076622
+TYP_M4I6630_X8 = 0x00076630
+TYP_M4I6631_X8 = 0x00076631
+TYP_M4X66XX_X4 = 0x00086600
+TYP_M4X6620_X4 = 0x00086620
+TYP_M4X6621_X4 = 0x00086621
+TYP_M4X6622_X4 = 0x00086622
+TYP_M4X6630_X4 = 0x00086630
+TYP_M4X6631_X4 = 0x00086631
+TYP_MI7005 = 0x00007005
+TYP_MI7010 = 0x00007010
+TYP_MI7011 = 0x00007011
+TYP_MI7020 = 0x00007020
+TYP_MI7021 = 0x00007021
+TYP_M2I7005 = 0x00037005
+TYP_M2I7010 = 0x00037010
+TYP_M2I7011 = 0x00037011
+TYP_M2I7020 = 0x00037020
+TYP_M2I7021 = 0x00037021
+TYP_M2I7005EXP = 0x00047005
+TYP_M2I7010EXP = 0x00047010
+TYP_M2I7011EXP = 0x00047011
+TYP_M2I7020EXP = 0x00047020
+TYP_M2I7021EXP = 0x00047021
+TYP_MC7005 = 0x00017005
+TYP_MC7010 = 0x00017010
+TYP_MC7011 = 0x00017011
+TYP_MC7020 = 0x00017020
+TYP_MC7021 = 0x00017021
+TYP_MX7005 = 0x00027005
+TYP_MX7010 = 0x00027010
+TYP_MX7011 = 0x00027011
+TYP_MI7210 = 0x00007210
+TYP_MI7211 = 0x00007211
+TYP_MI7220 = 0x00007220
+TYP_MI7221 = 0x00007221
+TYP_M2I7210 = 0x00037210
+TYP_M2I7211 = 0x00037211
+TYP_M2I7220 = 0x00037220
+TYP_M2I7221 = 0x00037221
+TYP_M2I7210EXP = 0x00047210
+TYP_M2I7211EXP = 0x00047211
+TYP_M2I7220EXP = 0x00047220
+TYP_M2I7221EXP = 0x00047221
+TYP_MC7210 = 0x00017210
+TYP_MC7211 = 0x00017211
+TYP_MC7220 = 0x00017220
+TYP_MC7221 = 0x00017221
+TYP_MX7210 = 0x00027210
+TYP_MX7220 = 0x00027220
+TYP_M2P75XX_X4 = 0x00097500
+TYP_M2P7515_X4 = 0x00097515
+TYP_M4I77XX_X8 = 0x00077700
+TYP_M4I7710_X8 = 0x00077710
+TYP_M4I7720_X8 = 0x00077720
+TYP_M4I7730_X8 = 0x00077730
+TYP_M4I7725_X8 = 0x00077725
+TYP_M4I7735_X8 = 0x00077735
+TYP_M4X77XX_X4 = 0x00087700
+TYP_M4X7710_X4 = 0x00087710
+TYP_M4X7720_X4 = 0x00087720
+TYP_M4X7730_X4 = 0x00087730
+TYP_M4X7725_X4 = 0x00087725
+TYP_M4X7735_X4 = 0x00087735
+TYP_MX9010 = 0x00029010
+PCIBIT_MULTI = 0x00000001
+PCIBIT_DIGITAL = 0x00000002
+PCIBIT_CH0DIGI = 0x00000004
+PCIBIT_EXTSAM = 0x00000008
+PCIBIT_3CHANNEL = 0x00000010
+PCIBIT_GATE = 0x00000020
+PCIBIT_SLAVE = 0x00000040
+PCIBIT_MASTER = 0x00000080
+PCIBIT_DOUBLEMEM = 0x00000100
+PCIBIT_SYNC = 0x00000200
+PCIBIT_TIMESTAMP = 0x00000400
+PCIBIT_STARHUB = 0x00000800
+PCIBIT_CA = 0x00001000
+PCIBIT_XIO = 0x00002000
+PCIBIT_AMPLIFIER = 0x00004000
+PCIBIT_DIFFMODE = 0x00008000
+PCIBIT_ELISA = 0x10000000
+SPCM_FEAT_MULTI = 0x00000001
+SPCM_FEAT_GATE = 0x00000002
+SPCM_FEAT_DIGITAL = 0x00000004
+SPCM_FEAT_TIMESTAMP = 0x00000008
+SPCM_FEAT_STARHUB5 = 0x00000020
+SPCM_FEAT_STARHUB4 = 0x00000020
+SPCM_FEAT_STARHUB6_EXTM = 0x00000020
+SPCM_FEAT_STARHUB8_EXTM = 0x00000020
+SPCM_FEAT_STARHUB16 = 0x00000040
+SPCM_FEAT_STARHUB16_EXTM = 0x00000040
+SPCM_FEAT_STARHUB8 = 0x00000040
+SPCM_FEAT_STARHUBXX_MASK = 0x00000060
+SPCM_FEAT_ABA = 0x00000080
+SPCM_FEAT_BASEXIO = 0x00000100
+SPCM_FEAT_AMPLIFIER_10V = 0x00000200
+SPCM_FEAT_STARHUBSYSMASTER = 0x00000400
+SPCM_FEAT_DIFFMODE = 0x00000800
+SPCM_FEAT_SEQUENCE = 0x00001000
+SPCM_FEAT_AMPMODULE_10V = 0x00002000
+SPCM_FEAT_STARHUBSYSSLAVE = 0x00004000
+SPCM_FEAT_NETBOX = 0x00008000
+SPCM_FEAT_REMOTESERVER = 0x00010000
+SPCM_FEAT_SCAPP = 0x00020000
+SPCM_FEAT_DIG16_SMB = 0x00040000
+SPCM_FEAT_DIG8_SMA = 0x00040000
+SPCM_FEAT_DIG16_FX2 = 0x00080000
+SPCM_FEAT_DIGITALBWFILTER = 0x00100000
+SPCM_FEAT_CUSTOMMOD_MASK = 0xF0000000
+SPCM_FEAT_EXTFW_SEGSTAT = 0x00000001
+SPCM_FEAT_EXTFW_SEGAVERAGE = 0x00000002
+SPCM_FEAT_EXTFW_BOXCAR = 0x00000004
+ERRORTEXTLEN = 200
+SPC_LASTERRORTEXT = 999996
+SPC_LASTERRORVALUE = 999997
+SPC_LASTERRORREG = 999998
+SPC_LASTERRORCODE = 999999
+COUPLING_DC = 0
+COUPLING_AC = 1
+SPC_COMMAND = 0
+SPC_RESET = 0
+SPC_SOFTRESET = 1
+SPC_WRITESETUP = 2
+SPC_START = 10
+SPC_STARTANDWAIT = 11
+SPC_FIFOSTART = 12
+SPC_FIFOWAIT = 13
+SPC_FIFOSTARTNOWAIT = 14
+SPC_FORCETRIGGER = 16
+SPC_STOP = 20
+SPC_FLUSHFIFOBUFFER = 21
+SPC_POWERDOWN = 30
+SPC_SYNCMASTER = 100
+SPC_SYNCTRIGGERMASTER = 101
+SPC_SYNCMASTERFIFO = 102
+SPC_SYNCSLAVE = 110
+SPC_SYNCTRIGGERSLAVE = 111
+SPC_SYNCSLAVEFIFO = 112
+SPC_NOSYNC = 120
+SPC_SYNCSTART = 130
+SPC_SYNCCALCMASTER = 140
+SPC_SYNCCALCMASTERFIFO = 141
+SPC_PXIDIVIDERRESET = 150
+SPC_RELAISON = 200
+SPC_RELAISOFF = 210
+SPC_ADJUSTSTART = 300
+SPC_FIFO_BUFREADY0 = 400
+SPC_FIFO_BUFREADY1 = 401
+SPC_FIFO_BUFREADY2 = 402
+SPC_FIFO_BUFREADY3 = 403
+SPC_FIFO_BUFREADY4 = 404
+SPC_FIFO_BUFREADY5 = 405
+SPC_FIFO_BUFREADY6 = 406
+SPC_FIFO_BUFREADY7 = 407
+SPC_FIFO_BUFREADY8 = 408
+SPC_FIFO_BUFREADY9 = 409
+SPC_FIFO_BUFREADY10 = 410
+SPC_FIFO_BUFREADY11 = 411
+SPC_FIFO_BUFREADY12 = 412
+SPC_FIFO_BUFREADY13 = 413
+SPC_FIFO_BUFREADY14 = 414
+SPC_FIFO_BUFREADY15 = 415
+SPC_FIFO_AUTOBUFSTART = 500
+SPC_FIFO_AUTOBUFEND = 510
+SPC_STATUS = 10
+SPC_RUN = 0
+SPC_TRIGGER = 10
+SPC_READY = 20
+SPC_M2CMD = 100
+M2CMD_CARD_RESET = 0x00000001
+M2CMD_CARD_WRITESETUP = 0x00000002
+M2CMD_CARD_START = 0x00000004
+M2CMD_CARD_ENABLETRIGGER = 0x00000008
+M2CMD_CARD_FORCETRIGGER = 0x00000010
+M2CMD_CARD_DISABLETRIGGER = 0x00000020
+M2CMD_CARD_STOP = 0x00000040
+M2CMD_CARD_FLUSHFIFO = 0x00000080
+M2CMD_CARD_INVALIDATEDATA = 0x00000100
+M2CMD_CARD_INTERNALRESET = 0x00000200
+M2CMD_ALL_STOP = 0x00440060
+M2CMD_CARD_WAITPREFULL = 0x00001000
+M2CMD_CARD_WAITTRIGGER = 0x00002000
+M2CMD_CARD_WAITREADY = 0x00004000
+M2CMD_DATA_STARTDMA = 0x00010000
+M2CMD_DATA_WAITDMA = 0x00020000
+M2CMD_DATA_STOPDMA = 0x00040000
+M2CMD_DATA_POLL = 0x00080000
+M2CMD_EXTRA_STARTDMA = 0x00100000
+M2CMD_EXTRA_WAITDMA = 0x00200000
+M2CMD_EXTRA_STOPDMA = 0x00400000
+M2CMD_EXTRA_POLL = 0x00800000
+M2CMD_DATA_SGFLUSH = 0x01000000
+SPC_M2STATUS = 110
+M2STAT_NONE = 0x00000000
+M2STAT_CARD_PRETRIGGER = 0x00000001
+M2STAT_CARD_TRIGGER = 0x00000002
+M2STAT_CARD_READY = 0x00000004
+M2STAT_CARD_SEGMENT_PRETRG = 0x00000008
+M2STAT_DATA_BLOCKREADY = 0x00000100
+M2STAT_DATA_END = 0x00000200
+M2STAT_DATA_OVERRUN = 0x00000400
+M2STAT_DATA_ERROR = 0x00000800
+M2STAT_EXTRA_BLOCKREADY = 0x00001000
+M2STAT_EXTRA_END = 0x00002000
+M2STAT_EXTRA_OVERRUN = 0x00004000
+M2STAT_EXTRA_ERROR = 0x00008000
+M2STAT_TSCNT_OVERRUN = 0x00010000
+M2STAT_INTERNALMASK = 0xff000000
+M2STAT_INTERNAL_SYSLOCK = 0x02000000
+SPC_DATA_AVAIL_USER_LEN = 200
+SPC_DATA_AVAIL_USER_POS = 201
+SPC_DATA_AVAIL_CARD_LEN = 202
+SPC_DATA_OUTBUFSIZE = 209
+SPC_ABA_AVAIL_USER_LEN = 210
+SPC_ABA_AVAIL_USER_POS = 211
+SPC_ABA_AVAIL_CARD_LEN = 212
+SPC_TS_AVAIL_USER_LEN = 220
+SPC_TS_AVAIL_USER_POS = 221
+SPC_TS_AVAIL_CARD_LEN = 222
+SPC_VERSION = 1000
+SPC_ISAADR = 1010
+SPC_INSTMEM = 1020
+SPC_INSTSAMPLERATE = 1030
+SPC_BRDTYP = 1040
+SPC_MIINST_MODULES = 1100
+SPC_MIINST_CHPERMODULE = 1110
+SPC_MIINST_BYTESPERSAMPLE = 1120
+SPC_MIINST_BITSPERSAMPLE = 1125
+SPC_MIINST_MAXADCVALUE = 1126
+SPC_MIINST_MINADCLOCK = 1130
+SPC_MIINST_MAXADCLOCK = 1140
+SPC_MIINST_MINEXTCLOCK = 1145
+SPC_MIINST_MAXEXTCLOCK = 1146
+SPC_MIINST_MINSYNCCLOCK = 1147
+SPC_MIINST_MINEXTREFCLOCK = 1148
+SPC_MIINST_MAXEXTREFCLOCK = 1149
+SPC_MIINST_QUARZ = 1150
+SPC_MIINST_QUARZ2 = 1151
+SPC_MIINST_MINEXTCLOCK1 = 1152
+SPC_MIINST_FLAGS = 1160
+SPC_MIINST_FIFOSUPPORT = 1170
+SPC_MIINST_ISDEMOCARD = 1175
+SPC_GETDRVVERSION = 1200
+SPC_GETKERNELVERSION = 1210
+SPC_GETDRVTYPE = 1220
+DRVTYP_DOS = 0
+DRVTYP_LINUX32 = 1
+DRVTYP_VXD = 2
+DRVTYP_NTLEGACY = 3
+DRVTYP_WDM32 = 4
+DRVTYP_WDM64 = 5
+DRVTYP_WOW64 = 6
+DRVTYP_LINUX64 = 7
+DRVTYP_QNX32 = 8
+DRVTYP_QNX64 = 9
+SPC_GETCOMPATIBILITYVERSION = 1230
+SPC_GETMINDRVVERSION = 1240
+SPC_PCITYP = 2000
+SPC_FNCTYPE = 2001
+SPCM_TYPE_AI = 0x01
+SPCM_TYPE_AO = 0x02
+SPCM_TYPE_DI = 0x04
+SPCM_TYPE_DO = 0x08
+SPCM_TYPE_DIO = 0x10
+SPC_PCIVERSION = 2010
+SPC_PCIEXTVERSION = 2011
+SPC_PCIMODULEVERSION = 2012
+SPC_PCIMODULEBVERSION = 2013
+SPC_BASEPCBVERSION = 2014
+SPC_MODULEPCBVERSION = 2015
+SPC_MODULEAPCBVERSION = 2015
+SPC_MODULEBPCBVERSION = 2016
+SPC_EXTPCBVERSION = 2017
+SPC_PCIDIGVERSION = 2018
+SPC_DIGPCBVERSION = 2019
+SPC_PCIDATE = 2020
+SPC_CALIBDATE = 2025
+SPC_CALIBDATEONBOARD = 2026
+SPC_PCISERIALNR = 2030
+SPC_PCISERIALNO = 2030
+SPC_PCIHWBUSNO = 2040
+SPC_PCIHWDEVNO = 2041
+SPC_PCIHWFNCNO = 2042
+SPC_PCIHWSLOTNO = 2043
+SPC_PCIEXPGENERATION = 2050
+SPC_PCIEXPLANES = 2051
+SPC_PCIEXPPAYLOAD = 2052
+SPC_PCIEXPREADREQUESTSIZE = 2053
+SPC_PCIEXPREADCOMPLBOUNDARY = 2054
+SPC_PXIHWSLOTNO = 2055
+SPC_PCISAMPLERATE = 2100
+SPC_PCIMEMSIZE = 2110
+SPC_PCIFEATURES = 2120
+SPC_PCIEXTFEATURES = 2121
+SPC_PCIINFOADR = 2200
+SPC_PCIINTERRUPT = 2300
+SPC_PCIBASEADR0 = 2400
+SPC_PCIBASEADR1 = 2401
+SPC_PCIREGION0 = 2410
+SPC_PCIREGION1 = 2411
+SPC_READTRGLVLCOUNT = 2500
+SPC_READIRCOUNT = 3000
+SPC_READUNIPOLAR0 = 3010
+SPC_READUNIPOLAR1 = 3020
+SPC_READUNIPOLAR2 = 3030
+SPC_READUNIPOLAR3 = 3040
+SPC_READMAXOFFSET = 3100
+SPC_READAIFEATURES = 3101
+SPCM_AI_TERM = 0x00000001
+SPCM_AI_SE = 0x00000002
+SPCM_AI_DIFF = 0x00000004
+SPCM_AI_OFFSPERCENT = 0x00000008
+SPCM_AI_OFFSMV = 0x00000010
+SPCM_AI_OVERRANGEDETECT = 0x00000020
+SPCM_AI_DCCOUPLING = 0x00000040
+SPCM_AI_ACCOUPLING = 0x00000080
+SPCM_AI_LOWPASS = 0x00000100
+SPCM_AI_ACDC_OFFS_COMP = 0x00000200
+SPCM_AI_DIFFMUX = 0x00000400
+SPCM_AI_GLOBALLOWPASS = 0x00000800
+SPCM_AI_AUTOCALOFFS = 0x00001000
+SPCM_AI_AUTOCALGAIN = 0x00002000
+SPCM_AI_AUTOCALOFFSNOIN = 0x00004000
+SPCM_AI_HIGHIMP = 0x00008000
+SPCM_AI_LOWIMP = 0x00010000
+SPCM_AI_DIGITALLOWPASS = 0x00020000
+SPCM_AI_INDIVPULSEWIDTH = 0x00100000
+SPC_READAOFEATURES = 3102
+SPCM_AO_SE = 0x00000002
+SPCM_AO_DIFF = 0x00000004
+SPCM_AO_PROGFILTER = 0x00000008
+SPCM_AO_PROGOFFSET = 0x00000010
+SPCM_AO_PROGGAIN = 0x00000020
+SPCM_AO_PROGSTOPLEVEL = 0x00000040
+SPCM_AO_DOUBLEOUT = 0x00000080
+SPCM_AO_ENABLEOUT = 0x00000100
+SPC_READDIFEATURES = 3103
+SPCM_DI_TERM = 0x00000001
+SPCM_DI_SE = 0x00000002
+SPCM_DI_DIFF = 0x00000004
+SPCM_DI_PROGTHRESHOLD = 0x00000008
+SPCM_DI_HIGHIMP = 0x00000010
+SPCM_DI_LOWIMP = 0x00000020
+SPCM_DI_INDIVPULSEWIDTH = 0x00100000
+SPCM_DI_IOCHANNEL = 0x00200000
+SPC_READDOFEATURES = 3104
+SPCM_DO_SE = 0x00000002
+SPCM_DO_DIFF = 0x00000004
+SPCM_DO_PROGSTOPLEVEL = 0x00000008
+SPCM_DO_PROGOUTLEVELS = 0x00000010
+SPCM_DO_ENABLEMASK = 0x00000020
+SPCM_DO_IOCHANNEL = 0x00200000
+SPC_READCHGROUPING = 3110
+SPC_READAIPATHCOUNT = 3120
+SPC_READAIPATH = 3121
+SPCM_CUSTOMMOD = 3130
+SPCM_CUSTOMMOD_BASE_MASK = 0x000000FF
+SPCM_CUSTOMMOD_MODULE_MASK = 0x0000FF00
+SPCM_CUSTOMMOD_STARHUB_MASK = 0x00FF0000
+SPC_READRANGECH0_0 = 3200
+SPC_READRANGECH0_1 = 3201
+SPC_READRANGECH0_2 = 3202
+SPC_READRANGECH0_3 = 3203
+SPC_READRANGECH0_4 = 3204
+SPC_READRANGECH0_5 = 3205
+SPC_READRANGECH0_6 = 3206
+SPC_READRANGECH0_7 = 3207
+SPC_READRANGECH0_8 = 3208
+SPC_READRANGECH0_9 = 3209
+SPC_READRANGECH1_0 = 3300
+SPC_READRANGECH1_1 = 3301
+SPC_READRANGECH1_2 = 3302
+SPC_READRANGECH1_3 = 3303
+SPC_READRANGECH1_4 = 3304
+SPC_READRANGECH1_5 = 3305
+SPC_READRANGECH1_6 = 3306
+SPC_READRANGECH1_7 = 3307
+SPC_READRANGECH1_8 = 3308
+SPC_READRANGECH1_9 = 3309
+SPC_READRANGECH2_0 = 3400
+SPC_READRANGECH2_1 = 3401
+SPC_READRANGECH2_2 = 3402
+SPC_READRANGECH2_3 = 3403
+SPC_READRANGECH3_0 = 3500
+SPC_READRANGECH3_1 = 3501
+SPC_READRANGECH3_2 = 3502
+SPC_READRANGECH3_3 = 3503
+SPC_READRANGEMIN0 = 4000
+SPC_READRANGEMIN99 = 4099
+SPC_READRANGEMAX0 = 4100
+SPC_READRANGEMAX99 = 4199
+SPC_READOFFSMIN0 = 4200
+SPC_READOFFSMIN99 = 4299
+SPC_READOFFSMAX0 = 4300
+SPC_READOFFSMAX99 = 4399
+SPC_PCICOUNTER = 9000
+SPC_BUFFERPOS = 9010
+SPC_READAOGAINMIN = 9100
+SPC_READAOGAINMAX = 9110
+SPC_READAOOFFSETMIN = 9120
+SPC_READAOOFFSETMAX = 9130
+SPC_CARDMODE = 9500
+SPC_AVAILCARDMODES = 9501
+SPC_REC_STD_SINGLE = 0x00000001
+SPC_REC_STD_MULTI = 0x00000002
+SPC_REC_STD_GATE = 0x00000004
+SPC_REC_STD_ABA = 0x00000008
+SPC_REC_STD_SEGSTATS = 0x00010000
+SPC_REC_STD_AVERAGE = 0x00020000
+SPC_REC_STD_AVERAGE_16BIT = 0x00080000
+SPC_REC_STD_BOXCAR = 0x00800000
+SPC_REC_FIFO_SINGLE = 0x00000010
+SPC_REC_FIFO_MULTI = 0x00000020
+SPC_REC_FIFO_GATE = 0x00000040
+SPC_REC_FIFO_ABA = 0x00000080
+SPC_REC_FIFO_SEGSTATS = 0x00100000
+SPC_REC_FIFO_AVERAGE = 0x00200000
+SPC_REC_FIFO_AVERAGE_16BIT = 0x00400000
+SPC_REC_FIFO_BOXCAR = 0x01000000
+SPC_REC_FIFO_SINGLE_MONITOR = 0x02000000
+SPC_REP_STD_SINGLE = 0x00000100
+SPC_REP_STD_MULTI = 0x00000200
+SPC_REP_STD_GATE = 0x00000400
+SPC_REP_FIFO_SINGLE = 0x00000800
+SPC_REP_FIFO_MULTI = 0x00001000
+SPC_REP_FIFO_GATE = 0x00002000
+SPC_REP_STD_CONTINUOUS = 0x00004000
+SPC_REP_STD_SINGLERESTART = 0x00008000
+SPC_REP_STD_SEQUENCE = 0x00040000
+SPC_DEMOWAVEFORM = 9600
+SPC_AVAILDEMOWAVEFORMS = 9601
+SPCM_DEMOWAVEFORM_SINE = 0x00000001
+SPCM_DEMOWAVEFORM_RECT = 0x00000002
+SPCM_DEMOWAVEFORM_TRIANGLE = 0x00000004
+SPC_MEMSIZE = 10000
+SPC_SEGMENTSIZE = 10010
+SPC_LOOPS = 10020
+SPC_PRETRIGGER = 10030
+SPC_ABADIVIDER = 10040
+SPC_AVERAGES = 10050
+SPC_BOX_AVERAGES = 10060
+SPC_SEGSPLIT_START = 10070
+SPC_SEGSPLIT_PAUSE = 10071
+SPC_POSTTRIGGER = 10100
+SPC_STARTOFFSET = 10200
+SPC_AVAILMEMSIZE_MIN = 10201
+SPC_AVAILMEMSIZE_MAX = 10202
+SPC_AVAILMEMSIZE_STEP = 10203
+SPC_AVAILPOSTTRIGGER_MIN = 10204
+SPC_AVAILPOSTTRIGGER_MAX = 10205
+SPC_AVAILPOSTTRIGGER_STEP = 10206
+SPC_AVAILABADIVIDER_MIN = 10207
+SPC_AVAILABADIVIDER_MAX = 10208
+SPC_AVAILABADIVIDER_STEP = 10209
+SPC_AVAILLOOPS_MIN = 10210
+SPC_AVAILLOOPS_MAX = 10211
+SPC_AVAILLOOPS_STEP = 10212
+SPC_AVAILAVERAGES_MIN = 10220
+SPC_AVAILAVERAGES_MAX = 10221
+SPC_AVAILAVERAGES_STEP = 10222
+SPC_AVAILAVRGSEGSIZE_MIN = 10223
+SPC_AVAILAVRGSEGSIZE_MAX = 10224
+SPC_AVAILAVRGSEGSIZE_STEP = 10225
+SPC_AVAILAVERAGES16BIT_MIN = 10226
+SPC_AVAILAVERAGES16BIT_MAX = 10227
+SPC_AVAILAVERAGES16BIT_STEP = 10228
+SPC_AVAILAVRG16BITSEGSIZE_MIN = 10229
+SPC_AVAILAVRG16BITSEGSIZE_MAX = 10230
+SPC_AVAILAVRG16BITSEGSIZE_STEP = 10231
+SPC_AVAILBOXCARAVERAGES_MIN = 10232
+SPC_AVAILBOXCARAVERAGES_MAX = 10233
+SPC_AVAILBOXCARAVERAGES_STEPFACTOR = 10234
+SPC_CHENABLE = 11000
+SPC_CHCOUNT = 11001
+SPC_CHMODACOUNT = 11100
+SPC_CHMODBCOUNT = 11101
+CHANNEL0 = 0x00000001
+CHANNEL1 = 0x00000002
+CHANNEL2 = 0x00000004
+CHANNEL3 = 0x00000008
+CHANNEL4 = 0x00000010
+CHANNEL5 = 0x00000020
+CHANNEL6 = 0x00000040
+CHANNEL7 = 0x00000080
+CHANNEL8 = 0x00000100
+CHANNEL9 = 0x00000200
+CHANNEL10 = 0x00000400
+CHANNEL11 = 0x00000800
+CHANNEL12 = 0x00001000
+CHANNEL13 = 0x00002000
+CHANNEL14 = 0x00004000
+CHANNEL15 = 0x00008000
+CHANNEL16 = 0x00010000
+CHANNEL17 = 0x00020000
+CHANNEL18 = 0x00040000
+CHANNEL19 = 0x00080000
+CHANNEL20 = 0x00100000
+CHANNEL21 = 0x00200000
+CHANNEL22 = 0x00400000
+CHANNEL23 = 0x00800000
+CHANNEL24 = 0x01000000
+CHANNEL25 = 0x02000000
+CHANNEL26 = 0x04000000
+CHANNEL27 = 0x08000000
+CHANNEL28 = 0x10000000
+CHANNEL29 = 0x20000000
+CHANNEL30 = 0x40000000
+CHANNEL31 = 0x80000000
+CH0_8BITMODE = 65536
+CH0_16BIT = 1
+CH0_32BIT = 3
+CH1_16BIT = 4
+CH1_32BIT = 12
+MOD0_8BIT = 1
+MOD0_16BIT = 3
+MOD0_32BIT = 15
+MOD1_8BIT = 16
+MOD1_16BIT = 48
+MOD1_32BIT = 240
+SPC_CHROUTE0 = 11010
+SPC_CHROUTE1 = 11020
+SPC_BITENABLE = 11030
+SPC_SAMPLERATE = 20000
+SPC_SYNCCLOCK = 20005
+SPC_SAMPLERATE2 = 20010
+SPC_SR2 = 20020
+SPC_PLL_ENABLE = 20030
+SPC_PLL_ISLOCKED = 20031
+SPC_CLOCKDIV = 20040
+SPC_INTCLOCKDIV = 20041
+SPC_PXICLOCKDIV = 20042
+SPC_PLL_R = 20060
+SPC_PLL_F = 20061
+SPC_PLL_S = 20062
+SPC_PLL_DIV = 20063
+SPC_PXI_CLK_OUT = 20090
+SPC_EXTERNALCLOCK = 20100
+SPC_EXTERNOUT = 20110
+SPC_CLOCKOUT = 20110
+SPC_CLOCKOUTFREQUENCY = 20111
+SPC_CLOCK50OHM = 20120
+SPC_CLOCK110OHM = 20120
+SPC_CLOCK75OHM = 20120
+SPC_STROBE75OHM = 20121
+SPC_EXTERNRANGE = 20130
+SPC_EXTRANGESHDIRECT = 20131
+EXRANGE_NONE = 0
+EXRANGE_NOPLL = 1
+EXRANGE_SINGLE = 2
+EXRANGE_BURST_S = 4
+EXRANGE_BURST_M = 8
+EXRANGE_BURST_L = 16
+EXRANGE_BURST_XL = 32
+EXRANGE_LOW = 64
+EXRANGE_HIGH = 128
+EXRANGE_LOW_DPS = 256
+SPC_REFERENCECLOCK = 20140
+REFCLOCK_PXI = -1
+SPC_CLOCKMODE = 20200
+SPC_AVAILCLOCKMODES = 20201
+SPC_CM_INTPLL = 0x00000001
+SPC_CM_QUARTZ1 = 0x00000002
+SPC_CM_QUARTZ2 = 0x00000004
+SPC_CM_EXTERNAL = 0x00000008
+SPC_CM_EXTERNAL0 = 0x00000008
+SPC_CM_EXTDIVIDER = 0x00000010
+SPC_CM_EXTREFCLOCK = 0x00000020
+SPC_CM_PXIREFCLOCK = 0x00000040
+SPC_CM_SHDIRECT = 0x00000080
+SPC_CM_QUARTZ2_DIRSYNC = 0x00000100
+SPC_CM_QUARTZ1_DIRSYNC = 0x00000200
+SPC_CM_EXTERNAL1 = 0x00000400
+SPC_CM_SYNCINT = 0x01000000
+SPC_CM_SYNCEXT = 0x02000000
+SPC_CLOCK_READFEATURES = 20205
+SPC_CLOCK_READFEATURES0 = 20205
+SPC_CLOCK_READFEATURES1 = 20206
+SPCM_CKFEAT_TERM = 0x00000001
+SPCM_CKFEAT_HIGHIMP = 0x00000002
+SPCM_CKFEAT_DCCOUPLING = 0x00000004
+SPCM_CKFEAT_ACCOUPLING = 0x00000008
+SPCM_CKFEAT_SE = 0x00000010
+SPCM_CKFEAT_DIFF = 0x00000020
+SPCM_CKFEAT_PROGEDGE = 0x00000040
+SPCM_CKFEAT_LEVELPROG = 0x00000100
+SPCM_CKFEAT_PROGTHRESHOLD = 0x00000200
+SPCM_CKFEAT_PROGDELAY = 0x00000400
+SPC_BURSTSYSCLOCKMODE = 20210
+SPC_SYNCMASTERSYSCLOCKMODE = 20211
+SPC_CLOCK_SETUP_CHANGED = 20212
+SPC_CLOCK_AVAILDELAY_MIN = 20220
+SPC_CLOCK_AVAILDELAY_MAX = 20221
+SPC_CLOCK_AVAILDELAY_STEP = 20222
+SPC_CLOCK_DELAY = 20223
+SPC_AVAILCLOCKEDGES = 20224
+SPCM_EDGE_FALLING = 0x00000001
+SPCM_EDGE_RISING = 0x00000002
+SPCM_BOTH_EDGES = 0x00000004
+SPCM_EDGES_BOTH = 0x00000004
+SPC_CLOCK_EDGE = 20225
+SPC_CHANNELMUXINFO = 20300
+SPCM_MUX_NONE = 0x00000000
+SPCM_MUX_MUXONMOD = 0x00000001
+SPCM_MUX_INVERTCLKONMOD = 0x00000002
+SPCM_MUX_DLY = 0x00000003
+SPCM_MUX_DLYANDMUXONMOD = 0x00000004
+SPCM_MUX_MUXBETWEENMODS = 0x00000005
+SPCM_MUX_MUXONMOD2CH = 0x00000006
+SPCM_MUX_MAX4CH = 0x00000007
+SPC_OFFS0 = 30000
+SPC_AMP0 = 30010
+SPC_ACDC0 = 30020
+SPC_ACDC_OFFS_COMPENSATION0 = 30021
+SPC_50OHM0 = 30030
+SPC_DIFF0 = 30040
+SPC_DOUBLEOUT0 = 30041
+SPC_DIGITAL0 = 30050
+SPC_110OHM0 = 30060
+SPC_110OHM0L = 30060
+SPC_75OHM0 = 30060
+SPC_INOUT0 = 30070
+SPC_FILTER0 = 30080
+SPC_BANKSWITCH0 = 30081
+SPC_PATH0 = 30090
+SPC_ENABLEOUT0 = 30091
+SPC_OFFS1 = 30100
+SPC_AMP1 = 30110
+SPC_ACDC1 = 30120
+SPC_ACDC_OFFS_COMPENSATION1 = 30121
+SPC_50OHM1 = 30130
+SPC_DIFF1 = 30140
+SPC_DOUBLEOUT1 = 30141
+SPC_DIGITAL1 = 30150
+SPC_110OHM1 = 30160
+SPC_110OHM0H = 30160
+SPC_75OHM1 = 30160
+SPC_INOUT1 = 30170
+SPC_FILTER1 = 30180
+SPC_BANKSWITCH1 = 30181
+SPC_PATH1 = 30190
+SPC_ENABLEOUT1 = 30191
+SPC_OFFS2 = 30200
+SPC_AMP2 = 30210
+SPC_ACDC2 = 30220
+SPC_ACDC_OFFS_COMPENSATION2 = 30221
+SPC_50OHM2 = 30230
+SPC_DIFF2 = 30240
+SPC_DOUBLEOUT2 = 30241
+SPC_110OHM2 = 30260
+SPC_110OHM1L = 30260
+SPC_75OHM2 = 30260
+SPC_INOUT2 = 30270
+SPC_FILTER2 = 30280
+SPC_BANKSWITCH2 = 30281
+SPC_PATH2 = 30290
+SPC_ENABLEOUT2 = 30291
+SPC_OFFS3 = 30300
+SPC_AMP3 = 30310
+SPC_ACDC3 = 30320
+SPC_ACDC_OFFS_COMPENSATION3 = 30321
+SPC_50OHM3 = 30330
+SPC_DIFF3 = 30340
+SPC_DOUBLEOUT3 = 30341
+SPC_110OHM3 = 30360
+SPC_110OHM1H = 30360
+SPC_75OHM3 = 30360
+SPC_INOUT3 = 30370
+SPC_FILTER3 = 30380
+SPC_BANKSWITCH3 = 30381
+SPC_PATH3 = 30390
+SPC_ENABLEOUT3 = 30391
+SPC_OFFS4 = 30400
+SPC_AMP4 = 30410
+SPC_ACDC4 = 30420
+SPC_50OHM4 = 30430
+SPC_DIFF4 = 30440
+SPC_DOUBLEOUT4 = 30441
+SPC_FILTER4 = 30480
+SPC_ENABLEOUT4 = 30491
+SPC_PATH4 = 30490
+SPC_OFFS5 = 30500
+SPC_AMP5 = 30510
+SPC_ACDC5 = 30520
+SPC_50OHM5 = 30530
+SPC_DIFF5 = 30540
+SPC_DOUBLEOUT5 = 30541
+SPC_FILTER5 = 30580
+SPC_ENABLEOUT5 = 30591
+SPC_PATH5 = 30590
+SPC_OFFS6 = 30600
+SPC_AMP6 = 30610
+SPC_ACDC6 = 30620
+SPC_50OHM6 = 30630
+SPC_DIFF6 = 30640
+SPC_DOUBLEOUT6 = 30641
+SPC_FILTER6 = 30680
+SPC_ENABLEOUT6 = 30691
+SPC_PATH6 = 30690
+SPC_OFFS7 = 30700
+SPC_AMP7 = 30710
+SPC_ACDC7 = 30720
+SPC_50OHM7 = 30730
+SPC_DIFF7 = 30740
+SPC_DOUBLEOUT7 = 30741
+SPC_FILTER7 = 30780
+SPC_ENABLEOUT7 = 30791
+SPC_PATH7 = 30790
+SPC_OFFS8 = 30800
+SPC_AMP8 = 30810
+SPC_ACDC8 = 30820
+SPC_50OHM8 = 30830
+SPC_DIFF8 = 30840
+SPC_PATH8 = 30890
+SPC_OFFS9 = 30900
+SPC_AMP9 = 30910
+SPC_ACDC9 = 30920
+SPC_50OHM9 = 30930
+SPC_DIFF9 = 30940
+SPC_PATH9 = 30990
+SPC_OFFS10 = 31000
+SPC_AMP10 = 31010
+SPC_ACDC10 = 31020
+SPC_50OHM10 = 31030
+SPC_DIFF10 = 31040
+SPC_PATH10 = 31090
+SPC_OFFS11 = 31100
+SPC_AMP11 = 31110
+SPC_ACDC11 = 31120
+SPC_50OHM11 = 31130
+SPC_DIFF11 = 31140
+SPC_PATH11 = 31190
+SPC_OFFS12 = 31200
+SPC_AMP12 = 31210
+SPC_ACDC12 = 31220
+SPC_50OHM12 = 31230
+SPC_DIFF12 = 31240
+SPC_PATH12 = 31290
+SPC_OFFS13 = 31300
+SPC_AMP13 = 31310
+SPC_ACDC13 = 31320
+SPC_50OHM13 = 31330
+SPC_DIFF13 = 31340
+SPC_PATH13 = 31390
+SPC_OFFS14 = 31400
+SPC_AMP14 = 31410
+SPC_ACDC14 = 31420
+SPC_50OHM14 = 31430
+SPC_DIFF14 = 31440
+SPC_PATH14 = 31490
+SPC_OFFS15 = 31500
+SPC_AMP15 = 31510
+SPC_ACDC15 = 31520
+SPC_50OHM15 = 31530
+SPC_DIFF15 = 31540
+SPC_PATH15 = 31590
+SPC_110OHMTRIGGER = 30400
+SPC_110OHMCLOCK = 30410
+AMP_BI200 = 200
+AMP_BI500 = 500
+AMP_BI1000 = 1000
+AMP_BI2000 = 2000
+AMP_BI2500 = 2500
+AMP_BI4000 = 4000
+AMP_BI5000 = 5000
+AMP_BI10000 = 10000
+AMP_UNI400 = 100400
+AMP_UNI1000 = 101000
+AMP_UNI2000 = 102000
+SPC_TRIGGERMODE = 40000
+SPC_TRIG_OUTPUT = 40100
+SPC_TRIGGEROUT = 40100
+SPC_TRIG_TERM = 40110
+SPC_TRIG_TERM0 = 40110
+SPC_TRIGGER50OHM = 40110
+SPC_TRIGGER110OHM0 = 40110
+SPC_TRIGGER75OHM0 = 40110
+SPC_TRIG_TERM1 = 40111
+SPC_TRIGGER110OHM1 = 40111
+SPC_TRIG_EXT0_ACDC = 40120
+SPC_TRIG_EXT1_ACDC = 40121
+SPC_TRIG_EXT2_ACDC = 40122
+SPC_TRIGGERMODE0 = 40200
+SPC_TRIGGERMODE1 = 40201
+SPC_TRIGGERMODE2 = 40202
+SPC_TRIGGERMODE3 = 40203
+SPC_TRIGGERMODE4 = 40204
+SPC_TRIGGERMODE5 = 40205
+SPC_TRIGGERMODE6 = 40206
+SPC_TRIGGERMODE7 = 40207
+SPC_TRIGGERMODE8 = 40208
+SPC_TRIGGERMODE9 = 40209
+SPC_TRIGGERMODE10 = 40210
+SPC_TRIGGERMODE11 = 40211
+SPC_TRIGGERMODE12 = 40212
+SPC_TRIGGERMODE13 = 40213
+SPC_TRIGGERMODE14 = 40214
+SPC_TRIGGERMODE15 = 40215
+TM_SOFTWARE = 0
+TM_NOTRIGGER = 10
+TM_CHXPOS = 10000
+TM_CHXPOS_LP = 10001
+TM_CHXPOS_SP = 10002
+TM_CHXPOS_GS = 10003
+TM_CHXPOS_SS = 10004
+TM_CHXNEG = 10010
+TM_CHXNEG_LP = 10011
+TM_CHXNEG_SP = 10012
+TM_CHXNEG_GS = 10013
+TM_CHXNEG_SS = 10014
+TM_CHXOFF = 10020
+TM_CHXBOTH = 10030
+TM_CHXWINENTER = 10040
+TM_CHXWINENTER_LP = 10041
+TM_CHXWINENTER_SP = 10042
+TM_CHXWINLEAVE = 10050
+TM_CHXWINLEAVE_LP = 10051
+TM_CHXWINLEAVE_SP = 10052
+TM_CHXLOW = 10060
+TM_CHXHIGH = 10061
+TM_CHXINWIN = 10062
+TM_CHXOUTWIN = 10063
+TM_CHXSPIKE = 10064
+TM_CH0POS = 10000
+TM_CH0NEG = 10010
+TM_CH0OFF = 10020
+TM_CH0BOTH = 10030
+TM_CH1POS = 10100
+TM_CH1NEG = 10110
+TM_CH1OFF = 10120
+TM_CH1BOTH = 10130
+TM_CH2POS = 10200
+TM_CH2NEG = 10210
+TM_CH2OFF = 10220
+TM_CH2BOTH = 10230
+TM_CH3POS = 10300
+TM_CH3NEG = 10310
+TM_CH3OFF = 10320
+TM_CH3BOTH = 10330
+TM_TTLPOS = 20000
+TM_TTLHIGH_LP = 20001
+TM_TTLHIGH_SP = 20002
+TM_TTLNEG = 20010
+TM_TTLLOW_LP = 20011
+TM_TTLLOW_SP = 20012
+TM_TTL = 20020
+TM_TTLBOTH = 20030
+TM_TTLBOTH_LP = 20031
+TM_TTLBOTH_SP = 20032
+TM_CHANNEL = 20040
+TM_TTLHIGH = 20050
+TM_TTLLOW = 20051
+TM_PATTERN = 21000
+TM_PATTERN_LP = 21001
+TM_PATTERN_SP = 21002
+TM_PATTERNANDEDGE = 22000
+TM_PATTERNANDEDGE_LP = 22001
+TM_PATTERNANDEDGE_SP = 22002
+TM_GATELOW = 30000
+TM_GATEHIGH = 30010
+TM_GATEPATTERN = 30020
+TM_CHOR = 35000
+TM_CHAND = 35010
+TM_CHORTTLPOS = 35020
+TM_CHORTTLNEG = 35021
+SPC_PXITRGOUT = 40300
+PTO_OFF = 0
+PTO_LINE0 = 1
+PTO_LINE1 = 2
+PTO_LINE2 = 3
+PTO_LINE3 = 4
+PTO_LINE4 = 5
+PTO_LINE5 = 6
+PTO_LINE6 = 7
+PTO_LINE7 = 8
+PTO_LINESTAR = 9
+SPC_PXITRGOUT_AVAILABLE = 40301
+SPC_PXISTARTRG_DIVRST_OUT = 40302
+SPC_PXISTARTRG_DIVRST_OUT_AVAILABLE = 40303
+SPC_PXISTARTRG_OUT = 40304
+PSTO_LINESTAR0 = 0x00000001
+PSTO_LINESTAR1 = 0x00000002
+PSTO_LINESTAR2 = 0x00000004
+PSTO_LINESTAR3 = 0x00000008
+PSTO_LINESTAR4 = 0x00000010
+PSTO_LINESTAR5 = 0x00000020
+PSTO_LINESTAR6 = 0x00000040
+PSTO_LINESTAR7 = 0x00000080
+PSTO_LINESTAR8 = 0x00000100
+PSTO_LINESTAR9 = 0x00000200
+PSTO_LINESTAR10 = 0x00000400
+PSTO_LINESTAR11 = 0x00000800
+PSTO_LINESTAR12 = 0x00001000
+PSTO_LINE0 = 0x00010000
+PSTO_LINE1 = 0x00020000
+PSTO_LINE2 = 0x00040000
+PSTO_LINE3 = 0x00080000
+PSTO_LINE4 = 0x00100000
+PSTO_LINE5 = 0x00200000
+PSTO_LINE6 = 0x00400000
+PSTO_LINE7 = 0x00800000
+SPC_PXISTARTRG_OUT_AVAILABLE = 40305
+SPC_PXITRGIN = 40310
+PTI_OFF = 0
+PTI_LINE0 = 1
+PTI_LINE1 = 2
+PTI_LINE2 = 4
+PTI_LINE3 = 8
+PTI_LINE4 = 16
+PTI_LINE5 = 32
+PTI_LINE6 = 64
+PTI_LINE7 = 128
+PTI_LINESTAR = 256
+SPC_PXITRGIN_AVAILABLE = 40311
+SPC_PXI_DIVIDER_RESET_IN = 40320
+SPC_PXI_DIVIDER_RESET_IN_AVAILABLE = 40321
+SPC_TRIG_AVAILORMASK = 40400
+SPC_TRIG_ORMASK = 40410
+SPC_TRIG_AVAILANDMASK = 40420
+SPC_TRIG_ANDMASK = 40430
+SPC_TMASK_NONE = 0x00000000
+SPC_TMASK_SOFTWARE = 0x00000001
+SPC_TMASK_EXT0 = 0x00000002
+SPC_TMASK_EXT1 = 0x00000004
+SPC_TMASK_EXT2 = 0x00000008
+SPC_TMASK_EXT3 = 0x00000010
+SPC_TMASK_EXT4 = 0x00000020
+SPC_TMASK_XIO0 = 0x00000100
+SPC_TMASK_XIO1 = 0x00000200
+SPC_TMASK_XIO2 = 0x00000400
+SPC_TMASK_XIO3 = 0x00000800
+SPC_TMASK_XIO4 = 0x00001000
+SPC_TMASK_XIO5 = 0x00002000
+SPC_TMASK_XIO6 = 0x00004000
+SPC_TMASK_XIO7 = 0x00008000
+SPC_TMASK_PXI0 = 0x00100000
+SPC_TMASK_PXI1 = 0x00200000
+SPC_TMASK_PXI2 = 0x00400000
+SPC_TMASK_PXI3 = 0x00800000
+SPC_TMASK_PXI4 = 0x01000000
+SPC_TMASK_PXI5 = 0x02000000
+SPC_TMASK_PXI6 = 0x04000000
+SPC_TMASK_PXI7 = 0x08000000
+SPC_TMASK_PXISTAR = 0x10000000
+SPC_TMASK_PXIDSTARB = 0x20000000
+SPC_TRIG_CH_AVAILORMASK0 = 40450
+SPC_TRIG_CH_AVAILORMASK1 = 40451
+SPC_TRIG_CH_ORMASK0 = 40460
+SPC_TRIG_CH_ORMASK1 = 40461
+SPC_TRIG_CH_AVAILANDMASK0 = 40470
+SPC_TRIG_CH_AVAILANDMASK1 = 40471
+SPC_TRIG_CH_ANDMASK0 = 40480
+SPC_TRIG_CH_ANDMASK1 = 40481
+SPC_TMASK0_NONE = 0x00000000
+SPC_TMASK0_CH0 = 0x00000001
+SPC_TMASK0_CH1 = 0x00000002
+SPC_TMASK0_CH2 = 0x00000004
+SPC_TMASK0_CH3 = 0x00000008
+SPC_TMASK0_CH4 = 0x00000010
+SPC_TMASK0_CH5 = 0x00000020
+SPC_TMASK0_CH6 = 0x00000040
+SPC_TMASK0_CH7 = 0x00000080
+SPC_TMASK0_CH8 = 0x00000100
+SPC_TMASK0_CH9 = 0x00000200
+SPC_TMASK0_CH10 = 0x00000400
+SPC_TMASK0_CH11 = 0x00000800
+SPC_TMASK0_CH12 = 0x00001000
+SPC_TMASK0_CH13 = 0x00002000
+SPC_TMASK0_CH14 = 0x00004000
+SPC_TMASK0_CH15 = 0x00008000
+SPC_TMASK0_CH16 = 0x00010000
+SPC_TMASK0_CH17 = 0x00020000
+SPC_TMASK0_CH18 = 0x00040000
+SPC_TMASK0_CH19 = 0x00080000
+SPC_TMASK0_CH20 = 0x00100000
+SPC_TMASK0_CH21 = 0x00200000
+SPC_TMASK0_CH22 = 0x00400000
+SPC_TMASK0_CH23 = 0x00800000
+SPC_TMASK0_CH24 = 0x01000000
+SPC_TMASK0_CH25 = 0x02000000
+SPC_TMASK0_CH26 = 0x04000000
+SPC_TMASK0_CH27 = 0x08000000
+SPC_TMASK0_CH28 = 0x10000000
+SPC_TMASK0_CH29 = 0x20000000
+SPC_TMASK0_CH30 = 0x40000000
+SPC_TMASK0_CH31 = 0x80000000
+SPC_TMASK1_NONE = 0x00000000
+SPC_TMASK1_CH32 = 0x00000001
+SPC_TMASK1_CH33 = 0x00000002
+SPC_TMASK1_CH34 = 0x00000004
+SPC_TMASK1_CH35 = 0x00000008
+SPC_TMASK1_CH36 = 0x00000010
+SPC_TMASK1_CH37 = 0x00000020
+SPC_TMASK1_CH38 = 0x00000040
+SPC_TMASK1_CH39 = 0x00000080
+SPC_TMASK1_CH40 = 0x00000100
+SPC_TMASK1_CH41 = 0x00000200
+SPC_TMASK1_CH42 = 0x00000400
+SPC_TMASK1_CH43 = 0x00000800
+SPC_TMASK1_CH44 = 0x00001000
+SPC_TMASK1_CH45 = 0x00002000
+SPC_TMASK1_CH46 = 0x00004000
+SPC_TMASK1_CH47 = 0x00008000
+SPC_TMASK1_CH48 = 0x00010000
+SPC_TMASK1_CH49 = 0x00020000
+SPC_TMASK1_CH50 = 0x00040000
+SPC_TMASK1_CH51 = 0x00080000
+SPC_TMASK1_CH52 = 0x00100000
+SPC_TMASK1_CH53 = 0x00200000
+SPC_TMASK1_CH54 = 0x00400000
+SPC_TMASK1_CH55 = 0x00800000
+SPC_TMASK1_CH56 = 0x01000000
+SPC_TMASK1_CH57 = 0x02000000
+SPC_TMASK1_CH58 = 0x04000000
+SPC_TMASK1_CH59 = 0x08000000
+SPC_TMASK1_CH60 = 0x10000000
+SPC_TMASK1_CH61 = 0x20000000
+SPC_TMASK1_CH62 = 0x40000000
+SPC_TMASK1_CH63 = 0x80000000
+SPC_TRIG_EXT_AVAILMODES = 40500
+SPC_TRIG_EXT0_AVAILMODES = 40500
+SPC_TRIG_EXT1_AVAILMODES = 40501
+SPC_TRIG_EXT2_AVAILMODES = 40502
+SPC_TRIG_EXT0_AVAILMODESOR = 40503
+SPC_TRIG_EXT1_AVAILMODESOR = 40504
+SPC_TRIG_EXT2_AVAILMODESOR = 40505
+SPC_TRIG_EXT0_AVAILMODESAND = 40506
+SPC_TRIG_EXT1_AVAILMODESAND = 40507
+SPC_TRIG_EXT2_AVAILMODESAND = 40508
+SPC_TRIG_EXT3_AVAILMODESAND = 40509
+SPC_TRIG_EXT0_MODE = 40510
+SPC_TRIG_EXT1_MODE = 40511
+SPC_TRIG_EXT2_MODE = 40512
+SPC_TRIG_EXT3_MODE = 40513
+SPC_TRIG_EXT3_AVAILMODES = 40514
+SPC_TRIG_EXT3_AVAILMODESOR = 40515
+SPC_TRIG_EXT4_AVAILMODES = 40516
+SPC_TRIG_EXT4_AVAILMODESOR = 40517
+SPC_TRIG_EXT4_AVAILMODESAND = 40518
+SPC_TRIG_EXT4_MODE = 40519
+SPC_TRIG_EXT0_READFEATURES = 40520
+SPC_TRIG_EXT1_READFEATURES = 40521
+SPC_TRIG_EXT2_READFEATURES = 40522
+SPC_TRIG_EXT3_READFEATURES = 40523
+SPC_TRIG_EXT4_READFEATURES = 40524
+SPCM_TRFEAT_TERM = 0x00000001
+SPCM_TRFEAT_HIGHIMP = 0x00000002
+SPCM_TRFEAT_DCCOUPLING = 0x00000004
+SPCM_TRFEAT_ACCOUPLING = 0x00000008
+SPCM_TRFEAT_SE = 0x00000010
+SPCM_TRFEAT_DIFF = 0x00000020
+SPCM_TRFEAT_LEVELPROG = 0x00000100
+SPCM_TRFEAT_PROGTHRESHOLD = 0x00000200
+SPC_LEGACY_X0_READFEATURES = 40530
+SPC_LEGACY_X1_READFEATURES = 40531
+SPC_LEGACY_X2_READFEATURES = 40532
+SPC_LEGACY_X3_READFEATURES = 40533
+SPC_LEGACY_X0_TERM = 40535
+SPC_LEGACY_X1_TERM = 40536
+SPC_LEGACY_X2_TERM = 40537
+SPC_LEGACY_X3_TERM = 40538
+SPC_TRIG_XIO_AVAILMODES = 40550
+SPC_TRIG_XIO_AVAILMODESOR = 40551
+SPC_TRIG_XIO_AVAILMODESAND = 40552
+SPC_TRIG_XIO0_MODE = 40560
+SPC_TRIG_XIO1_MODE = 40561
+SPC_TM_MODEMASK = 0x00FFFFFF
+SPC_TM_NONE = 0x00000000
+SPC_TM_POS = 0x00000001
+SPC_TM_NEG = 0x00000002
+SPC_TM_BOTH = 0x00000004
+SPC_TM_HIGH = 0x00000008
+SPC_TM_LOW = 0x00000010
+SPC_TM_WINENTER = 0x00000020
+SPC_TM_WINLEAVE = 0x00000040
+SPC_TM_INWIN = 0x00000080
+SPC_TM_OUTSIDEWIN = 0x00000100
+SPC_TM_SPIKE = 0x00000200
+SPC_TM_PATTERN = 0x00000400
+SPC_TM_STEEPPOS = 0x00000800
+SPC_TM_STEEPNEG = 0x00001000
+SPC_TM_EXTRAMASK = 0xFF000000
+SPC_TM_REARM = 0x01000000
+SPC_TM_PW_SMALLER = 0x02000000
+SPC_TM_PW_GREATER = 0x04000000
+SPC_TM_DOUBLEEDGE = 0x08000000
+SPC_TM_PULSESTRETCH = 0x10000000
+SPC_TM_HYSTERESIS = 0x20000000
+SPC_TRIG_PATTERN_AVAILMODES = 40580
+SPC_TRIG_PATTERN_MODE = 40590
+SPC_TRIG_CH_AVAILMODES = 40600
+SPC_TRIG_CH_AVAILMODESOR = 40601
+SPC_TRIG_CH_AVAILMODESAND = 40602
+SPC_TRIG_CH0_MODE = 40610
+SPC_TRIG_CH1_MODE = 40611
+SPC_TRIG_CH2_MODE = 40612
+SPC_TRIG_CH3_MODE = 40613
+SPC_TRIG_CH4_MODE = 40614
+SPC_TRIG_CH5_MODE = 40615
+SPC_TRIG_CH6_MODE = 40616
+SPC_TRIG_CH7_MODE = 40617
+SPC_TRIG_CH8_MODE = 40618
+SPC_TRIG_CH9_MODE = 40619
+SPC_TRIG_CH10_MODE = 40620
+SPC_TRIG_CH11_MODE = 40621
+SPC_TRIG_CH12_MODE = 40622
+SPC_TRIG_CH13_MODE = 40623
+SPC_TRIG_CH14_MODE = 40624
+SPC_TRIG_CH15_MODE = 40625
+SPC_TRIG_CH16_MODE = 40626
+SPC_TRIG_CH17_MODE = 40627
+SPC_TRIG_CH18_MODE = 40628
+SPC_TRIG_CH19_MODE = 40629
+SPC_TRIG_CH20_MODE = 40630
+SPC_TRIG_CH21_MODE = 40631
+SPC_TRIG_CH22_MODE = 40632
+SPC_TRIG_CH23_MODE = 40633
+SPC_TRIG_CH24_MODE = 40634
+SPC_TRIG_CH25_MODE = 40635
+SPC_TRIG_CH26_MODE = 40636
+SPC_TRIG_CH27_MODE = 40637
+SPC_TRIG_CH28_MODE = 40638
+SPC_TRIG_CH29_MODE = 40639
+SPC_TRIG_CH30_MODE = 40640
+SPC_TRIG_CH31_MODE = 40641
+SPC_TRIG_CH32_MODE = 40642
+SPC_TRIG_CH33_MODE = 40643
+SPC_TRIG_CH34_MODE = 40644
+SPC_TRIG_CH35_MODE = 40645
+SPC_TRIG_CH36_MODE = 40646
+SPC_TRIG_CH37_MODE = 40647
+SPC_TRIG_CH38_MODE = 40648
+SPC_TRIG_CH39_MODE = 40649
+SPC_TRIG_CH40_MODE = 40650
+SPC_TRIG_CH41_MODE = 40651
+SPC_TRIG_CH42_MODE = 40652
+SPC_TRIG_CH43_MODE = 40653
+SPC_TRIG_CH44_MODE = 40654
+SPC_TRIG_CH45_MODE = 40655
+SPC_TRIG_CH46_MODE = 40656
+SPC_TRIG_CH47_MODE = 40657
+SPC_TRIG_CH48_MODE = 40658
+SPC_TRIG_CH49_MODE = 40659
+SPC_TRIG_CH50_MODE = 40660
+SPC_TRIG_CH51_MODE = 40661
+SPC_TRIG_CH52_MODE = 40662
+SPC_TRIG_CH53_MODE = 40663
+SPC_TRIG_CH54_MODE = 40664
+SPC_TRIG_CH55_MODE = 40665
+SPC_TRIG_CH56_MODE = 40666
+SPC_TRIG_CH57_MODE = 40667
+SPC_TRIG_CH58_MODE = 40668
+SPC_TRIG_CH59_MODE = 40669
+SPC_TRIG_CH60_MODE = 40670
+SPC_TRIG_CH61_MODE = 40671
+SPC_TRIG_CH62_MODE = 40672
+SPC_TRIG_CH63_MODE = 40673
+SPC_TRIG_AVAILDELAY = 40800
+SPC_TRIG_AVAILDELAY_STEP = 40801
+SPC_TRIG_DELAY = 40810
+SPC_TRIG_AVAILHOLDOFF = 40802
+SPC_TRIG_AVAILHOLDOFF_STEP = 40803
+SPC_TRIG_HOLDOFF = 40811
+SPC_SINGLESHOT = 41000
+SPC_OUTONTRIGGER = 41100
+SPC_RESTARTCONT = 41200
+SPC_SINGLERESTART = 41300
+SPC_TRIGGERLEVEL = 42000
+SPC_TRIGGERLEVEL0 = 42000
+SPC_TRIGGERLEVEL1 = 42001
+SPC_TRIGGERLEVEL2 = 42002
+SPC_TRIGGERLEVEL3 = 42003
+SPC_TRIGGERLEVEL4 = 42004
+SPC_TRIGGERLEVEL5 = 42005
+SPC_TRIGGERLEVEL6 = 42006
+SPC_TRIGGERLEVEL7 = 42007
+SPC_TRIGGERLEVEL8 = 42008
+SPC_TRIGGERLEVEL9 = 42009
+SPC_TRIGGERLEVEL10 = 42010
+SPC_TRIGGERLEVEL11 = 42011
+SPC_TRIGGERLEVEL12 = 42012
+SPC_TRIGGERLEVEL13 = 42013
+SPC_TRIGGERLEVEL14 = 42014
+SPC_TRIGGERLEVEL15 = 42015
+SPC_AVAILHIGHLEVEL_MIN = 41997
+SPC_AVAILHIGHLEVEL_MAX = 41998
+SPC_AVAILHIGHLEVEL_STEP = 41999
+SPC_HIGHLEVEL0 = 42000
+SPC_HIGHLEVEL1 = 42001
+SPC_HIGHLEVEL2 = 42002
+SPC_HIGHLEVEL3 = 42003
+SPC_HIGHLEVEL4 = 42004
+SPC_HIGHLEVEL5 = 42005
+SPC_HIGHLEVEL6 = 42006
+SPC_HIGHLEVEL7 = 42007
+SPC_HIGHLEVEL8 = 42008
+SPC_HIGHLEVEL9 = 42009
+SPC_HIGHLEVEL10 = 42010
+SPC_HIGHLEVEL11 = 42011
+SPC_HIGHLEVEL12 = 42012
+SPC_HIGHLEVEL13 = 42013
+SPC_HIGHLEVEL14 = 42014
+SPC_HIGHLEVEL15 = 42015
+SPC_AVAILLOWLEVEL_MIN = 42097
+SPC_AVAILLOWLEVEL_MAX = 42098
+SPC_AVAILLOWLEVEL_STEP = 42099
+SPC_LOWLEVEL0 = 42100
+SPC_LOWLEVEL1 = 42101
+SPC_LOWLEVEL2 = 42102
+SPC_LOWLEVEL3 = 42103
+SPC_LOWLEVEL4 = 42104
+SPC_LOWLEVEL5 = 42105
+SPC_LOWLEVEL6 = 42106
+SPC_LOWLEVEL7 = 42107
+SPC_LOWLEVEL8 = 42108
+SPC_LOWLEVEL9 = 42109
+SPC_LOWLEVEL10 = 42110
+SPC_LOWLEVEL11 = 42111
+SPC_LOWLEVEL12 = 42112
+SPC_LOWLEVEL13 = 42113
+SPC_LOWLEVEL14 = 42114
+SPC_LOWLEVEL15 = 42115
+SPC_TRIG_CH0_LEVEL0 = 42200
+SPC_TRIG_CH1_LEVEL0 = 42201
+SPC_TRIG_CH2_LEVEL0 = 42202
+SPC_TRIG_CH3_LEVEL0 = 42203
+SPC_TRIG_CH4_LEVEL0 = 42204
+SPC_TRIG_CH5_LEVEL0 = 42205
+SPC_TRIG_CH6_LEVEL0 = 42206
+SPC_TRIG_CH7_LEVEL0 = 42207
+SPC_TRIG_CH8_LEVEL0 = 42208
+SPC_TRIG_CH9_LEVEL0 = 42209
+SPC_TRIG_CH10_LEVEL0 = 42210
+SPC_TRIG_CH11_LEVEL0 = 42211
+SPC_TRIG_CH12_LEVEL0 = 42212
+SPC_TRIG_CH13_LEVEL0 = 42213
+SPC_TRIG_CH14_LEVEL0 = 42214
+SPC_TRIG_CH15_LEVEL0 = 42215
+SPC_TRIG_CH0_LEVEL1 = 42300
+SPC_TRIG_CH1_LEVEL1 = 42301
+SPC_TRIG_CH2_LEVEL1 = 42302
+SPC_TRIG_CH3_LEVEL1 = 42303
+SPC_TRIG_CH4_LEVEL1 = 42304
+SPC_TRIG_CH5_LEVEL1 = 42305
+SPC_TRIG_CH6_LEVEL1 = 42306
+SPC_TRIG_CH7_LEVEL1 = 42307
+SPC_TRIG_CH8_LEVEL1 = 42308
+SPC_TRIG_CH9_LEVEL1 = 42309
+SPC_TRIG_CH10_LEVEL1 = 42310
+SPC_TRIG_CH11_LEVEL1 = 42311
+SPC_TRIG_CH12_LEVEL1 = 42312
+SPC_TRIG_CH13_LEVEL1 = 42313
+SPC_TRIG_CH14_LEVEL1 = 42314
+SPC_TRIG_CH15_LEVEL1 = 42315
+SPC_TRIG_EXT0_LEVEL0 = 42320
+SPC_TRIG_EXT1_LEVEL0 = 42321
+SPC_TRIG_EXT2_LEVEL0 = 42322
+SPC_TRIG_EXT0_LEVEL1 = 42330
+SPC_TRIG_EXT1_LEVEL1 = 42331
+SPC_TRIG_EXT2_LEVEL1 = 42332
+SPC_TRIG_EXT_AVAIL0_MIN = 42340
+SPC_TRIG_EXT_AVAIL0_MAX = 42341
+SPC_TRIG_EXT_AVAIL0_STEP = 42342
+SPC_TRIG_EXT_AVAIL1_MIN = 42345
+SPC_TRIG_EXT_AVAIL1_MAX = 42346
+SPC_TRIG_EXT_AVAIL1_STEP = 42347
+SPC_THRESHOLD0 = 42400
+SPC_THRESHOLD1 = 42401
+SPC_THRESHOLD2 = 42402
+SPC_THRESHOLD3 = 42403
+SPC_CLOCK_THRESHOLD = 42410
+SPC_TRIG_THRESHOLD = 42411
+SPC_X0X1_THRESHOLD = 42412
+SPC_STROBE_THRESHOLD = 42413
+SPC_AVAILTHRESHOLD_MIN = 42420
+SPC_AVAILTHRESHOLD_MAX = 42421
+SPC_AVAILTHRESHOLD_STEP = 42422
+SPC_CLOCK_AVAILTHRESHOLD_MIN = 42423
+SPC_CLOCK_AVAILTHRESHOLD_MAX = 42424
+SPC_CLOCK_AVAILTHRESHOLD_STEP = 42425
+SPC_TRIG_AVAILTHRESHOLD_MIN = 42426
+SPC_TRIG_AVAILTHRESHOLD_MAX = 42427
+SPC_TRIG_AVAILTHRESHOLD_STEP = 42428
+SPC_TRIGGERPATTERN = 43000
+SPC_TRIGGERPATTERN0 = 43000
+SPC_TRIGGERPATTERN1 = 43001
+SPC_TRIGGERMASK = 43100
+SPC_TRIGGERMASK0 = 43100
+SPC_TRIGGERMASK1 = 43101
+SPC_PULSEWIDTH = 44000
+SPC_PULSEWIDTH0 = 44000
+SPC_PULSEWIDTH1 = 44001
+SPC_TRIG_CH_AVAILPULSEWIDTH = 44100
+SPC_TRIG_CH_PULSEWIDTH = 44101
+SPC_TRIG_CH0_PULSEWIDTH = 44101
+SPC_TRIG_CH1_PULSEWIDTH = 44102
+SPC_TRIG_CH2_PULSEWIDTH = 44103
+SPC_TRIG_CH3_PULSEWIDTH = 44104
+SPC_TRIG_CH4_PULSEWIDTH = 44105
+SPC_TRIG_CH5_PULSEWIDTH = 44106
+SPC_TRIG_CH6_PULSEWIDTH = 44107
+SPC_TRIG_CH7_PULSEWIDTH = 44108
+SPC_TRIG_CH8_PULSEWIDTH = 44109
+SPC_TRIG_CH9_PULSEWIDTH = 44110
+SPC_TRIG_CH10_PULSEWIDTH = 44111
+SPC_TRIG_CH11_PULSEWIDTH = 44112
+SPC_TRIG_CH12_PULSEWIDTH = 44113
+SPC_TRIG_CH13_PULSEWIDTH = 44114
+SPC_TRIG_CH14_PULSEWIDTH = 44115
+SPC_TRIG_CH15_PULSEWIDTH = 44116
+SPC_TRIG_EXT_AVAILPULSEWIDTH = 44200
+SPC_TRIG_EXT0_PULSEWIDTH = 44210
+SPC_TRIG_EXT1_PULSEWIDTH = 44211
+SPC_TRIG_EXT2_PULSEWIDTH = 44212
+SPC_TRIG_EXT3_PULSEWIDTH = 44213
+SPC_READCLOCKDIVCOUNT = 44300
+SPC_CLOCKDIV0 = 44301
+SPC_CLOCKDIV1 = 44302
+SPC_CLOCKDIV2 = 44303
+SPC_CLOCKDIV3 = 44304
+SPC_CLOCKDIV4 = 44305
+SPC_CLOCKDIV5 = 44306
+SPC_CLOCKDIV6 = 44307
+SPC_CLOCKDIV7 = 44308
+SPC_CLOCKDIV8 = 44309
+SPC_CLOCKDIV9 = 44310
+SPC_CLOCKDIV10 = 44311
+SPC_CLOCKDIV11 = 44312
+SPC_CLOCKDIV12 = 44313
+SPC_CLOCKDIV13 = 44314
+SPC_CLOCKDIV14 = 44315
+SPC_CLOCKDIV15 = 44316
+SPC_CLOCKDIV16 = 44317
+SPC_READTROFFSET = 45000
+SPC_TRIGGEREDGE = 46000
+SPC_TRIGGEREDGE0 = 46000
+SPC_TRIGGEREDGE1 = 46001
+TE_POS = 10000
+TE_NEG = 10010
+TE_BOTH = 10020
+TE_NONE = 10030
+CH_TIMESTAMP = 9999
+SPC_TIMESTAMP_CMD = 47000
+TS_RESET = 0
+TS_MODE_DISABLE = 10
+TS_MODE_STARTRESET = 11
+TS_MODE_STANDARD = 12
+TS_MODE_REFCLOCK = 13
+TS_MODE_TEST5555 = 90
+TS_MODE_TESTAAAA = 91
+TS_MODE_ZHTEST = 92
+SPC_TIMESTAMP_AVAILMODES = 47001
+SPC_TSMODE_DISABLE = 0x00000000
+SPC_TS_RESET = 0x00000001
+SPC_TSMODE_STANDARD = 0x00000002
+SPC_TSMODE_STARTRESET = 0x00000004
+SPC_TS_RESET_WAITREFCLK = 0x00000008
+SPC_TSCNT_INTERNAL = 0x00000100
+SPC_TSCNT_REFCLOCKPOS = 0x00000200
+SPC_TSCNT_REFCLOCKNEG = 0x00000400
+SPC_TSFEAT_NONE = 0x00000000
+SPC_TSFEAT_STORE1STABA = 0x00010000
+SPC_TSFEAT_INCRMODE = 0x00020000
+SPC_TSFEAT_INCRMODE12 = 0x00040000
+SPC_TSFEAT_TRGSRC = 0x00080000
+SPC_TSXIOACQ_DISABLE = 0x00000000
+SPC_TSXIOACQ_ENABLE = 0x00001000
+SPC_TSXIOINC_ENABLE = 0x00002000
+SPC_TSXIOINC12_ENABLE = 0x00004000
+SPC_TSMODE_MASK = 0x000000FF
+SPC_TSCNT_MASK = 0x00000F00
+SPC_TSFEAT_MASK = 0x000F0000
+SPC_TRGSRC_MASK_CH0 = 0x00000001
+SPC_TRGSRC_MASK_CH1 = 0x00000002
+SPC_TRGSRC_MASK_CH2 = 0x00000004
+SPC_TRGSRC_MASK_CH3 = 0x00000008
+SPC_TRGSRC_MASK_CH4 = 0x00000010
+SPC_TRGSRC_MASK_CH5 = 0x00000020
+SPC_TRGSRC_MASK_CH6 = 0x00000040
+SPC_TRGSRC_MASK_CH7 = 0x00000080
+SPC_TRGSRC_MASK_EXT0 = 0x00000100
+SPC_TRGSRC_MASK_EXT1 = 0x00000200
+SPC_TRGSRC_MASK_FORCE = 0x00000400
+SPC_TRGSRC_MASK_PXI0 = 0x00010000
+SPC_TRGSRC_MASK_PXI1 = 0x00020000
+SPC_TRGSRC_MASK_PXI2 = 0x00040000
+SPC_TRGSRC_MASK_PXI3 = 0x00080000
+SPC_TRGSRC_MASK_PXI4 = 0x00100000
+SPC_TRGSRC_MASK_PXI5 = 0x00200000
+SPC_TRGSRC_MASK_PXI6 = 0x00400000
+SPC_TRGSRC_MASK_PXI7 = 0x00800000
+SPC_TRGSRC_MASK_PXISTAR = 0x01000000
+SPC_TRGSRC_MASK_PXIDSTARB = 0x02000000
+SPC_TRGSRC_MASK_X0 = 0x10000000
+SPC_TRGSRC_MASK_X1 = 0x20000000
+SPC_TRGSRC_MASK_X2 = 0x40000000
+SPC_TRGSRC_MASK_X3 = 0x80000000
+SPC_TIMESTAMP_STATUS = 47010
+TS_FIFO_EMPTY = 0
+TS_FIFO_LESSHALF = 1
+TS_FIFO_MOREHALF = 2
+TS_FIFO_OVERFLOW = 3
+SPC_TIMESTAMP_COUNT = 47020
+SPC_TIMESTAMP_STARTTIME = 47030
+SPC_TIMESTAMP_STARTDATE = 47031
+SPC_TIMESTAMP_FIFO = 47040
+SPC_TIMESTAMP_TIMEOUT = 47045
+SPC_TIMESTAMP_RESETMODE = 47050
+TS_RESET_POS = 10
+TS_RESET_NEG = 20
+SPC_XIO_DIRECTION = 47100
+XD_CH0_INPUT = 0
+XD_CH0_OUTPUT = 1
+XD_CH1_INPUT = 0
+XD_CH1_OUTPUT = 2
+XD_CH2_INPUT = 0
+XD_CH2_OUTPUT = 4
+SPC_XIO_DIGITALIO = 47110
+SPC_XIO_ANALOGOUT0 = 47120
+SPC_XIO_ANALOGOUT1 = 47121
+SPC_XIO_ANALOGOUT2 = 47122
+SPC_XIO_ANALOGOUT3 = 47123
+SPC_XIO_WRITEDACS = 47130
+SPCM_LEGACY_X0_MODE = 47200
+SPCM_LEGACY_X1_MODE = 47201
+SPCM_LEGACY_X2_MODE = 47202
+SPCM_LEGACY_X3_MODE = 47203
+SPCM_LEGACY_X0_AVAILMODES = 47210
+SPCM_LEGACY_X1_AVAILMODES = 47211
+SPCM_LEGACY_X2_AVAILMODES = 47212
+SPCM_LEGACY_X3_AVAILMODES = 47213
+SPCM_XMODE_DISABLE = 0x00000000
+SPCM_XMODE_ASYNCIN = 0x00000001
+SPCM_XMODE_ASYNCOUT = 0x00000002
+SPCM_XMODE_DIGIN = 0x00000004
+SPCM_XMODE_DIGOUT = 0x00000008
+SPCM_XMODE_TRIGIN = 0x00000010
+SPCM_XMODE_TRIGOUT = 0x00000020
+SPCM_XMODE_OVROUT = 0x00000040
+SPCM_XMODE_DIGIN2BIT = 0x00000080
+SPCM_XMODE_RUNSTATE = 0x00000100
+SPCM_XMODE_ARMSTATE = 0x00000200
+SPCM_XMODE_DIRECTTRIGOUT = 0x00000400
+SPCM_XMODE_DIRECTTRIGOUT_LR = 0x00000800
+SPCM_XMODE_REFCLKOUT = 0x00001000
+SPCM_XMODE_CONTOUTMARK = 0x00002000
+SPCM_XMODE_SYSCLKOUT = 0x00004000
+SPCM_XMODE_CLKOUT = 0x00008000
+SPCM_XMODE_SYNCARMSTATE = 0x00010000
+SPCM_XMODE_OPTDIGIN2BIT = 0x00020000
+SPCM_XMODE_OPTDIGIN4BIT = 0x00040000
+SPCM_XMODE_MODEMASK = 0x000FFFFF
+SPCM_XMODE_DIGOUTSRC_CH0 = 0x01000000
+SPCM_XMODE_DIGOUTSRC_CH1 = 0x02000000
+SPCM_XMODE_DIGOUTSRC_CH2 = 0x04000000
+SPCM_XMODE_DIGOUTSRC_CH3 = 0x08000000
+SPCM_XMODE_DIGOUTSRC_CH4 = 0x10000000
+SPCM_XMODE_DIGOUTSRC_CH5 = 0x20000000
+SPCM_XMODE_DIGOUTSRC_CH6 = 0x40000000
+SPCM_XMODE_DIGOUTSRC_CH7 = 0x80000000
+SPCM_XMODE_DIGOUTSRC_CHMASK = 0xFF000000
+SPCM_XMODE_DIGOUTSRC_BIT15 = 0x00100000
+SPCM_XMODE_DIGOUTSRC_BIT14 = 0x00200000
+SPCM_XMODE_DIGOUTSRC_BIT13 = 0x00400000
+SPCM_XMODE_DIGOUTSRC_BIT12 = 0x00800000
+SPCM_XMODE_DIGOUTSRC_BITMASK = 0x00F00000
+SPCM_XMODE_DIGOUTSRC_BIT15_downto_0 = 0x00F00000
+SPCM_XMODE_DIGOUTSRC_BIT15_downto_8 = 0x00700000
+SPCM_XX_ASYNCIO = 47220
+SPC_DIGMODE0 = 47250
+SPC_DIGMODE1 = 47251
+SPC_DIGMODE2 = 47252
+SPC_DIGMODE3 = 47253
+SPC_DIGMODE4 = 47254
+SPC_DIGMODE5 = 47255
+SPC_DIGMODE6 = 47256
+SPC_DIGMODE7 = 47257
+SPCM_DIGMODE_OFF = 0x00000000
+SPCM_DIGMODE_X0 = 0x21084000
+SPCM_DIGMODE_X1 = 0x294A5000
+SPCM_DIGMODE_X2 = 0x318C6000
+SPCM_DIGMODE_X3 = 0x39CE7000
+SPCM_DIGMODE_X4 = 0x84210001
+SPCM_DIGMODE_X5 = 0x8c631002
+SPCM_DIGMODE_X6 = 0x94a52004
+SPCM_DIGMODE_X7 = 0x9ce73008
+SPCM_DIGMODE_X8 = 0xa5294010
+SPCM_DIGMODE_X9 = 0xad6b5020
+SPCM_DIGMODE_X10 = 0xb5ad6040
+SPCM_DIGMODE_X11 = 0xbdef7080
+SPCM_DIGMODE_X12 = 0xc6318100
+SPCM_DIGMODE_X13 = 0xce739200
+SPCM_DIGMODE_X14 = 0xd6b5a400
+SPCM_DIGMODE_X15 = 0xdef7b800
+SPCM_DIGMODE_X16 = 0xe739c000
+SPCM_DIGMODE_X17 = 0xef7bd000
+SPCM_DIGMODE_X18 = 0xf7bde000
+SPCM_DIGMODE_X19 = 0xfffff000
+DIGMODEMASK_BIT15 = 0xF8000000
+DIGMODEMASK_BIT14 = 0x07C00000
+DIGMODEMASK_BIT13 = 0x003E0000
+DIGMODEMASK_BIT12 = 0x0001F000
+DIGMODEMASK_BIT11 = 0x00000800
+DIGMODEMASK_BIT10 = 0x00000400
+DIGMODEMASK_BIT9 = 0x00000200
+DIGMODEMASK_BIT8 = 0x00000100
+DIGMODEMASK_BIT7 = 0x00000080
+DIGMODEMASK_BIT6 = 0x00000040
+DIGMODEMASK_BIT5 = 0x00000020
+DIGMODEMASK_BIT4 = 0x00000010
+DIGMODEMASK_BIT3 = 0x00000008
+DIGMODEMASK_BIT2 = 0x00000004
+DIGMODEMASK_BIT1 = 0x00000002
+DIGMODEMASK_BIT0 = 0x00000001
+SPCM_DIGMODE_CHREPLACE = 0xFFBBCFFF
+SPC_PXITRG0_MODE = 47300
+SPC_PXITRG1_MODE = 47301
+SPC_PXITRG2_MODE = 47302
+SPC_PXITRG3_MODE = 47303
+SPC_PXITRG4_MODE = 47304
+SPC_PXITRG5_MODE = 47305
+SPC_PXITRG6_MODE = 47306
+SPC_PXITRG7_MODE = 47307
+SPC_PXISTAR_MODE = 47308
+SPC_PXIDSTARC_MODE = 47309
+SPC_PXITRG0_AVAILMODES = 47310
+SPC_PXITRG1_AVAILMODES = 47311
+SPC_PXITRG2_AVAILMODES = 47312
+SPC_PXITRG3_AVAILMODES = 47313
+SPC_PXITRG4_AVAILMODES = 47314
+SPC_PXITRG5_AVAILMODES = 47315
+SPC_PXITRG6_AVAILMODES = 47316
+SPC_PXITRG7_AVAILMODES = 47317
+SPC_PXISTAR_AVAILMODES = 47318
+SPC_PXIDSTARC_AVAILMODES = 47319
+SPC_PXITRG_ASYNCIO = 47320
+SPCM_PXITRGMODE_DISABLE = 0x00000000
+SPCM_PXITRGMODE_IN = 0x00000001
+SPCM_PXITRGMODE_ASYNCOUT = 0x00000002
+SPCM_PXITRGMODE_RUNSTATE = 0x00000004
+SPCM_PXITRGMODE_ARMSTATE = 0x00000008
+SPCM_PXITRGMODE_TRIGOUT = 0x00000010
+SPCM_PXITRGMODE_REFCLKOUT = 0x00000020
+SPCM_PXITRGMODE_CONTOUTMARK = 0x00000040
+SPC_STARHUB_STATUS = 48010
+SPC_STARHUB_ROUTE0 = 48100
+SPC_STARHUB_ROUTE99 = 48199
+SPC_SYNC_READ_SYNCCOUNT = 48990
+SPC_SYNC_READ_NUMCONNECTORS = 48991
+SPC_SYNC_READ_CARDIDX0 = 49000
+SPC_SYNC_READ_CARDIDX1 = 49001
+SPC_SYNC_READ_CARDIDX2 = 49002
+SPC_SYNC_READ_CARDIDX3 = 49003
+SPC_SYNC_READ_CARDIDX4 = 49004
+SPC_SYNC_READ_CARDIDX5 = 49005
+SPC_SYNC_READ_CARDIDX6 = 49006
+SPC_SYNC_READ_CARDIDX7 = 49007
+SPC_SYNC_READ_CARDIDX8 = 49008
+SPC_SYNC_READ_CARDIDX9 = 49009
+SPC_SYNC_READ_CARDIDX10 = 49010
+SPC_SYNC_READ_CARDIDX11 = 49011
+SPC_SYNC_READ_CARDIDX12 = 49012
+SPC_SYNC_READ_CARDIDX13 = 49013
+SPC_SYNC_READ_CARDIDX14 = 49014
+SPC_SYNC_READ_CARDIDX15 = 49015
+SPC_SYNC_READ_CABLECON0 = 49100
+SPC_SYNC_READ_CABLECON1 = 49101
+SPC_SYNC_READ_CABLECON2 = 49102
+SPC_SYNC_READ_CABLECON3 = 49103
+SPC_SYNC_READ_CABLECON4 = 49104
+SPC_SYNC_READ_CABLECON5 = 49105
+SPC_SYNC_READ_CABLECON6 = 49106
+SPC_SYNC_READ_CABLECON7 = 49107
+SPC_SYNC_READ_CABLECON8 = 49108
+SPC_SYNC_READ_CABLECON9 = 49109
+SPC_SYNC_READ_CABLECON10 = 49110
+SPC_SYNC_READ_CABLECON11 = 49111
+SPC_SYNC_READ_CABLECON12 = 49112
+SPC_SYNC_READ_CABLECON13 = 49113
+SPC_SYNC_READ_CABLECON14 = 49114
+SPC_SYNC_READ_CABLECON15 = 49115
+SPC_SYNC_ENABLEMASK = 49200
+SPC_SYNC_NOTRIGSYNCMASK = 49210
+SPC_SYNC_CLKMASK = 49220
+SPC_SYNC_MODE = 49230
+SPC_AVAILSYNC_MODES = 49231
+SPC_SYNC_STANDARD = 0x00000001
+SPC_SYNC_SYSTEMCLOCK = 0x00000002
+SPC_SYNC_SYSTEMCLOCKTRIG = 0x00000004
+SPC_SYNC_SYSTEMCLOCKTRIGN = 0x00000008
+SPC_SYNC_SYSTEM_TRIGADJUST = 49240
+SPC_ADJ_START = 50000
+SPC_ADJ_LOAD = 50000
+SPC_ADJ_SAVE = 50010
+ADJ_DEFAULT = 0
+ADJ_USER0 = 1
+ADJ_USER1 = 2
+ADJ_USER2 = 3
+ADJ_USER3 = 4
+ADJ_USER4 = 5
+ADJ_USER5 = 6
+ADJ_USER6 = 7
+ADJ_USER7 = 8
+SPC_ADJ_AUTOADJ = 50020
+ADJ_ALL = 0
+ADJ_CURRENT = 1
+ADJ_EXTERNAL = 2
+ADJ_1MOHM = 3
+ADJ_CURRENT_CLOCK = 4
+ADJ_CURRENT_IR = 8
+ADJ_OFFSET_ONLY = 16
+ADJ_SPECIAL_CLOCK = 32
+SPC_ADJ_SOURCE_CALLBACK = 50021
+SPC_ADJ_PROGRESS_CALLBACK = 50022
+SPC_ADJ_SET = 50030
+SPC_ADJ_FAILMASK = 50040
+SPC_ADJ_CALIBSOURCE = 50050
+ADJ_CALSRC_GAIN = 1
+ADJ_CALSRC_OFF = 0
+ADJ_CALSRC_GND = -1
+ADJ_CALSRC_GNDOFFS = -2
+ADJ_CALSRC_AC = 10
+ADJ_CALSRC_ADC = 11
+SPC_ADJ_CALIBVALUE0 = 50060
+SPC_ADJ_CALIBVALUE1 = 50061
+SPC_ADJ_CALIBVALUE2 = 50062
+SPC_ADJ_CALIBVALUE3 = 50063
+SPC_ADJ_CALIBVALUE4 = 50064
+SPC_ADJ_CALIBVALUE5 = 50065
+SPC_ADJ_CALIBVALUE6 = 50066
+SPC_ADJ_CALIBVALUE7 = 50067
+SPC_ADJ_OFFSET_CH0 = 50900
+SPC_ADJ_OFFSET_CH1 = 50901
+SPC_ADJ_OFFSET_CH2 = 50902
+SPC_ADJ_OFFSET_CH3 = 50903
+SPC_ADJ_OFFSET_CH4 = 50904
+SPC_ADJ_OFFSET_CH5 = 50905
+SPC_ADJ_OFFSET_CH6 = 50906
+SPC_ADJ_OFFSET_CH7 = 50907
+SPC_ADJ_OFFSET_CH8 = 50908
+SPC_ADJ_OFFSET_CH9 = 50909
+SPC_ADJ_OFFSET_CH10 = 50910
+SPC_ADJ_OFFSET_CH11 = 50911
+SPC_ADJ_OFFSET_CH12 = 50912
+SPC_ADJ_OFFSET_CH13 = 50913
+SPC_ADJ_OFFSET_CH14 = 50914
+SPC_ADJ_OFFSET_CH15 = 50915
+SPC_ADJ_GAIN_CH0 = 50916
+SPC_ADJ_GAIN_CH1 = 50917
+SPC_ADJ_GAIN_CH2 = 50918
+SPC_ADJ_GAIN_CH3 = 50919
+SPC_ADJ_GAIN_CH4 = 50920
+SPC_ADJ_GAIN_CH5 = 50921
+SPC_ADJ_GAIN_CH6 = 50922
+SPC_ADJ_GAIN_CH7 = 50923
+SPC_ADJ_GAIN_CH8 = 50924
+SPC_ADJ_GAIN_CH9 = 50925
+SPC_ADJ_GAIN_CH10 = 50926
+SPC_ADJ_GAIN_CH11 = 50927
+SPC_ADJ_GAIN_CH12 = 50928
+SPC_ADJ_GAIN_CH13 = 50929
+SPC_ADJ_GAIN_CH14 = 50930
+SPC_ADJ_GAIN_CH15 = 50931
+SPC_ADJ_OFFSET0 = 51000
+SPC_ADJ_OFFSET999 = 51999
+SPC_ADJ_GAIN0 = 52000
+SPC_ADJ_GAIN999 = 52999
+SPC_ADJ_CORRECT0 = 53000
+SPC_ADJ_OFFS_CORRECT0 = 53000
+SPC_ADJ_CORRECT999 = 53999
+SPC_ADJ_OFFS_CORRECT999 = 53999
+SPC_ADJ_XIOOFFS0 = 54000
+SPC_ADJ_XIOOFFS1 = 54001
+SPC_ADJ_XIOOFFS2 = 54002
+SPC_ADJ_XIOOFFS3 = 54003
+SPC_ADJ_XIOGAIN0 = 54010
+SPC_ADJ_XIOGAIN1 = 54011
+SPC_ADJ_XIOGAIN2 = 54012
+SPC_ADJ_XIOGAIN3 = 54013
+SPC_ADJ_GAIN_CORRECT0 = 55000
+SPC_ADJ_GAIN_CORRECT999 = 55999
+SPC_ADJ_OFFSCALIBCORRECT0 = 56000
+SPC_ADJ_OFFSCALIBCORRECT999 = 56999
+SPC_ADJ_GAINCALIBCORRECT0 = 57000
+SPC_ADJ_GAINCALIBCORRECT999 = 57999
+SPC_ADJ_ANALOGTRIGGER0 = 58000
+SPC_ADJ_ANALOGTRIGGER99 = 58099
+SPC_ADJ_CALIBSAMPLERATE0 = 58100
+SPC_ADJ_CALIBSAMPLERATE99 = 58199
+SPC_ADJ_CALIBSAMPLERATE_GAIN0 = 58200
+SPC_ADJ_CALIBSAMPLERATE_GAIN99 = 58299
+SPC_ADJ_REFCLOCK = 58300
+SPC_ADJ_STARHUB_REFCLOCK = 58301
+SPC_ADJ_END = 59999
+SPC_FIFO_BUFFERS = 60000
+SPC_FIFO_BUFLEN = 60010
+SPC_FIFO_BUFCOUNT = 60020
+SPC_FIFO_BUFMAXCNT = 60030
+SPC_FIFO_BUFADRCNT = 60040
+SPC_FIFO_BUFREADY = 60050
+SPC_FIFO_BUFFILLCNT = 60060
+SPC_FIFO_BUFADR0 = 60100
+SPC_FIFO_BUFADR1 = 60101
+SPC_FIFO_BUFADR2 = 60102
+SPC_FIFO_BUFADR3 = 60103
+SPC_FIFO_BUFADR4 = 60104
+SPC_FIFO_BUFADR5 = 60105
+SPC_FIFO_BUFADR6 = 60106
+SPC_FIFO_BUFADR7 = 60107
+SPC_FIFO_BUFADR8 = 60108
+SPC_FIFO_BUFADR9 = 60109
+SPC_FIFO_BUFADR10 = 60110
+SPC_FIFO_BUFADR11 = 60111
+SPC_FIFO_BUFADR12 = 60112
+SPC_FIFO_BUFADR13 = 60113
+SPC_FIFO_BUFADR14 = 60114
+SPC_FIFO_BUFADR15 = 60115
+SPC_FIFO_BUFADR255 = 60355
+SPC_FILTER = 100000
+SPC_READNUMFILTERS = 100001
+SPC_FILTERFREQUENCY0 = 100002
+SPC_FILTERFREQUENCY1 = 100003
+SPC_FILTERFREQUENCY2 = 100004
+SPC_FILTERFREQUENCY3 = 100005
+SPC_DIGITALBWFILTER = 100100
+SPC_PATTERNENABLE = 110000
+SPC_READDIGITAL = 110100
+SPC_DIGITALMODE0 = 110200
+SPC_DIGITALMODE1 = 110201
+SPC_DIGITALMODE2 = 110202
+SPC_DIGITALMODE3 = 110203
+SPC_DIGITALMODE4 = 110204
+SPC_DIGITALMODE5 = 110205
+SPC_DIGITALMODE6 = 110206
+SPC_DIGITALMODE7 = 110207
+SPC_DIGITALMODE_OFF = 0
+SPC_DIGITALMODE_2BIT = 1
+SPC_DIGITALMODE_4BIT = 2
+SPC_DIGITALMODE_CHREPLACE = 3
+SPC_MISCDAC0 = 200000
+SPC_MISCDAC1 = 200010
+SPC_FACTORYMODE = 200020
+SPC_DIRECTDAC = 200030
+SPC_NOTRIGSYNC = 200040
+SPC_DSPDIRECT = 200100
+SPC_DMAPHYSICALADR = 200110
+SPC_MICXCOMP_CLOSEBOARD = 200119
+SPC_MICXCOMPATIBILITYMODE = 200120
+SPC_TEST_FIFOSPEED = 200121
+SPC_RELOADDEMO = 200122
+SPC_OVERSAMPLINGFACTOR = 200123
+SPC_ISMAPPEDCARD = 200124
+SPCM_NOT_MAPPED = 0
+SPCM_LOCAL_MAPPED = 1
+SPCM_REMOTE_MAPPED = 2
+SPC_GETTHREADHANDLE = 200130
+SPC_GETKERNELHANDLE = 200131
+SPC_XYZMODE = 200200
+SPC_INVERTDATA = 200300
+SPC_GATEMARKENABLE = 200400
+SPC_GATE_LEN_ALIGNMENT = 200401
+SPC_CONTOUTMARK = 200450
+SPC_EXPANDINT32 = 200500
+SPC_NOPRETRIGGER = 200600
+SPC_RELAISWAITTIME = 200700
+SPC_DACWAITTIME = 200710
+SPC_DELAY_US = 200720
+SPC_ILAMODE = 200800
+SPC_NMDGMODE = 200810
+SPC_CKADHALF_OUTPUT = 200820
+SPC_LONGTRIG_OUTPUT = 200830
+SPC_STOREMODAENDOFSEGMENT = 200840
+SPC_COUNTERMODE = 200850
+SPC_CNTMOD_MASK = 0x0000000F
+SPC_CNTMOD_PARALLELDATA = 0x00000000
+SPC_CNTMOD_8BITCNT = 0x00000001
+SPC_CNTMOD_2x8BITCNT = 0x00000002
+SPC_CNTMOD_16BITCNT = 0x00000003
+SPC_CNT0_MASK = 0x000000F0
+SPC_CNT0_CNTONPOSEDGE = 0x00000000
+SPC_CNT0_CNTONNEGEDGE = 0x00000010
+SPC_CNT0_RESETHIGHLVL = 0x00000000
+SPC_CNT0_RESETLOWLVL = 0x00000020
+SPC_CNT0_STOPATMAX = 0x00000000
+SPC_CNT0_ROLLOVER = 0x00000040
+SPC_CNT1_MASK = 0x00000F00
+SPC_CNT1_CNTONPOSEDGE = 0x00000000
+SPC_CNT1_CNTONNEGEDGE = 0x00000100
+SPC_CNT1_RESETHIGHLVL = 0x00000000
+SPC_CNT1_RESETLOWLVL = 0x00000200
+SPC_CNT1_STOPATMAX = 0x00000000
+SPC_CNT1_ROLLOVER = 0x00000400
+SPC_CNTCMD_MASK = 0x0000F000
+SPC_CNTCMD_RESETCNT0 = 0x00001000
+SPC_CNTCMD_RESETCNT1 = 0x00002000
+SPC_ENHANCEDSTATUS = 200900
+SPC_ENHSTAT_OVERRANGE0 = 0x00000001
+SPC_ENHSTAT_OVERRANGE1 = 0x00000002
+SPC_ENHSTAT_OVERRANGE2 = 0x00000004
+SPC_ENHSTAT_OVERRANGE3 = 0x00000008
+SPC_ENHSTAT_OVERRANGE4 = 0x00000010
+SPC_ENHSTAT_OVERRANGE5 = 0x00000020
+SPC_ENHSTAT_OVERRANGE6 = 0x00000040
+SPC_ENHSTAT_OVERRANGE7 = 0x00000080
+SPC_ENHSTAT_COMPARATOR0 = 0x40000000
+SPC_ENHSTAT_COMPARATOR1 = 0x80000000
+SPC_ENHSTAT_COMPARATOR2 = 0x20000000
+SPC_ENHSTAT_TRGCOMPARATOR = 0x40000000
+SPC_ENHSTAT_CLKCOMPARATOR = 0x80000000
+SPC_TRIGGERCOUNTER = 200905
+SPC_FILLSIZEPROMILLE = 200910
+SPC_OVERRANGEBIT = 201000
+SPC_2CH8BITMODE = 201100
+SPC_12BITMODE = 201200
+SPC_HOLDLASTSAMPLE = 201300
+SPC_DATACONVERSION = 201400
+SPC_AVAILDATACONVERSION = 201401
+SPCM_DC_NONE = 0x00000000
+SPCM_DC_12BIT_TO_14BIT = 0x00000001
+SPCM_DC_16BIT_TO_14BIT = 0x00000002
+SPCM_DC_12BIT_TO_16BIT = 0x00000004
+SPCM_DC_14BIT_TO_16BIT = 0x00000008
+SPCM_DC_15BIT_TO_16BIT = 0x00000010
+SPCM_DC_13BIT_TO_16BIT = 0x00000020
+SPCM_DC_14BIT_TO_8BIT = 0x00000100
+SPCM_DC_16BIT_TO_8BIT = 0x00000200
+SPCM_DC_16BIT_TO_12BIT = 0x00000400
+SPCM_DC_TO_OFFSETBINARY = 0x00000800
+SPC_CARDIDENTIFICATION = 201500
+SPC_HANDSHAKE = 201600
+SPC_CKSYNC0 = 202000
+SPC_CKSYNC1 = 202001
+SPC_DISABLEMOD0 = 203000
+SPC_DISABLEMOD1 = 203010
+SPC_ENABLEOVERRANGECHECK = 204000
+SPC_OVERRANGESTATUS = 204010
+SPC_BITMODE = 205000
+SPC_READBACK = 206000
+SPC_AVAILSTOPLEVEL = 206009
+SPC_STOPLEVEL1 = 206010
+SPC_STOPLEVEL0 = 206020
+SPC_CH0_STOPLEVEL = 206020
+SPC_CH1_STOPLEVEL = 206021
+SPC_CH2_STOPLEVEL = 206022
+SPC_CH3_STOPLEVEL = 206023
+SPC_CH4_STOPLEVEL = 206024
+SPC_CH5_STOPLEVEL = 206025
+SPC_CH6_STOPLEVEL = 206026
+SPC_CH7_STOPLEVEL = 206027
+SPCM_STOPLVL_TRISTATE = 0x00000001
+SPCM_STOPLVL_LOW = 0x00000002
+SPCM_STOPLVL_HIGH = 0x00000004
+SPCM_STOPLVL_HOLDLAST = 0x00000008
+SPCM_STOPLVL_ZERO = 0x00000010
+SPCM_STOPLVL_CUSTOM = 0x00000020
+SPC_DIFFMODE = 206030
+SPC_DACADJUST = 206040
+SPC_CH0_CUSTOM_STOP = 206050
+SPC_CH1_CUSTOM_STOP = 206051
+SPC_CH2_CUSTOM_STOP = 206052
+SPC_CH3_CUSTOM_STOP = 206053
+SPC_CH4_CUSTOM_STOP = 206054
+SPC_CH5_CUSTOM_STOP = 206055
+SPC_CH6_CUSTOM_STOP = 206056
+SPC_CH7_CUSTOM_STOP = 206057
+SPC_AMP_MODE = 207000
+SPCM_FW_CTRL = 210000
+SPCM_FW_CTRL_GOLDEN = 210001
+SPCM_FW_CTRL_ACTIVE = 210002
+SPCM_FW_CLOCK = 210010
+SPCM_FW_CONFIG = 210020
+SPCM_FW_MODULEA = 210030
+SPCM_FW_MODULEB = 210031
+SPCM_FW_MODULEA_ACTIVE = 210032
+SPCM_FW_MODULEB_ACTIVE = 210033
+SPCM_FW_MODEXTRA = 210050
+SPCM_FW_MODEXTRA_ACTIVE = 210052
+SPCM_FW_POWER = 210060
+SPCM_FW_POWER_ACTIVE = 210062
+SPC_MULTI = 220000
+SPC_DOUBLEMEM = 220100
+SPC_MULTIMEMVALID = 220200
+SPC_BANK = 220300
+SPC_GATE = 220400
+SPC_RELOAD = 230000
+SPC_USEROUT = 230010
+SPC_WRITEUSER0 = 230100
+SPC_WRITEUSER1 = 230110
+SPC_READUSER0 = 230200
+SPC_READUSER1 = 230210
+SPC_MUX = 240000
+SPC_ADJADC = 241000
+SPC_ADJOFFS0 = 242000
+SPC_ADJOFFS1 = 243000
+SPC_ADJGAIN0 = 244000
+SPC_ADJGAIN1 = 245000
+SPC_READEPROM = 250000
+SPC_WRITEEPROM = 250010
+SPC_DIRECTIO = 260000
+SPC_DIRECT_MODA = 260010
+SPC_DIRECT_MODB = 260020
+SPC_DIRECT_EXT0 = 260030
+SPC_DIRECT_EXT1 = 260031
+SPC_DIRECT_EXT2 = 260032
+SPC_DIRECT_EXT3 = 260033
+SPC_DIRECT_EXT4 = 260034
+SPC_DIRECT_EXT5 = 260035
+SPC_DIRECT_EXT6 = 260036
+SPC_DIRECT_EXT7 = 260037
+SPC_MEMTEST = 270000
+SPC_NODMA = 275000
+SPC_NOCOUNTER = 275010
+SPC_NOSCATTERGATHER = 275020
+SPC_USER_RELAIS_OVERWRITE = 275030
+SPCM_URO_ENABLE = 0x80000000
+SPCM_URO_INVERT_10TO1REL = 0x00000001
+SPC_RUNINTENABLE = 290000
+SPC_XFERBUFSIZE = 295000
+SPC_CHLX = 295010
+SPC_SPECIALCLOCK = 295100
+SPC_PLL0_ICP = 295105
+SPCM_ICP0 = 0x00000000
+SPCM_ICP7 = 0x00000007
+SPC_STARTDELAY = 295110
+SPC_BASISTTLTRIG = 295120
+SPC_TIMEOUT = 295130
+SPC_SWL_INFO = 295140
+SPC_SWD_INFO = 295141
+SPC_SWD_DOWN = 295142
+SPC_SWL_EXTRAINFO = 295143
+SPC_SPECIALCLOCK_ADJUST0 = 295150
+SPC_SPECIALCLOCK_ADJUST1 = 295151
+SPC_SPECIALCLOCK_ADJUST2 = 295152
+SPC_SPECIALCLOCK_ADJUST3 = 295153
+SPCM_SPECIALCLOCK_ADJUST_SHIFT = 1000000
+SPC_REGACC_CONTMEM = 299000
+SPC_REGACC_MEMORYUSAGE = 299001
+SPC_REINITLOGSETTINGS = 299998
+SPC_LOGDLLCALLS = 299999
+SPC_FREQUENCE = 300000
+SPC_DELTAFREQUENCE = 300010
+SPC_PINHIGH = 300100
+SPC_PINLOW = 300110
+SPC_PINDELTA = 300120
+SPC_STOPLEVEL = 300200
+SPC_PINRELAIS = 300210
+SPC_EXTERNLEVEL = 300300
+SPC_COUNTER0 = 310000
+SPC_COUNTER1 = 310001
+SPC_COUNTER2 = 310002
+SPC_COUNTER3 = 310003
+SPC_COUNTER4 = 310004
+SPC_COUNTER5 = 310005
+SPC_MODE0 = 310100
+SPC_MODE1 = 310101
+SPC_MODE2 = 310102
+SPC_MODE3 = 310103
+SPC_MODE4 = 310104
+SPC_MODE5 = 310105
+CM_SINGLE = 1
+CM_MULTI = 2
+CM_POSEDGE = 4
+CM_NEGEDGE = 8
+CM_HIGHPULSE = 16
+CM_LOWPULSE = 32
+SPC_SEQUENCERESET = 320000
+SPC_SEQUENCEADD = 320010
+SEQ_IR_10000MV = 0
+SEQ_IR_5000MV = 1
+SEQ_IR_2000MV = 2
+SEQ_IR_1000MV = 3
+SEQ_IR_500MV = 4
+SEQ_CH0 = 0
+SEQ_CH1 = 8
+SEQ_CH2 = 16
+SEQ_CH3 = 24
+SEQ_CH4 = 32
+SEQ_CH5 = 40
+SEQ_CH6 = 48
+SEQ_CH7 = 56
+SEQ_CH8 = 64
+SEQ_CH9 = 72
+SEQ_CH10 = 80
+SEQ_CH11 = 88
+SEQ_CH12 = 96
+SEQ_CH13 = 104
+SEQ_CH14 = 112
+SEQ_CH15 = 120
+SEQ_TRIGGER = 128
+SEQ_START = 256
+SPC_CA_MODE = 330000
+CAMODE_OFF = 0
+CAMODE_CDM = 1
+CAMODE_KW = 2
+CAMODE_OT = 3
+CAMODE_CDMMUL = 4
+SPC_CA_TRIGDELAY = 330010
+SPC_CA_CKDIV = 330020
+SPC_CA_PULS = 330030
+SPC_CA_CKMUL = 330040
+SPC_CA_DREHZAHLFORMAT = 330050
+CADREH_4X4 = 0
+CADREH_1X16 = 1
+SPC_CA_KWINVERT = 330060
+SPC_CA_OUTA = 330100
+SPC_CA_OUTB = 330110
+CAOUT_TRISTATE = 0
+CAOUT_LOW = 1
+CAOUT_HIGH = 2
+CAOUT_CDM = 3
+CAOUT_OT = 4
+CAOUT_KW = 5
+CAOUT_TRIG = 6
+CAOUT_CLK = 7
+CAOUT_KW60 = 8
+CAOUT_KWGAP = 9
+CAOUT_TRDLY = 10
+CAOUT_INVERT = 16
+SPC_SEQMODE_STEPMEM0 = 340000
+SPC_SEQMODE_STEPMEM8191 = 348191
+SPCSEQ_SEGMENTMASK = 0x0000FFFF
+SPCSEQ_NEXTSTEPMASK = 0xFFFF0000
+SPCSEQ_LOOPMASK = 0x000FFFFF
+SPCSEQ_ENDLOOPALWAYS = 0x00000000
+SPCSEQ_ENDLOOPONTRIG = 0x40000000
+SPCSEQ_END = 0x80000000
+SPC_SEQMODE_AVAILMAXSEGMENT = 349900
+SPC_SEQMODE_AVAILMAXSTEPS = 349901
+SPC_SEQMODE_AVAILMAXLOOP = 349902
+SPC_SEQMODE_AVAILFEATURES = 349903
+SPC_SEQMODE_MAXSEGMENTS = 349910
+SPC_SEQMODE_WRITESEGMENT = 349920
+SPC_SEQMODE_STARTSTEP = 349930
+SPC_SEQMODE_SEGMENTSIZE = 349940
+SPC_SEQMODE_STATUS = 349950
+SEQSTAT_STEPCHANGE = 0x80000000
+SPC_NETBOX_TYPE = 400000
+NETBOX_SERIES_MASK = 0xFF000000
+NETBOX_FAMILY_MASK = 0x00FF0000
+NETBOX_SPEED_MASK = 0x0000FF00
+NETBOX_CHANNEL_MASK = 0x000000FF
+NETBOX_SERIES_DN2 = 0x02000000
+NETBOX_SERIES_DN6 = 0x06000000
+NETBOX_FAMILY_20 = 0x00200000
+NETBOX_FAMILY_22 = 0x00220000
+NETBOX_FAMILY_44 = 0x00440000
+NETBOX_FAMILY_46 = 0x00460000
+NETBOX_FAMILY_47 = 0x00470000
+NETBOX_FAMILY_48 = 0x00480000
+NETBOX_FAMILY_49 = 0x00490000
+NETBOX_FAMILY_59 = 0x00590000
+NETBOX_FAMILY_60 = 0x00600000
+NETBOX_FAMILY_65 = 0x00650000
+NETBOX_FAMILY_66 = 0x00660000
+NETBOX_FAMILY_8X = 0x00800000
+NETBOX_FAMILY_80 = 0x00800000
+NETBOX_FAMILY_81 = 0x00810000
+NETBOX_FAMILY_82 = 0x00820000
+NETBOX_FAMILY_83 = 0x00830000
+NETBOX_SPEED_1 = 0x00000100
+NETBOX_SPEED_2 = 0x00000200
+NETBOX_SPEED_3 = 0x00000300
+NETBOX_SPEED_4 = 0x00000400
+NETBOX_SPEED_5 = 0x00000500
+NETBOX_SPEED_6 = 0x00000600
+NETBOX_SPEED_7 = 0x00000700
+NETBOX_SPEED_8 = 0x00000800
+NETBOX_CHANNELS_2 = 0x00000002
+NETBOX_CHANNELS_4 = 0x00000004
+NETBOX_CHANNELS_6 = 0x00000006
+NETBOX_CHANNELS_8 = 0x00000008
+NETBOX_CHANNELS_10 = 0x0000000A
+NETBOX_CHANNELS_12 = 0x0000000C
+NETBOX_CHANNELS_16 = 0x00000010
+NETBOX_CHANNELS_20 = 0x00000014
+NETBOX_CHANNELS_24 = 0x00000018
+NETBOX_CHANNELS_32 = 0x00000020
+NETBOX_CHANNELS_40 = 0x00000028
+NETBOX_CHANNELS_48 = 0x00000030
+SPC_NETBOX_SERIALNO = 400001
+SPC_NETBOX_PRODUCTIONDATE = 400002
+SPC_NETBOX_HWVERSION = 400003
+SPC_NETBOX_SWVERSION = 400004
+SPC_NETBOX_FEATURES = 400005
+NETBOX_FEAT_DCPOWER = 0x1
+NETBOX_FEAT_BOOTATPOWERON = 0x2
+NETBOX_FEAT_EMBEDDEDSERVER = 0x4
+SPC_NETBOX_CUSTOM = 400006
+SPC_NETBOX_WAKEONLAN = 400007
+SPC_NETBOX_MACADDRESS = 400008
+SPC_NETBOX_LANIDFLASH = 400009
+SPC_NETBOX_TEMPERATURE = 400010
+SPC_NETBOX_SHUTDOWN = 400011
+SPC_NETBOX_RESTART = 400012
+SPC_NETBOX_FANSPEED0 = 400013
+SPC_NETBOX_FANSPEED1 = 400014
+SPC_NETBOX_TEMPERATURE_K = 400010
+SPC_NETBOX_TEMPERATURE_C = 400015
+SPC_NETBOX_TEMPERATURE_F = 400016
+SPC_NETBOX_TEMPERATURE1_K = 400017
+SPC_NETBOX_TEMPERATURE1_C = 400018
+SPC_NETBOX_TEMPERATURE1_F = 400019
+SPC_NETBOX_TEMPERATURE2_K = 400020
+SPC_NETBOX_TEMPERATURE2_C = 400021
+SPC_NETBOX_TEMPERATURE2_F = 400022
+SPC_MON_V_PCIE_BUS = 500000
+SPC_MON_V_CONNECTOR = 500001
+SPC_MON_CARD_PWRSOURCE = 500002
+CARD_PWRSOURCE_BUS = 0
+CARD_PWRSOURCE_CONNECTOR = 1
+SPC_MON_V_CARD_IN = 500003
+SPC_MON_I_CARD_IN = 500004
+SPC_MON_P_CARD_IN = 500005
+SPC_MON_V_3V3 = 500006
+SPC_MON_V_2V5 = 500007
+SPC_MON_V_CORE = 500008
+SPC_MON_V_AVTT = 500009
+SPC_MON_V_AVCC = 500010
+SPC_MON_V_MEMVCC = 500011
+SPC_MON_V_MEMVTT = 500012
+SPC_MON_V_CP_POS = 500013
+SPC_MON_V_CP_NEG = 500014
+SPC_MON_V_5VA = 500015
+SPC_MON_V_ADCA = 500016
+SPC_MON_V_ADCD = 500017
+SPC_MON_V_OP_POS = 500018
+SPC_MON_V_OP_NEG = 500019
+SPC_MON_V_COMP_NEG = 500020
+SPC_MON_V_COMP_POS = 500021
+SPC_MON_T_BASE_CTRL = 500022
+SPC_MON_T_MODULE_0 = 500023
+SPC_MON_T_MODULE_1 = 500024
+SPC_MON_TK_BASE_CTRL = 500022
+SPC_MON_TK_MODULE_0 = 500023
+SPC_MON_TK_MODULE_1 = 500024
+SPC_MON_TC_BASE_CTRL = 500025
+SPC_MON_TC_MODULE_0 = 500026
+SPC_MON_TC_MODULE_1 = 500027
+SPC_MON_TF_BASE_CTRL = 500028
+SPC_MON_TF_MODULE_0 = 500029
+SPC_MON_TF_MODULE_1 = 500030
+SPC_MON_V_1V8_BASE = 500031
+SPC_MON_V_1V8_MOD = 500032
+SPC_MON_V_MODA_0 = 500033
+SPC_MON_V_MODA_1 = 500034
+SPC_MON_V_MODB_0 = 500035
+SPC_MON_V_MODB_1 = 500037
+SPC_MON_TK_MODA_0 = 500023
+SPC_MON_TK_MODA_1 = 500038
+SPC_MON_TK_MODA_2 = 500039
+SPC_MON_TK_MODA_3 = 500040
+SPC_MON_TK_MODA_4 = 500041
+SPC_MON_TK_MODB_0 = 500024
+SPC_MON_TK_MODB_1 = 500042
+SPC_MON_TK_MODB_2 = 500043
+SPC_MON_TK_MODB_3 = 500044
+SPC_MON_TK_MODB_4 = 500045
+SPC_MON_TC_MODA_0 = 500026
+SPC_MON_TC_MODA_1 = 500046
+SPC_MON_TC_MODA_2 = 500047
+SPC_MON_TC_MODA_3 = 500048
+SPC_MON_TC_MODA_4 = 500049
+SPC_MON_TC_MODB_0 = 500027
+SPC_MON_TC_MODB_1 = 500050
+SPC_MON_TC_MODB_2 = 500051
+SPC_MON_TC_MODB_3 = 500052
+SPC_MON_TC_MODB_4 = 500053
+SPC_MON_TF_MODA_0 = 500029
+SPC_MON_TF_MODA_1 = 500054
+SPC_MON_TF_MODA_2 = 500055
+SPC_MON_TF_MODA_3 = 500056
+SPC_MON_TF_MODA_4 = 500057
+SPC_MON_TF_MODB_0 = 500030
+SPC_MON_TF_MODB_1 = 500058
+SPC_MON_TF_MODB_2 = 500059
+SPC_MON_TF_MODB_3 = 500060
+SPC_MON_TF_MODB_4 = 500061
+SPC_MON_I_MODA_0 = 500062
+SPC_MON_I_MODA_1 = 500063
+SPC_MON_I_MODA_2 = 500064
+SPC_MON_I_MODA_3 = 500065
+SPC_MON_I_MODB_0 = 500066
+SPC_MON_I_MODB_1 = 500067
+SPC_MON_I_MODB_2 = 500068
+SPC_MON_I_MODB_3 = 500069
+SPC_MON_MOD_FAULT = 500070
+SPC_CLR_MOD_FAULT = 500071
+SPC_MON_TK_MODA_5 = 500072
+SPC_MON_TK_MODB_5 = 500073
+SPC_MON_TC_MODA_5 = 500074
+SPC_MON_TC_MODB_5 = 500075
+SPC_MON_TF_MODA_5 = 500076
+SPC_MON_TF_MODB_5 = 500077
+SPC_MON_V_MOD_0 = 500078
+SPC_MON_V_MOD_1 = 500079
+SPC_MON_V_MOD_2 = 500080
+SPC_MON_V_MOD_3 = 500081
+SPC_MON_V_MOD_4 = 500082
+SPC_MON_V_MOD_5 = 500083
+SPC_MON_V_MOD_6 = 500084
+SPC_MON_V_MOD_7 = 500085
+SPC_MON_V_MOD_8 = 500086
+SPC_MON_V_MOD_9 = 500087
+SPC_MON_V_MOD_10 = 500088
+SPC_MON_TK_MODULE_2 = 500089
+SPC_MON_TC_MODULE_2 = 500090
+SPC_MON_TF_MODULE_2 = 500091
+SPC_MON_RPM_FAN0 = 500092
+SPC_MON_RPM_FAN1 = 500093
+SPC_MON_V_MEMVTTA = 500094
+SPC_MON_V_MEMVTTB = 500095
+SPC_MON_V_VCCAUX = 500096
+SPC_MON_V_MEMAUXA = 500097
+SPC_MON_V_MEMAUXB = 500098
+SPC_MON_TK_BASE_0 = 500099
+SPC_MON_TC_BASE_0 = 500100
+SPC_MON_TF_BASE_0 = 500101
+SPC_MON_TK_BASE_1 = 500102
+SPC_MON_TC_BASE_1 = 500103
+SPC_MON_TF_BASE_1 = 500104
+SPC_MON_I_CORE = 500105
+SPC_AVAILMONITORS = 510000
+SPCM_MON_T_BASE_CTRL = 0x0000000000000001
+SPCM_MON_T_MODULE_0 = 0x0000000000000002
+SPCM_MON_T_MODULE_1 = 0x0000000000000004
+SPCM_MON_T_MODULE_2 = 0x0000000000000008
+SPCM_MON_V_PCIE_BUS = 0x0000000000000010
+SPCM_MON_V_CONNECTOR = 0x0000000000000020
+SPCM_MON_CARD_PWRSOURCE = 0x0000000000000040
+SPCM_MON_V_CARD_IN = 0x0000000000000080
+SPCM_MON_I_CARD_IN = 0x0000000000000100
+SPCM_MON_P_CARD_IN = 0x0000000000000200
+SPCM_MON_V_3V3 = 0x0000000000000400
+SPCM_MON_V_2V5 = 0x0000000000000800
+SPCM_MON_V_CORE = 0x0000000000001000
+SPCM_MON_V_AVTT = 0x0000000000002000
+SPCM_MON_V_AVCC = 0x0000000000004000
+SPCM_MON_V_MEMVCC = 0x0000000000008000
+SPCM_MON_V_MEMVTT = 0x0000000000010000
+SPCM_MON_V_CP_POS = 0x0000000000020000
+SPCM_MON_V_CP_NEG = 0x0000000000040000
+SPCM_MON_V_5VA = 0x0000000000080000
+SPCM_MON_V_ADCA = 0x0000000000100000
+SPCM_MON_V_ADCD = 0x0000000000200000
+SPCM_MON_V_OP_POS = 0x0000000000400000
+SPCM_MON_V_OP_NEG = 0x0000000000800000
+SPCM_MON_V_COMP_NEG = 0x0000000001000000
+SPCM_MON_V_COMP_POS = 0x0000000002000000
+SPCM_MON_V_1V8_BASE = 0x0000000004000000
+SPCM_MON_V_1V8_MOD = 0x0000000008000000
+SPCM_MON_V_MODA_0 = 0x0000000010000000
+SPCM_MON_V_MODA_1 = 0x0000000020000000
+SPCM_MON_V_MODB_0 = 0x0000000040000000
+SPCM_MON_V_MODB_1 = 0x0000000080000000
+SPCM_MON_T_MODA_0 = 0x0000000000000002
+SPCM_MON_T_MODA_1 = 0x0000000100000000
+SPCM_MON_T_MODA_2 = 0x0000000200000000
+SPCM_MON_T_MODA_3 = 0x0000000400000000
+SPCM_MON_T_MODA_4 = 0x0000000800000000
+SPCM_MON_T_MODB_0 = 0x0000000000000004
+SPCM_MON_T_MODB_1 = 0x0000001000000000
+SPCM_MON_T_MODB_2 = 0x0000002000000000
+SPCM_MON_T_MODB_3 = 0x0000004000000000
+SPCM_MON_T_MODB_4 = 0x0000008000000000
+SPCM_MON_I_MODA_0 = 0x0000010000000000
+SPCM_MON_I_MODA_1 = 0x0000020000000000
+SPCM_MON_I_MODA_2 = 0x0000040000000000
+SPCM_MON_I_MODA_3 = 0x0000080000000000
+SPCM_MON_I_MODB_0 = 0x0000100000000000
+SPCM_MON_I_MODB_1 = 0x0000200000000000
+SPCM_MON_I_MODB_2 = 0x0000400000000000
+SPCM_MON_I_MODB_3 = 0x0000800000000000
+SPCM_MON_T_MODA_5 = 0x0001000000000000
+SPCM_MON_T_MODB_5 = 0x0002000000000000
+SPCM_MON_V_MEMVTTA = 0x0004000000000000
+SPCM_MON_V_MEMVTTB = 0x0008000000000000
+SPCM_MON_V_MEMAUXA = 0x0010000000000000
+SPCM_MON_V_MEMAUXB = 0x0020000000000000
+SPCM_MON_V_VCCAUX = 0x0040000000000000
+SPCM_MON_T_BASE_0 = 0x0080000000000000
+SPCM_MON_T_BASE_1 = 0x0100000000000000
+SPCM_MON_RPM_FAN0 = 0x0200000000000000
+SPCM_MON_RPM_FAN1 = 0x0400000000000000
+SPCM_MON_I_CORE = 0x0800000000000000
+SPC_AVAILMONITORS1 = 510001
+SPCM_MON_V_MOD_0 = 0x0000000000000001
+SPCM_MON_V_MOD_1 = 0x0000000000000002
+SPCM_MON_V_MOD_2 = 0x0000000000000004
+SPCM_MON_V_MOD_3 = 0x0000000000000008
+SPCM_MON_V_MOD_4 = 0x0000000000000010
+SPCM_MON_V_MOD_5 = 0x0000000000000020
+SPCM_MON_V_MOD_6 = 0x0000000000000040
+SPCM_MON_V_MOD_7 = 0x0000000000000080
+SPCM_MON_V_MOD_8 = 0x0000000000000100
+SPCM_MON_V_MOD_9 = 0x0000000000000200
+SPCM_MON_V_MOD_10 = 0x0000000000000400
+SPC_X0_READFEATURES = 600000
+SPC_X1_READFEATURES = 600001
+SPC_X2_READFEATURES = 600002
+SPC_X3_READFEATURES = 600003
+SPC_X4_READFEATURES = 600004
+SPC_X5_READFEATURES = 600005
+SPC_X6_READFEATURES = 600006
+SPC_X7_READFEATURES = 600007
+SPC_X8_READFEATURES = 600008
+SPC_X9_READFEATURES = 600009
+SPC_X10_READFEATURES = 600010
+SPC_X11_READFEATURES = 600011
+SPC_X12_READFEATURES = 600012
+SPC_X13_READFEATURES = 600013
+SPC_X14_READFEATURES = 600014
+SPC_X15_READFEATURES = 600015
+SPC_X16_READFEATURES = 600016
+SPC_X17_READFEATURES = 600017
+SPC_X18_READFEATURES = 600018
+SPC_X19_READFEATURES = 600019
+SPCM_XFEAT_TERM = 0x00000001
+SPCM_XFEAT_HIGHIMP = 0x00000002
+SPCM_XFEAT_DCCOUPLING = 0x00000004
+SPCM_XFEAT_ACCOUPLING = 0x00000008
+SPCM_XFEAT_SE = 0x00000010
+SPCM_XFEAT_DIFF = 0x00000020
+SPCM_XFEAT_PROGTHRESHOLD = 0x00000040
+SPC_X0_TERM = 600100
+SPC_X1_TERM = 600101
+SPC_X2_TERM = 600102
+SPC_X3_TERM = 600103
+SPC_X4_TERM = 600104
+SPC_X5_TERM = 600105
+SPC_X6_TERM = 600106
+SPC_X7_TERM = 600107
+SPC_X8_TERM = 600108
+SPC_X9_TERM = 600109
+SPC_X10_TERM = 600110
+SPC_X11_TERM = 600111
+SPC_X12_TERM = 600112
+SPC_X13_TERM = 600113
+SPC_X14_TERM = 600114
+SPC_X15_TERM = 600115
+SPC_X16_TERM = 600116
+SPC_X17_TERM = 600117
+SPC_X18_TERM = 600118
+SPC_X19_TERM = 600119
+SPCM_X0_MODE = 600200
+SPCM_X1_MODE = 600201
+SPCM_X2_MODE = 600202
+SPCM_X3_MODE = 600203
+SPCM_X4_MODE = 600204
+SPCM_X5_MODE = 600205
+SPCM_X6_MODE = 600206
+SPCM_X7_MODE = 600207
+SPCM_X8_MODE = 600208
+SPCM_X9_MODE = 600209
+SPCM_X10_MODE = 600210
+SPCM_X11_MODE = 600211
+SPCM_X12_MODE = 600212
+SPCM_X13_MODE = 600213
+SPCM_X14_MODE = 600214
+SPCM_X15_MODE = 600215
+SPCM_X16_MODE = 600216
+SPCM_X17_MODE = 600217
+SPCM_X18_MODE = 600218
+SPCM_X19_MODE = 600219
+SPCM_X0_AVAILMODES = 600300
+SPCM_X1_AVAILMODES = 600301
+SPCM_X2_AVAILMODES = 600302
+SPCM_X3_AVAILMODES = 600303
+SPCM_X4_AVAILMODES = 600304
+SPCM_X5_AVAILMODES = 600305
+SPCM_X6_AVAILMODES = 600306
+SPCM_X7_AVAILMODES = 600307
+SPCM_X8_AVAILMODES = 600308
+SPCM_X9_AVAILMODES = 600309
+SPCM_X10_AVAILMODES = 600310
+SPCM_X11_AVAILMODES = 600311
+SPCM_X12_AVAILMODES = 600312
+SPCM_X13_AVAILMODES = 600313
+SPCM_X14_AVAILMODES = 600314
+SPCM_X15_AVAILMODES = 600315
+SPCM_X16_AVAILMODES = 600316
+SPCM_X17_AVAILMODES = 600317
+SPCM_X18_AVAILMODES = 600318
+SPCM_X19_AVAILMODES = 600319
+SPC_REG0x00 = 900000
+SPC_REG0x02 = 900010
+SPC_REG0x04 = 900020
+SPC_REG0x06 = 900030
+SPC_REG0x08 = 900040
+SPC_REG0x0A = 900050
+SPC_REG0x0C = 900060
+SPC_REG0x0E = 900070
+SPC_DEBUGREG0 = 900100
+SPC_DEBUGREG15 = 900115
+SPC_DEBUGVALUE0 = 900200
+SPC_DEBUGVALUE15 = 900215
+SPC_MI_ISP = 901000
+ISP_TMS_0 = 0
+ISP_TMS_1 = 1
+ISP_TDO_0 = 0
+ISP_TDO_1 = 2
+SPC_EE_RWAUTH = 901100
+SPC_EE_REG = 901110
+SPC_EE_RESETCOUNTER = 901120
+SPC_TEST_BASE = 902000
+SPC_TEST_LOCAL_START = 902100
+SPC_TEST_LOCAL_END = 902356
+SPC_TEST_PLX_START = 902400
+SPC_TEST_PLX_END = 902656
+SPC_FUNCTION_DEFTRANSFER = 100000000
diff --git a/Python/py_header/spcerr.py b/Python/py_header/spcerr.py
new file mode 100644
index 0000000000000000000000000000000000000000..e8164a9a2c7f9db0e21de9ecd29a0b656b909336
--- /dev/null
+++ b/Python/py_header/spcerr.py
@@ -0,0 +1,82 @@
+SPCM_ERROR_ORIGIN_MASK = 0x80000000
+SPCM_ERROR_ORIGIN_LOCAL = 0x00000000
+SPCM_ERROR_ORIGIN_REMOTE = 0x80000000
+ERR_OK = 0x0000
+ERR_INIT = 0x0001
+ERR_NR = 0x0002
+ERR_TYP = 0x0003
+ERR_FNCNOTSUPPORTED = 0x0004
+ERR_BRDREMAP = 0x0005
+ERR_KERNELVERSION = 0x0006
+ERR_HWDRVVERSION = 0x0007
+ERR_ADRRANGE = 0x0008
+ERR_INVALIDHANDLE = 0x0009
+ERR_BOARDNOTFOUND = 0x000A
+ERR_BOARDINUSE = 0x000B
+ERR_EXPHW64BITADR = 0x000C
+ERR_FWVERSION = 0x000D
+ERR_SYNCPROTOCOL = 0x000E
+ERR_KERNEL = 0x000F
+ERR_LASTERR = 0x0010
+ERR_ABORT = 0x0020
+ERR_BOARDLOCKED = 0x0030
+ERR_DEVICE_MAPPING = 0x0032
+ERR_NETWORKSETUP = 0x0040
+ERR_NETWORKTRANSFER = 0x0041
+ERR_FWPOWERCYCLE = 0x0042
+ERR_NETWORKTIMEOUT = 0x0043
+ERR_BUFFERSIZE = 0x0044
+ERR_RESTRICTEDACCESS = 0x0045
+ERR_INVALIDPARAM = 0x0046
+ERR_TEMPERATURE = 0x0047
+ERR_FAN = 0x0048
+ERR_REG = 0x0100
+ERR_VALUE = 0x0101
+ERR_FEATURE = 0x0102
+ERR_SEQUENCE = 0x0103
+ERR_READABORT = 0x0104
+ERR_NOACCESS = 0x0105
+ERR_POWERDOWN = 0x0106
+ERR_TIMEOUT = 0x0107
+ERR_CALLTYPE = 0x0108
+ERR_EXCEEDSINT32 = 0x0109
+ERR_NOWRITEALLOWED = 0x010A
+ERR_SETUP = 0x010B
+ERR_CLOCKNOTLOCKED = 0x010C
+ERR_MEMINIT = 0x010D
+ERR_POWERSUPPLY = 0x010E
+ERR_ADCCOMMUNICATION = 0x010F
+ERR_CHANNEL = 0x0110
+ERR_NOTIFYSIZE = 0x0111
+ERR_RUNNING = 0x0120
+ERR_ADJUST = 0x0130
+ERR_PRETRIGGERLEN = 0x0140
+ERR_DIRMISMATCH = 0x0141
+ERR_POSTEXCDSEGMENT = 0x0142
+ERR_SEGMENTINMEM = 0x0143
+ERR_MULTIPLEPW = 0x0144
+ERR_NOCHANNELPWOR = 0x0145
+ERR_ANDORMASKOVRLAP = 0x0146
+ERR_ANDMASKEDGE = 0x0147
+ERR_ORMASKLEVEL = 0x0148
+ERR_EDGEPERMOD = 0x0149
+ERR_DOLEVELMINDIFF = 0x014A
+ERR_STARHUBENABLE = 0x014B
+ERR_PATPWSMALLEDGE = 0x014C
+ERR_XMODESETUP = 0x014D
+ERR_NOPCI = 0x0200
+ERR_PCIVERSION = 0x0201
+ERR_PCINOBOARDS = 0x0202
+ERR_PCICHECKSUM = 0x0203
+ERR_DMALOCKED = 0x0204
+ERR_MEMALLOC = 0x0205
+ERR_EEPROMLOAD = 0x0206
+ERR_CARDNOSUPPORT = 0x0207
+ERR_CONFIGACCESS = 0x0208
+ERR_FIFOBUFOVERRUN = 0x0300
+ERR_FIFOHWOVERRUN = 0x0301
+ERR_FIFOFINISHED = 0x0302
+ERR_FIFOSETUP = 0x0309
+ERR_TIMESTAMP_SYNC = 0x0310
+ERR_STARHUB = 0x0320
+ERR_INTERNAL_ERROR = 0xFFFF
diff --git a/Python/pyspcm.py b/Python/pyspcm.py
new file mode 100644
index 0000000000000000000000000000000000000000..4cc7925c7971562fa05c436eb385298e62e2bbd0
--- /dev/null
+++ b/Python/pyspcm.py
@@ -0,0 +1,232 @@
+import os
+import platform
+import sys
+from ctypes import *
+
+# load registers for easier access
+from py_header.regs import *
+
+# load registers for easier access
+from py_header.spcerr import *
+
+SPCM_DIR_PCTOCARD = 0
+SPCM_DIR_CARDTOPC = 1
+
+SPCM_BUF_DATA = 1000 # main data buffer for acquired or generated samples
+SPCM_BUF_ABA = 2000 # buffer for ABA data, holds the A-DATA (slow samples)
+SPCM_BUF_TIMESTAMP = 3000 # buffer for timestamps
+
+
+# determine bit width of os
+oPlatform = platform.architecture()
+if (oPlatform[0] == '64bit'):
+ bIs64Bit = 1
+else:
+ bIs64Bit = 0
+
+# define pointer aliases
+int8 = c_int8
+int16 = c_int16
+int32 = c_int32
+int64 = c_int64
+
+ptr8 = POINTER (int8)
+ptr16 = POINTER (int16)
+ptr32 = POINTER (int32)
+ptr64 = POINTER (int64)
+
+uint8 = c_uint8
+uint16 = c_uint16
+uint32 = c_uint32
+uint64 = c_uint64
+
+uptr8 = POINTER (uint8)
+uptr16 = POINTER (uint16)
+uptr32 = POINTER (uint32)
+uptr64 = POINTER (uint64)
+
+
+# Windows
+if os.name == 'nt':
+ sys.stdout.write("Python Version: {0} on Windows\n\n".format (platform.python_version()))
+
+ # define card handle type
+ if (bIs64Bit):
+ # for unknown reasons c_void_p gets messed up on Win7/64bit, but this works:
+ drv_handle = POINTER(c_uint64)
+ else:
+ drv_handle = c_void_p
+
+ # Load DLL into memory.
+ # use windll because all driver access functions use _stdcall calling convention under windows
+ if (bIs64Bit == 1):
+ spcmDll = windll.LoadLibrary ("c:\\windows\\system32\\spcm_win64.dll")
+ else:
+ spcmDll = windll.LoadLibrary ("c:\\windows\\system32\\spcm_win32.dll")
+
+ # load spcm_hOpen
+ if (bIs64Bit):
+ spcm_hOpen = getattr (spcmDll, "spcm_hOpen")
+ else:
+ spcm_hOpen = getattr (spcmDll, "_spcm_hOpen@4")
+ spcm_hOpen.argtype = [c_char_p]
+ spcm_hOpen.restype = drv_handle
+
+ # load spcm_vClose
+ if (bIs64Bit):
+ spcm_vClose = getattr (spcmDll, "spcm_vClose")
+ else:
+ spcm_vClose = getattr (spcmDll, "_spcm_vClose@4")
+ spcm_vClose.argtype = [drv_handle]
+ spcm_vClose.restype = None
+
+ # load spcm_dwGetErrorInfo
+ if (bIs64Bit):
+ spcm_dwGetErrorInfo_i32 = getattr (spcmDll, "spcm_dwGetErrorInfo_i32")
+ else:
+ spcm_dwGetErrorInfo_i32 = getattr (spcmDll, "_spcm_dwGetErrorInfo_i32@16")
+ spcm_dwGetErrorInfo_i32.argtype = [drv_handle, uptr32, ptr32, c_char_p]
+ spcm_dwGetErrorInfo_i32.restype = uint32
+
+ # load spcm_dwGetParam_i32
+ if (bIs64Bit):
+ spcm_dwGetParam_i32 = getattr (spcmDll, "spcm_dwGetParam_i32")
+ else:
+ spcm_dwGetParam_i32 = getattr (spcmDll, "_spcm_dwGetParam_i32@12")
+ spcm_dwGetParam_i32.argtype = [drv_handle, int32, ptr32]
+ spcm_dwGetParam_i32.restype = uint32
+
+ # load spcm_dwGetParam_i64
+ if (bIs64Bit):
+ spcm_dwGetParam_i64 = getattr (spcmDll, "spcm_dwGetParam_i64")
+ else:
+ spcm_dwGetParam_i64 = getattr (spcmDll, "_spcm_dwGetParam_i64@12")
+ spcm_dwGetParam_i64.argtype = [drv_handle, int32, ptr64]
+ spcm_dwGetParam_i64.restype = uint32
+
+ # load spcm_dwSetParam_i32
+ if (bIs64Bit):
+ spcm_dwSetParam_i32 = getattr (spcmDll, "spcm_dwSetParam_i32")
+ else:
+ spcm_dwSetParam_i32 = getattr (spcmDll, "_spcm_dwSetParam_i32@12")
+ spcm_dwSetParam_i32.argtype = [drv_handle, int32, int32]
+ spcm_dwSetParam_i32.restype = uint32
+
+ # load spcm_dwSetParam_i64
+ if (bIs64Bit):
+ spcm_dwSetParam_i64_ = getattr (spcmDll, "spcm_dwSetParam_i64")
+ else:
+ spcm_dwSetParam_i64_ = getattr (spcmDll, "_spcm_dwSetParam_i64@16")
+ spcm_dwSetParam_i64_.argtype = [drv_handle, int32, int64]
+ spcm_dwSetParam_i64_.restype = uint32
+
+ def spcm_dwSetParam_i64 (hDrv, lReg, Val):
+ try:
+ llVal = int64(Val.value)
+ except AttributeError:
+ llVal = int64(Val)
+ return spcm_dwSetParam_i64_ (hDrv, lReg, llVal)
+
+ # load spcm_dwSetParam_i64m
+ if (bIs64Bit):
+ spcm_dwSetParam_i64m = getattr (spcmDll, "spcm_dwSetParam_i64m")
+ else:
+ spcm_dwSetParam_i64m = getattr (spcmDll, "_spcm_dwSetParam_i64m@16")
+ spcm_dwSetParam_i64m.argtype = [drv_handle, int32, int32, int32]
+ spcm_dwSetParam_i64m.restype = uint32
+
+ # load spcm_dwDefTransfer_i64
+ if (bIs64Bit):
+ spcm_dwDefTransfer_i64 = getattr (spcmDll, "spcm_dwDefTransfer_i64")
+ else:
+ spcm_dwDefTransfer_i64 = getattr (spcmDll, "_spcm_dwDefTransfer_i64@36")
+ spcm_dwDefTransfer_i64.argtype = [drv_handle, uint32, uint32, uint32, c_void_p, uint64, uint64]
+ spcm_dwDefTransfer_i64.restype = uint32
+
+ # load spcm_dwInvalidateBuf
+ if (bIs64Bit):
+ spcm_dwInvalidateBuf = getattr (spcmDll, "spcm_dwInvalidateBuf")
+ else:
+ spcm_dwInvalidateBuf = getattr (spcmDll, "_spcm_dwInvalidateBuf@8")
+ spcm_dwInvalidateBuf.argtype = [drv_handle, uint32]
+ spcm_dwInvalidateBuf.restype = uint32
+
+ # load spcm_dwGetContBuf_i64
+ if (bIs64Bit):
+ spcm_dwGetContBuf_i64 = getattr (spcmDll, "spcm_dwGetContBuf_i64")
+ else:
+ spcm_dwGetContBuf_i64 = getattr (spcmDll, "_spcm_dwGetContBuf_i64@16")
+ spcm_dwGetContBuf_i64.argtype = [drv_handle, uint32, POINTER(c_void_p), uptr64]
+ spcm_dwGetContBuf_i64.restype = uint32
+
+
+elif os.name == 'posix':
+ sys.stdout.write("Python Version: {0} on Linux\n\n".format (platform.python_version()))
+
+ # define card handle type
+ if (bIs64Bit):
+ drv_handle = POINTER(c_uint64)
+ else:
+ drv_handle = c_void_p
+
+ # Load DLL into memory.
+ # use cdll because all driver access functions use cdecl calling convention under linux
+ spcmDll = cdll.LoadLibrary ("libspcm_linux.so")
+
+ # load spcm_hOpen
+ spcm_hOpen = getattr (spcmDll, "spcm_hOpen")
+ spcm_hOpen.argtype = [c_char_p]
+ spcm_hOpen.restype = drv_handle
+
+ # load spcm_vClose
+ spcm_vClose = getattr (spcmDll, "spcm_vClose")
+ spcm_vClose.argtype = [drv_handle]
+ spcm_vClose.restype = None
+
+ # load spcm_dwGetErrorInfo
+ spcm_dwGetErrorInfo_i32 = getattr (spcmDll, "spcm_dwGetErrorInfo_i32")
+ spcm_dwGetErrorInfo_i32.argtype = [drv_handle, uptr32, ptr32, c_char_p]
+ spcm_dwGetErrorInfo_i32.restype = uint32
+
+ # load spcm_dwGetParam_i32
+ spcm_dwGetParam_i32 = getattr (spcmDll, "spcm_dwGetParam_i32")
+ spcm_dwGetParam_i32.argtype = [drv_handle, int32, ptr32]
+ spcm_dwGetParam_i32.restype = uint32
+
+ # load spcm_dwGetParam_i64
+ spcm_dwGetParam_i64 = getattr (spcmDll, "spcm_dwGetParam_i64")
+ spcm_dwGetParam_i64.argtype = [drv_handle, int32, ptr64]
+ spcm_dwGetParam_i64.restype = uint32
+
+ # load spcm_dwSetParam_i32
+ spcm_dwSetParam_i32 = getattr (spcmDll, "spcm_dwSetParam_i32")
+ spcm_dwSetParam_i32.argtype = [drv_handle, int32, int32]
+ spcm_dwSetParam_i32.restype = uint32
+
+ # load spcm_dwSetParam_i64
+ spcm_dwSetParam_i64 = getattr (spcmDll, "spcm_dwSetParam_i64")
+ spcm_dwSetParam_i64.argtype = [drv_handle, int32, int64]
+ spcm_dwSetParam_i64.restype = uint32
+
+ # load spcm_dwSetParam_i64m
+ spcm_dwSetParam_i64m = getattr (spcmDll, "spcm_dwSetParam_i64m")
+ spcm_dwSetParam_i64m.argtype = [drv_handle, int32, int32, int32]
+ spcm_dwSetParam_i64m.restype = uint32
+
+ # load spcm_dwDefTransfer_i64
+ spcm_dwDefTransfer_i64 = getattr (spcmDll, "spcm_dwDefTransfer_i64")
+ spcm_dwDefTransfer_i64.argtype = [drv_handle, uint32, uint32, uint32, c_void_p, uint64, uint64]
+ spcm_dwDefTransfer_i64.restype = uint32
+
+ # load spcm_dwInvalidateBuf
+ spcm_dwInvalidateBuf = getattr (spcmDll, "spcm_dwInvalidateBuf")
+ spcm_dwInvalidateBuf.argtype = [drv_handle, uint32]
+ spcm_dwInvalidateBuf.restype = uint32
+
+ # load spcm_dwGetContBuf_i64
+ spcm_dwGetContBuf_i64 = getattr (spcmDll, "spcm_dwGetContBuf_i64")
+ spcm_dwGetContBuf_i64.argtype = [drv_handle, uint32, POINTER(c_void_p), uptr64]
+ spcm_dwGetContBuf_i64.restype = uint32
+
+else:
+ raise Exception ('Operating system not supported by pySpcm')
diff --git a/Python/sequence_v1.py b/Python/sequence_v1.py
new file mode 100644
index 0000000000000000000000000000000000000000..fc8ae6999a20c6cec4694f3ece96408ba35da4bc
--- /dev/null
+++ b/Python/sequence_v1.py
@@ -0,0 +1,120 @@
+#
+# **************************************************************************
+# AWG fast sequence control V1
+#
+# Must install the AWG driver for Windows 8/9/10/11, found in
+# https://spectrum-instrumentation.com/support/downloads.php
+# Look under model M4i 6622-x8
+#
+# The python module provided is in essence a c/c++ wrapper,
+# hence the extensive use of ctype variables and c-like coding style in this code.
+# **************************************************************************
+#
+# This code makes AWG play one iteration of the written waveform upon a hardware trigger from channel ext0,
+# or a 'c' keyboard press. A 's' keyboard press stops the AWG.
+#
+# **************************************************************************
+#
+from pyspcm import *
+from spcm_tools import *
+import sys
+import math
+import numpy as np
+from time import sleep
+from AWG_outdated import *
+import msvcrt
+
+
+# helper func to exit the program when an error is detected, also takes a string for testing purpose
+def errorExit(awg, msg):
+ if awg.checkError(msg):
+ awg.close()
+ exit(1)
+
+
+awg = AWG()
+awg.open()
+errorExit(awg, "start up")
+hCard = awg.hCard
+
+spcm_dwSetParam_i32(hCard, SPC_CLOCKOUT, 0)
+
+lChEnable = int64(CHANNEL0)
+lMemSamples = int64(KILO_B(64))
+
+spcm_dwSetParam_i32(hCard, SPC_CARDMODE, SPC_REP_STD_SINGLERESTART) # single restart mode
+spcm_dwSetParam_i64(hCard, SPC_SAMPLERATE, MEGA(64)) # set 64 MHz sampling rate
+spcm_dwSetParam_i64(hCard, SPC_CHENABLE, lChEnable) # enable channel 0
+spcm_dwSetParam_i64(hCard, SPC_MEMSIZE, lMemSamples) # set memory size of a single waveform to 16 kB
+spcm_dwSetParam_i32(hCard, SPC_LOOPS, 0) # run # of times, or 0 for endless loop until stopped by trigger
+errorExit(awg, "mode init")
+
+# set up the trigger mode
+spcm_dwSetParam_i32(hCard, SPC_TRIG_ORMASK, SPC_TMASK_SOFTWARE) # using external channel 0 as trigger
+# spcm_dwSetParam_i32(hCard, SPC_TRIG_ORMASK, SPC_TMASK_NONE)
+spcm_dwSetParam_i32(hCard, SPC_TRIG_ANDMASK, 0)
+spcm_dwSetParam_i32(hCard, SPC_TRIG_CH_ORMASK0, 0)
+spcm_dwSetParam_i32(hCard, SPC_TRIG_CH_ORMASK1, 0)
+spcm_dwSetParam_i32(hCard, SPC_TRIG_CH_ANDMASK0, 0)
+spcm_dwSetParam_i32(hCard, SPC_TRIG_CH_ANDMASK1, 0)
+spcm_dwSetParam_i32(hCard, SPC_TRIGGEROUT, 0)
+# spcm_dwSetParam_i32(hCard, SPC_TRIG_EXT0_MODE, SPC_TM_POS) # positive edge trigger
+errorExit(awg, "trigger")
+
+# set up the channels
+lNumChannels = int32(0)
+spcm_dwGetParam_i32(hCard, SPC_CHCOUNT, byref(lNumChannels))
+for lCh in range (0, lNumChannels.value, 1):
+ spcm_dwSetParam_i32 (hCard, SPC_ENABLEOUT0 + lCh * (SPC_ENABLEOUT1 - SPC_ENABLEOUT0), 1)
+ spcm_dwSetParam_i32 (hCard, SPC_AMP0 + lCh * (SPC_AMP1 - SPC_AMP0), 1000)
+ spcm_dwSetParam_i32 (hCard, SPC_CH0_STOPLEVEL + lCh * (SPC_CH1_STOPLEVEL - SPC_CH0_STOPLEVEL), SPCM_STOPLVL_ZERO)
+
+# buffer loading preparation
+lBytesPerSample = int32(0)
+spcm_dwGetParam_i32(hCard, SPC_MIINST_BYTESPERSAMPLE, byref(lBytesPerSample))
+# use continuous mem whenever possible
+swBufferSize = uint64(lMemSamples.value * lBytesPerSample.value * lNumChannels.value)
+pvBuffer = c_void_p()
+swContBufLen = uint64(0)
+spcm_dwGetContBuf_i64(hCard, SPCM_BUF_DATA, byref(pvBuffer), byref(swContBufLen))
+sys.stdout.write("Continuous buffer length: {:d}\n".format(swContBufLen.value))
+if swContBufLen.value > swBufferSize.value:
+ sys.stdout.write("Using continuous buffer\n")
+else:
+ pvBuffer = pvAllocMemPageAligned(swBufferSize.value)
+ sys.stdout.write("Using manually allocated buffer\n")
+errorExit(awg, "buffer prep")
+
+# waveform calculation
+wData = np.linspace(0, lMemSamples.value, lMemSamples.value, dtype=int16) # a ramping signal
+wDataPtr = wData.ctypes.data_as(POINTER(int16)) # buffer writing function requires a pointer to the start of the array
+pnBuffer = cast(pvBuffer, ptr16)
+for i in range(0, lMemSamples.value, 1): # a ramping signal
+ pnBuffer[i] = i
+spcm_dwDefTransfer_i64(hCard, SPCM_BUF_DATA, SPCM_DIR_PCTOCARD, int32(0), wDataPtr, uint64(0), swBufferSize)
+spcm_dwSetParam_i32(hCard, SPC_M2CMD, M2CMD_DATA_STARTDMA | M2CMD_DATA_WAITDMA)
+errorExit(awg, "data writing")
+
+spcm_dwSetParam_i32(hCard, SPC_M2CMD, M2CMD_CARD_START | M2CMD_CARD_ENABLETRIGGER) # start the card, enable trigger and wait for trigger to start
+errorExit(awg, "starting card")
+
+lCardStatus = int32(0)
+while True:
+ lKey = input("command: ")
+ if lKey == 's': # stop on s
+ spcm_dwSetParam_i32(hCard, SPC_M2CMD, M2CMD_CARD_STOP)
+ sys.stdout.write("stopping card\n")
+ break
+ elif lKey == 'c':
+ spcm_dwSetParam_i32(hCard, SPC_M2CMD, M2CMD_CARD_FORCETRIGGER)
+ errorExit(awg, "force trigger")
+ else:
+ sleep(1)
+ print("nothing")
+
+ # spcm_dwGetParam_i32(hCard, SPC_M2STATUS, lCardStatus)
+ # if lCardStatus.value & M2STAT_CARD_READY != 0:
+ # break
+
+awg.close()
+
diff --git a/Python/sequence_v2.py b/Python/sequence_v2.py
new file mode 100644
index 0000000000000000000000000000000000000000..c6bf6ecd20de2b2108c14aea59f5e2e5e6ce92a0
--- /dev/null
+++ b/Python/sequence_v2.py
@@ -0,0 +1,165 @@
+#
+# **************************************************************************
+# AWG fast sequence control V2
+#
+# Must install the AWG driver for Windows 8/9/10/11, found in
+# https://spectrum-instrumentation.com/support/downloads.php
+# Look under model M4i 6622-x8
+#
+# The python module provided is in essence a c/c++ wrapper,
+# hence the extensive use of ctype variables and c-like coding style in this code.
+# **************************************************************************
+#
+# This code makes AWG play one waveform on repeat until a trigger event.
+# Upon a triggering event the AWG will play a second waveform on repeat.
+#
+# **************************************************************************
+
+
+from pyspcm import *
+from spcm_tools import *
+import sys
+import math
+import numpy as np
+import time
+from AWG_outdated import *
+import msvcrt
+
+
+def errorExit(awg, msg=None):
+ """
+ helper func to exit the program when an error is detected
+ :param awg: awg instance
+ :param msg: optional msg for testing purpose
+ """
+ if awg.checkError(msg):
+ awg.close()
+ exit(1)
+
+
+def configureStep(card, step, segment, loop, next, condition):
+ """
+ helper to configure a step in the sequence
+ :param awg: awg instance
+ :param step: step in the sequence to configure, starts at SPC_SEQMODE_STEPMEM0
+ :param segment: memory segment this step is linked to
+ :param loop: number of times this step is repeated
+ :param next: next step to be played after this step
+ :param condition: see usage of this function for detail
+ """
+ mask = (condition << 32) | (loop << 32) | (next << 16) | segment # 64-bit mask
+ spcm_dwSetParam_i64(card, SPC_SEQMODE_STEPMEM0 + step, mask)
+
+
+# helper to write data onto a memory segment
+def writeSeg(card, dataptr, segment, size, numCh):
+ spcm_dwSetParam_i32(card, SPC_SEQMODE_WRITESEGMENT, segment) # set current segment
+ spcm_dwSetParam_i32(card, SPC_SEQMODE_SEGMENTSIZE, size) # set segment size
+ # transfer data
+ segLength = size * 2 * numCh
+ spcm_dwDefTransfer_i64(card, SPCM_BUF_DATA, SPCM_DIR_PCTOCARD, int32(0), dataptr, int64(0), segLength)
+ spcm_dwSetParam_i32(card, SPC_M2CMD, M2CMD_DATA_STARTDMA | M2CMD_DATA_WAITDMA)
+
+
+awg = AWG()
+awg.open()
+errorExit(awg, "start up")
+hCard = awg.hCard
+
+# **************************************************************************
+# mode initialization
+# **************************************************************************
+lChEnable = int64(CHANNEL0)
+# lMemSamples = int64(KILO_B(64))
+lNumSegments = 2 # number of sequences the memory is divided into, must be powers of 2: 2,4,8...
+spcm_dwSetParam_i32(hCard, SPC_CARDMODE, SPC_REP_STD_SEQUENCE) # Sequence replay mode
+spcm_dwSetParam_i32(hCard, SPC_SEQMODE_MAXSEGMENTS, lNumSegments) # set number of sequences the memory is divided into
+spcm_dwSetParam_i32(hCard, SPC_SEQMODE_STARTSTEP, 0) # set step 0 as the starting step
+spcm_dwSetParam_i64(hCard, SPC_SAMPLERATE, MEGA(64)) # set 64 MHz sampling rate
+spcm_dwSetParam_i64(hCard, SPC_CHENABLE, lChEnable) # enable channel 0
+# spcm_dwSetParam_i64(hCard, SPC_MEMSIZE, lMemSamples) # MEMSIZE is not used in sequence replay mode
+spcm_dwSetParam_i32(hCard, SPC_CLOCKOUT, 0) # no clock output
+errorExit(awg, "mode init")
+
+# **************************************************************************
+# set up trigger mode
+# **************************************************************************
+spcm_dwSetParam_i32(hCard, SPC_TRIG_ORMASK, SPC_TMASK_EXT0) # using external channel 0 as trigger
+# spcm_dwSetParam_i32(hCard, SPC_TRIG_ORMASK, SPC_TMASK_NONE)
+spcm_dwSetParam_i32(hCard, SPC_TRIG_ANDMASK, 0)
+spcm_dwSetParam_i32(hCard, SPC_TRIG_CH_ORMASK0, 0)
+spcm_dwSetParam_i32(hCard, SPC_TRIG_CH_ORMASK1, 0)
+spcm_dwSetParam_i32(hCard, SPC_TRIG_CH_ANDMASK0, 0)
+spcm_dwSetParam_i32(hCard, SPC_TRIG_CH_ANDMASK1, 0)
+spcm_dwSetParam_i32(hCard, SPC_TRIGGEROUT, 0)
+spcm_dwSetParam_i32(hCard, SPC_TRIG_EXT0_MODE, SPC_TM_POS) # positive edge trigger
+errorExit(awg, "trigger")
+
+# **************************************************************************
+# set up channel modes
+# **************************************************************************
+lNumChannels = int32(0)
+spcm_dwGetParam_i32(hCard, SPC_CHCOUNT, byref(lNumChannels))
+for lCh in range (0, lNumChannels.value, 1):
+ # second entry looks weird because the mask for having multiple channels is "interleaved", see data organization chapter in manual for more detail
+ spcm_dwSetParam_i32 (hCard, SPC_ENABLEOUT0 + lCh * (SPC_ENABLEOUT1 - SPC_ENABLEOUT0), 1) # enable channel
+ spcm_dwSetParam_i32 (hCard, SPC_AMP0 + lCh * (SPC_AMP1 - SPC_AMP0), 1000) # set output amplitude
+ spcm_dwSetParam_i32 (hCard, SPC_CH0_STOPLEVEL + lCh * (SPC_CH1_STOPLEVEL - SPC_CH0_STOPLEVEL), SPCM_STOPLVL_ZERO) #
+errorExit(awg, "channel init")
+
+# **************************************************************************
+# do data calculation and set up segments/memory
+# **************************************************************************
+dwFactor = 6 # weird factor related to the minimum size of a segment, not sure if necessary.
+segLength = KILO(1) # 1k samples
+fullScale = int32(0)
+spcm_dwGetParam_i32(hCard, SPC_MIINST_MAXADCVALUE, byref (fullScale)) # full scale value for data generation purpose
+fullScale = fullScale.value
+halfScale = fullScale // 2
+
+# generate segment 0
+combinedData = np.zeros(dwFactor*segLength*lNumChannels.value, dtype=int16) # this array will contain all generated data
+for i in range(lNumChannels.value):
+ x = np.linspace(0, segLength, segLength)
+ data = halfScale * np.sin(2*np.pi*segLength*x) # sine wave with a period of segLength
+ combinedData[i::2] = data.astype(int16) # output same data onto all channels
+dataptr = combinedData.ctypes.data_as(POINTER(int16)) # convert data into a c-like array, with dataptr pointing to the address of first element
+# write segment data
+writeSeg(hCard, dataptr=dataptr, segment=0, size=segLength, numCh=lNumChannels)
+
+# generate segment 1
+combinedData = np.zeros(dwFactor*segLength*lNumChannels.value, dtype=int16) # this array will contain all generated data
+for i in range(lNumChannels.value):
+ data = np.zeros(segLength, dtype=int16)
+ oneThirdPoint = segLength // 3
+ data[oneThirdPoint:oneThirdPoint*2] = halfScale # square wave in the middle
+ combinedData[i::2] = data.astype(int16) # output same data onto all channels
+dataptr = combinedData.ctypes.data_as(POINTER(int16)) # convert data into a c-like array, with dataptr pointing to the address of first element
+# write segment data
+writeSeg(hCard, dataptr, 1, segLength, lNumChannels)
+
+# **************************************************************************
+# configure steps
+# **************************************************************************
+configureStep(hCard, step=0, segment=0, loop=1, next=1, condition=SPCSEQ_ENDLOOPONTRIG)
+configureStep(hCard, step=1, segment=1, loop=1, next=0, condition=SPCSEQ_ENDLOOPONTRIG)
+
+# **************************************************************************
+# running the sequence
+# **************************************************************************
+spcm_dwSetParam_i32(hCard, SPC_M2CMD, M2CMD_CARD_START | M2CMD_CARD_ENABLETRIGGER) # start the card, enable trigger and wait for trigger to start
+while True:
+ command = input("command: ")
+ if command == 's': # stop on s
+ spcm_dwSetParam_i32(hCard, SPC_M2CMD, M2CMD_CARD_STOP)
+ sys.stdout.write("stopping card\n")
+ break
+ elif command == 'c':
+ spcm_dwSetParam_i32(hCard, SPC_M2CMD, M2CMD_CARD_FORCETRIGGER)
+ errorExit(awg, "force trigger")
+ else:
+ sys.stdout.write("nothing")
+awg.close()
+
+
+
diff --git a/Python/sequence_v3.py b/Python/sequence_v3.py
new file mode 100644
index 0000000000000000000000000000000000000000..39fba9dd301cffbdb960ed4a2a5643d0109978b1
--- /dev/null
+++ b/Python/sequence_v3.py
@@ -0,0 +1,47 @@
+from pyspcm import *
+from spcm_tools import *
+import sys
+import math
+import numpy as np
+import time
+from AWG import *
+import msvcrt
+
+awg = AWG()
+awg.open()
+awg.set_sampling_rate(MEGA(64))
+awg.enable_channel(0)
+awg.set_trigger(EXT0=SPC_TM_POS)
+awg.set_sequence_mode(2)
+
+seg_length = KILO(10)
+fs = int32(0)
+spcm_dwGetParam_i32(awg.card, SPC_MIINST_MAXADCVALUE, byref(fs)) # full scale value for data generation purpose
+fs = fs.value
+hs = fs // 2
+
+x = np.linspace(0, seg_length, seg_length, dtype=int16)
+seg0 = hs * np.sin(2*np.pi*seg_length*x)
+
+cutoff = seg_length // 3
+seg1 = np.zeros(seg_length, dtype=int16)
+seg1[cutoff:cutoff*2] = hs
+
+awg.write_segment(seg0, segment=0)
+awg.write_segment(seg1, segment=1)
+awg.configure_step(step=0, segment=0, nextstep=1, loop=10, condition=SPCSEQ_ENDLOOPONTRIG)
+awg.configure_step(step=1, segment=1, nextstep=1, loop=10, condition=SPCSEQ_END)
+
+while True:
+ command = input("command: ")
+ if command == 's': # stop on s
+ awg.stop()
+ sys.stdout.write("stopping card\n")
+ break
+ elif command == 'c':
+ awg.force_trigger()
+ else:
+ sys.stdout.write("nothing")
+awg.close()
+
+
diff --git a/Python/spcm_tools.py b/Python/spcm_tools.py
new file mode 100644
index 0000000000000000000000000000000000000000..b6462566d2bf34dcb8323a2679a5ef22fd998084
--- /dev/null
+++ b/Python/spcm_tools.py
@@ -0,0 +1,57 @@
+from ctypes import *
+
+# load registers for easier access
+from py_header.regs import *
+
+#
+# **************************************************************************
+# szTypeToName: doing name translation
+# **************************************************************************
+#
+def szTypeToName (lCardType):
+ sName = ''
+ lVersion = (lCardType & TYP_VERSIONMASK)
+ if (lCardType & TYP_SERIESMASK) == TYP_M2ISERIES:
+ sName = 'M2i.%04x'%lVersion
+ elif (lCardType & TYP_SERIESMASK) == TYP_M2IEXPSERIES:
+ sName = 'M2i.%04x-Exp'%lVersion
+ elif (lCardType & TYP_SERIESMASK) == TYP_M3ISERIES:
+ sName = 'M3i.%04x'%lVersion
+ elif (lCardType & TYP_SERIESMASK) == TYP_M3IEXPSERIES:
+ sName = 'M3i.%04x-Exp'%lVersion
+ elif (lCardType & TYP_SERIESMASK) == TYP_M4IEXPSERIES:
+ sName = 'M4i.%04x-x8'%lVersion
+ elif (lCardType & TYP_SERIESMASK) == TYP_M4XEXPSERIES:
+ sName = 'M4x.%04x-x4'%lVersion
+ elif (lCardType & TYP_SERIESMASK) == TYP_M2PEXPSERIES:
+ sName = 'M2p.%04x-x4'%lVersion
+ elif (lCardType & TYP_SERIESMASK) == TYP_M5IEXPSERIES:
+ sName = 'M5i.%04x-x16'%lVersion
+ else:
+ sName = 'unknown type'
+ return sName
+
+
+
+#
+# **************************************************************************
+# pvAllocMemPageAligned: creates a buffer for DMA that's page-aligned
+# **************************************************************************
+#
+def pvAllocMemPageAligned (qwBytes):
+ dwAlignment = 4096
+ dwMask = dwAlignment - 1
+
+ # allocate non-aligned, slightly larger buffer
+ qwRequiredNonAlignedBytes = qwBytes * sizeof (c_char) + dwMask
+ pvNonAlignedBuf = (c_char * qwRequiredNonAlignedBytes)()
+
+ # get offset of next aligned address in non-aligned buffer
+ misalignment = addressof (pvNonAlignedBuf) & dwMask
+ if misalignment:
+ dwOffset = dwAlignment - misalignment
+ else:
+ dwOffset = 0
+ return (c_char * qwBytes).from_buffer (pvNonAlignedBuf, dwOffset)
+
+