def AcquireData(board):
# No pre-trigger samples in NPT mode
preTriggerSamples = 0
# TODO: Select the number of samples per record.
postTriggerSamples = 2048
# TODO: Select the number of records per DMA buffer.
recordsPerBuffer = 10
# TODO: Select the number of buffers per acquisition.
buffersPerAcquisition = 10
# TODO: Select the active channels.
channels = ats.CHANNEL_A | ats.CHANNEL_B
channelCount = 0
for c in ats.channels:
channelCount += (c & channels == c)
# TODO: Should data be saved to file?
saveData = False
dataFile = None
if saveData:
dataFile = open(os.path.join(os.path.dirname(__file__),
"data.bin"), 'wb')
# Compute the number of bytes per record and per buffer
memorySize_samples, bitsPerSample = board.getChannelInfo()
bytesPerSample = (bitsPerSample.value + 7) // 8
samplesPerRecord = preTriggerSamples + postTriggerSamples
bytesPerRecord = bytesPerSample * samplesPerRecord
bytesPerBuffer = bytesPerRecord * recordsPerBuffer * channelCount
# TODO: Select number of DMA buffers to allocate
bufferCount = 4
# Allocate DMA buffers
sample_type = ctypes.c_uint8
if bytesPerSample > 1:
sample_type = ctypes.c_uint16
buffers = []
for i in range(bufferCount):
buffers.append(ats.DMABuffer(board.handle, sample_type, bytesPerBuffer))
# Set the record size
board.setRecordSize(preTriggerSamples, postTriggerSamples)
recordsPerAcquisition = recordsPerBuffer * buffersPerAcquisition
# Configure the board to make an NPT AutoDMA acquisition
board.beforeAsyncRead(channels,
-preTriggerSamples,
samplesPerRecord,
recordsPerBuffer,
recordsPerAcquisition,
ats.ADMA_EXTERNAL_STARTCAPTURE | ats.ADMA_NPT)
# Post DMA buffers to board
for buffer in buffers:
board.postAsyncBuffer(buffer.addr, buffer.size_bytes)
start = time.clock() # Keep track of when acquisition started
try:
board.startCapture() # Start the acquisition
print("Capturing %d buffers. Press <enter> to abort" %
buffersPerAcquisition)
buffersCompleted = 0
bytesTransferred = 0
while (buffersCompleted < buffersPerAcquisition and not
ats.enter_pressed()):
# Wait for the buffer at the head of the list of available
# buffers to be filled by the board.
buffer = buffers[buffersCompleted % len(buffers)]
board.waitAsyncBufferComplete(buffer.addr, timeout_ms=5000)
buffersCompleted += 1
bytesTransferred += buffer.size_bytes
# TODO: Process sample data in this buffer. Data is available
# as a NumPy array at buffer.buffer
# NOTE:
#
# While you are processing this buffer, the board is already
# filling the next available buffer(s).
#
# You MUST finish processing this buffer and post it back to the
# board before the board fills all of its available DMA buffers
# and on-board memory.
#
# Samples are arranged in the buffer as follows:
# S0A, S0B, ..., S1A, S1B, ...
# with SXY the sample number X of channel Y.
#
# A 12-bit sample code is stored in the most significant bits of
# each 16-bit sample value.
#
# Sample codes are unsigned by default. As a result:
# - 0x0000 represents a negative full scale input signal.
# - 0x8000 represents a ~0V signal.
# - 0xFFFF represents a positive full scale input signal.
# Optionaly save data to file
if dataFile:
buffer.buffer.tofile(dataFile)
# Add the buffer to the end of the list of available buffers.
board.postAsyncBuffer(buffer.addr, buffer.size_bytes)
finally:
board.abortAsyncRead()
# Compute the total transfer time, and display performance information.
transferTime_sec = time.clock() - start
print("Capture completed in %f sec" % transferTime_sec)
buffersPerSec = 0
bytesPerSec = 0
recordsPerSec = 0
if transferTime_sec > 0:
buffersPerSec = buffersCompleted / transferTime_sec
bytesPerSec = bytesTransferred / transferTime_sec
recordsPerSec = recordsPerBuffer * buffersCompleted / transferTime_sec
print("Captured %d buffers (%f buffers per sec)" %
(buffersCompleted, buffersPerSec))
print("Captured %d records (%f records per sec)" %
(recordsPerBuffer * buffersCompleted, recordsPerSec))
print("Transferred %d bytes (%f bytes per sec)" %
(bytesTransferred, bytesPerSec))
def AcquireData(boards):
# TODO: Select the total acquisition length in seconds
acquisitionLength_sec = 1.
# TODO: Select the number of samples in each DMA buffer
samplesPerBuffer = 204800
# TODO: Select the active channels.
channels = ats.CHANNEL_A
channelCount = 0
for c in ats.channels:
channelCount += (c & channels == c)
# TODO: Should data be saved to file?
saveData = False
dataFile = None
if saveData:
dataFile = open(os.path.join(os.path.dirname(__file__), "data.bin"),
'wb')
# Make sure that boards[0] is the system's master
if boards[0].boardId != 1:
raise ValueError("The first board passed should be the master.")
for board in boards:
if board.systemId != boards[0].systemId:
raise ValueError("All the boards should be of the same system.")
# Compute the number of bytes per record and per buffer
memorySize_samples, bitsPerSample = boards[0].getChannelInfo()
bytesPerSample = (bitsPerSample.value + 7) // 8
bytesPerBuffer = bytesPerSample * samplesPerBuffer * channelCount
# Calculate the number of buffers in the acquisition
samplesPerAcquisition = int(samplesPerSec * acquisitionLength_sec + 0.5)
buffersPerAcquisition = ((samplesPerAcquisition + samplesPerBuffer - 1) //
samplesPerBuffer)
# TODO: Select number of DMA buffers to allocate
bufferCount = 4
buffers = []
for b in range(len(boards)):
# Allocate DMA buffers
sample_type = ctypes.c_uint8
if bytesPerSample > 1:
sample_type = ctypes.c_uint16
buffers.append([])
for i in range(bufferCount):
buffers[b].append(
ats.DMABuffer(board.handle, sample_type, bytesPerBuffer))
boards[b].beforeAsyncRead(
channels,
0, # Must be 0
samplesPerBuffer,
1, # Must be 1
0x7FFFFFFF, # Ignored
ats.ADMA_EXTERNAL_STARTCAPTURE | ats.ADMA_CONTINUOUS_MODE
| ats.ADMA_FIFO_ONLY_STREAMING)
# Post DMA buffers to board
for buffer in buffers[b]:
boards[b].postAsyncBuffer(buffer.addr, buffer.size_bytes)
start = time.clock() # Keep track of when acquisition started
try:
boards[0].startCapture() # Start the acquisition
buffersPerAcquisitionAllBoards = len(boards) * buffersPerAcquisition
print("Capturing {} buffers. Press <enter> to abort".format(
buffersPerAcquisitionAllBoards))
buffersCompletedPerBoard = 0
buffersCompletedAllBoards = 0
bytesTransferredAllBoards = 0
while (buffersCompletedPerBoard < buffersPerAcquisition
and not ats.enter_pressed()):
for b in range(len(boards)):
# Wait for the buffer at the head of the list of available
# buffers to be filled by the board.
buffer = buffers[b][buffersCompletedPerBoard % len(buffers[b])]
boards[b].waitAsyncBufferComplete(buffer.addr, timeout_ms=5000)
buffersCompletedAllBoards += 1
bytesTransferredAllBoards += buffer.size_bytes
# TODO: Process sample data in this buffer. Data is available
# as a NumPy array at buffer.buffer
# NOTE:
#
# While you are processing this buffer, the board is already
# filling the next available buffer(s).
#
# You MUST finish processing this buffer and post it back to the
# board before the board fills all of its available DMA buffers
# and on-board memory.
#
# Samples are arranged in the buffer as follows:
# S0A, S0B, ..., S1A, S1B, ...
# with SXY the sample number X of channel Y.
#
# A 12-bit sample code is stored in the most significant bits of
# each 16-bit sample value.
#
# Sample codes are unsigned by default. As a result:
# - 0x0000 represents a negative full scale signal.
# - 0x8000 represents a ~0V signal.
# - 0xFFFF represents a positive full scale signal.
# Optionaly save data to file
if dataFile:
buffer.buffer.tofile(dataFile)
# Add the buffer to the end of the list of available buffers.
boards[b].postAsyncBuffer(buffer.addr, buffer.size_bytes)
buffersCompletedPerBoard += 1
finally:
board.abortAsyncRead()
# Compute the total transfer time, and display performance information.
transferTime_sec = time.clock() - start
print("Capture completed in %f sec" % transferTime_sec)
buffersPerSec = 0
bytesPerSec = 0
if transferTime_sec > 0:
buffersPerSec = buffersCompletedAllBoards / transferTime_sec
bytesPerSec = bytesTransferredAllBoards / transferTime_sec
print("Captured %d buffers (%f buffers per sec)" %
(buffersCompletedAllBoards, buffersPerSec))
print("Transferred %d bytes (%f bytes per sec)" %
(bytesTransferredAllBoards, bytesPerSec))
def acquire_data(daq_params, alazar_params, board, verbose=True):
rec_avg_all = []
rec_readout = []
# No pre-trigger samples in NPT mode
preTriggerSamples = 0
# Select the number of samples per record.
post_trigger_samples = alazar_params.post_trigger_samples
# Select the number0 of records per DMA buffer.
records_per_buffer = alazar_params.records_per_buffer #2**10 # up to 2**14
# Select the number of buffers per acquisition.
buffers_per_acquisition = alazar_params.buffers_per_acquisition
records_per_acquisition = records_per_buffer * buffers_per_acquisition
# Select the active channels.
channels = ats.CHANNEL_A | ats.CHANNEL_B
channelCount = 0
for c in ats.channels:
channelCount += (c & channels == c)
# Should data be saved to file?
saveData = False
dataFile = None
if saveData:
dataFile = open(os.path.join(os.path.dirname(__file__),
"data.bin"), 'wb')
# Compute the number of bytes per record and per buffer
memorySize_samples, bitsPerSample = board.getChannelInfo()
bytesPerSample = (bitsPerSample.value + 7) // 8
samplesPerRecord = preTriggerSamples + post_trigger_samples
bytesPerRecord = bytesPerSample * samplesPerRecord
bytesPerBuffer = bytesPerRecord * records_per_buffer * channelCount
# Select number of DMA buffers to allocate
buffer_count = alazar_params.buffer_count
# Allocate DMA buffers
sample_type = ctypes.c_uint8
if bytesPerSample > 1:
sample_type = ctypes.c_uint16
buffers = []
for i in range(buffer_count):
buffers.append(ats.DMABuffer(board.handle, sample_type, bytesPerBuffer))
# Set the record size
board.setRecordSize(preTriggerSamples, post_trigger_samples)
# Configure the board to make an NPT AutoDMA acquisition
board.beforeAsyncRead(channels,
-preTriggerSamples,
samplesPerRecord,
records_per_buffer,
records_per_acquisition,
ats.ADMA_EXTERNAL_STARTCAPTURE | ats.ADMA_NPT)
index_avg_start = daq_params.readout_start
index_avg_end = daq_params.readout_start + daq_params.readout_duration - 1
index_ch = [None]*2
index_ch[0] = np.arange(0,post_trigger_samples*records_per_buffer) # channel A
index_ch[1] = post_trigger_samples*records_per_buffer + np.arange(0,post_trigger_samples*records_per_buffer) # channel B
rec_all_raw = [None]*2
rec_avg_all = [None]*2
rec_readout = [[]]*2
# Post DMA buffers to board
for buffer in buffers:
board.postAsyncBuffer(buffer.addr, buffer.size_bytes)
start = time.clock() # Keep track of when acquisition started
# start SRS DG535 triggers
dg535_control.set_state(1)
try:
board.startCapture() # Start the acquisition
if verbose:
print("Capturing %d buffers. Press <enter> to abort" %
buffers_per_acquisition)
buffersCompleted = 0
bytesTransferred = 0
while (buffersCompleted < buffers_per_acquisition and not
ats.enter_pressed()):
# Wait for the buffer at the head of the list of available
# buffers to be filled by the board.
buffer = buffers[buffersCompleted % len(buffers)]
board.waitAsyncBufferComplete(buffer.addr, timeout_ms=5000)
buffersCompleted += 1
bytesTransferred += buffer.size_bytes
#
for idx, idx_ch in enumerate(index_ch):
rec_all_raw[idx] = np.reshape(buffer.buffer[idx_ch], (records_per_buffer, post_trigger_samples))
#
rec_all = rotate_iq(daq_params.iq_angle_deg, rec_all_raw)
#
for idx in [0, 1]:
rec_avg_all[idx] = np.mean(rec_all[idx], axis=0) # is this just the avg of the last loop?
rec_readout[idx] = np.concatenate((rec_readout[idx], np.mean(rec_all[idx][:,index_avg_start:index_avg_end], axis=1)))
# NOTE:
#
# While you are processing this buffer, the board is already
# filling the next available buffer(s).
#
# You MUST finish processing this buffer and post it back to the
# board before the board fills all of its available DMA buffers
# and on-board memory.
#
# Samples are arranged in the buffer as follows:
# S0A, S0B, ..., S1A, S1B, ...
# with SXY the sample number X of channel Y.
#
# Sample code are stored as 8-bit values.
#
# Sample codes are unsigned by default. As a result:
# - 0x00 represents a negative full scale input signal.
# - 0x80 represents a ~0V signal.
# - 0xFF represents a positive full scale input signal.
# Optionaly save data to file
if dataFile:
buffer.buffer.tofile(dataFile)
# Add the buffer to the end of the list of available buffers.
board.postAsyncBuffer(buffer.addr, buffer.size_bytes)
finally:
board.abortAsyncRead()
# stop SRS DG535 triggers
dg535_control.set_state(0)
# Compute the total transfer time, and display performance information.
if verbose:
transferTime_sec = time.clock() - start
print("Capture completed in %f sec" % transferTime_sec)
buffersPerSec = 0
bytesPerSec = 0
recordsPerSec = 0
if transferTime_sec > 0:
buffersPerSec = buffersCompleted / transferTime_sec
bytesPerSec = bytesTransferred / transferTime_sec
recordsPerSec = records_per_buffer * buffersCompleted / transferTime_sec
print("Captured %d buffers (%f buffers per sec)" %
(buffersCompleted, buffersPerSec))
print("Captured %d records (%f records per sec)" %
(records_per_buffer * buffersCompleted, recordsPerSec))
print("Transferred %d bytes (%f bytes per sec)" %
(bytesTransferred, bytesPerSec))
return (rec_avg_all, rec_readout)
def AcquireData(board):
# TODO: Select the number of pre-trigger samples
preTriggerSamples = 1024
# TODO: Select the number of samples per record.
postTriggerSamples = 1024
# TODO: Select the number of records in the acquisition.
recordsPerCapture = 100
# TODO: Select the amount of time to wait for the acquisition to
# complete to on-board memory.
acquisition_timeout_sec = 10
# TODO: Select the active channels.
channels = ats.CHANNEL_A | ats.CHANNEL_B
channelCount = 0
for c in ats.channels:
channelCount += (c & channels == c)
# TODO: Should data be saved to file?
saveData = False
dataFile = None
if saveData:
dataFile = open(os.path.join(os.path.dirname(__file__), "data.bin"),
'wb')
# Compute the number of bytes per record and per buffer
memorySize_samples, bitsPerSample = board.getChannelInfo()
bytesPerSample = (bitsPerSample.value + 7) // 8
samplesPerRecord = preTriggerSamples + postTriggerSamples
bytesPerRecord = bytesPerSample * samplesPerRecord
# Calculate the size of a record buffer in bytes. Note that the
# buffer must be at least 16 bytes larger than the transfer size.
bytesPerBuffer = (bytesPerSample * (samplesPerRecord + 0))
# Set the record size
board.setRecordSize(preTriggerSamples, postTriggerSamples)
# Configure the number of records in the acquisition
board.setRecordCount(recordsPerCapture)
start = time.clock() # Keep track of when acquisition started
board.startCapture() # Start the acquisition
print("Capturing %d record. Press <enter> to abort" % recordsPerCapture)
buffersCompleted = 0
bytesTransferred = 0
while not ats.enter_pressed():
if not board.busy():
# Acquisition is done
break
if time.clock() - start > acquisition_timeout_sec:
board.abortCapture()
raise Exception("Error: Capture timeout. Verify trigger")
time.sleep(10e-3)
captureTime_sec = time.clock() - start
recordsPerSec = 0
if captureTime_sec > 0:
recordsPerSec = recordsPerCapture / captureTime_sec
print("Captured %d records in %f rec (%f records/sec)" %
(recordsPerCapture, captureTime_sec, recordsPerSec))
sample_type = ctypes.c_uint8
if bytesPerSample > 1:
sample_type = ctypes.c_uint16
buffer = ats.DMABuffer(board.handle, sample_type, bytesPerBuffer + 16)
# Transfer the records from on-board memory to our buffer
print("Transferring %d records..." % recordsPerCapture)
for record in range(recordsPerCapture):
if ats.enter_pressed():
break
for channel in range(channelCount):
channelId = ats.channels[channel]
if channelId & channels == 0:
continue
board.read(
channelId, # Channel identifier
buffer.addr, # Memory address of buffer
bytesPerSample, # Bytes per sample
record + 1, # Record (1-indexed)
-preTriggerSamples, # Pre-trigger samples
samplesPerRecord) # Samples per record
bytesTransferred += bytesPerRecord
# Records are arranged in the buffer as follows:
# R0A, R1A, R2A ... RnA, R0B, R1B, R2B ...
#
# Sample code are stored as 8-bit values.
#
# Sample codes are unsigned by default. As a result:
# - 0x00 represents a negative full scale input signal.
# - 0x80 represents a ~0V signal.
# - 0xFF represents a positive full scale input signal.
# Optionaly save data to file
if dataFile:
buffer.buffer[:samplesPerRecord].tofile(dataFile)
if ats.enter_pressed():
break
# Compute the total transfer time, and display performance information.
transferTime_sec = time.clock() - start
bytesPerSec = 0
if transferTime_sec > 0:
bytesPerSec = bytesTransferred / transferTime_sec
print("Transferred %d bytes (%f bytes per sec)" %
(bytesTransferred, bytesPerSec))
def AcquireData(board):
# TODO: Select the number of pre-trigger samples
preTriggerSamples = 1024
# TODO: Select the number of samples per record.
postTriggerSamples = 1024
# TODO: Select the number of records in the acquisition.
recordsPerCapture = 100
# TODO: Select the amount of time to wait for the acquisition to
# complete to on-board memory.
acquisition_timeout_sec = 10
# TODO: Select the active channels.
channels = ats.CHANNEL_A | ats.CHANNEL_B
channelCount = 0
for c in ats.channels:
channelCount += (c & channels == c)
# TODO: Should data be saved to file?
saveData = False
dataFile = 'TEST'
if saveData:
dataFile = open(os.path.join(os.path.dirname(__file__),
"data.bin"), 'w')
# Compute the number of bytes per record and per buffer
memorySize_samples, bitsPerSample = board.getChannelInfo()
bytesPerSample = (bitsPerSample.value + 7) // 8
samplesPerRecord = preTriggerSamples + postTriggerSamples
bytesPerRecord = bytesPerSample * samplesPerRecord
# Calculate the size of a record buffer in bytes. Note that the
# buffer must be at least 16 bytes larger than the transfer size.
bytesPerBuffer = (bytesPerSample *
(samplesPerRecord + 0))
# Set the record size
board.setRecordSize(preTriggerSamples, postTriggerSamples)
# Configure the number of records in the acquisition
board.setRecordCount(recordsPerCapture)
start = time.clock() # Keep track of when acquisition started
board.startCapture() # Start the acquisition
# print("Capturing %d record. Press <enter> to abort" % recordsPerCapture)
buffersCompleted = 0
bytesTransferred = 0
while not ats.enter_pressed():
if not board.busy():
# Acquisition is done
break
if time.clock() - start > acquisition_timeout_sec:
board.abortCapture()
raise Exception("Error: Capture timeout. Verify trigger")
time.sleep(10e-3)
captureTime_sec = time.clock() - start
recordsPerSec = 0
if captureTime_sec > 0:
recordsPerSec = recordsPerCapture / captureTime_sec
# print("Captured %d records in %f rec (%f records/sec)" %
# (recordsPerCapture, captureTime_sec, recordsPerSec))
buffer = ats.DMABuffer(bytesPerSample, bytesPerBuffer + 16)
# Transfer the records from on-board memory to our buffer
print("Transferring %d records..." % recordsPerCapture)
for record in range(recordsPerCapture):
if ats.enter_pressed():
break
for channel in range(channelCount):
channelId = ats.channels[channel]
if channelId & channels == 0:
continue
board.read(channelId, # Channel identifier
buffer.addr, # Memory address of buffer
bytesPerSample, # Bytes per sample
record + 1, # Record (1-indexed)
-preTriggerSamples, # Pre-trigger samples
samplesPerRecord) # Samples per record
bytesTransferred += bytesPerRecord;
# Records are arranged in the buffer as follows:
# R0A, R1A, R2A ... RnA, R0B, R1B, R2B ...
#
# Sample code are stored as 8-bit values.
#
# Sample codes are unsigned by default. As a result:
# - 0x00 represents a negative full scale input signal.
# - 0x80 represents a ~0V signal.
# - 0xFF represents a positive full scale input signal.
# Optionaly save data to file
if dataFile:
buffer.buffer[:samplesPerRecord].tofile(dataFile)
if ats.enter_pressed():
break
# Compute the total transfer time, and display performance information.
transferTime_sec = time.clock() - start
bytesPerSec = 0
if transferTime_sec > 0:
bytesPerSec = bytesTransferred / transferTime_sec
print("Transferred %d bytes (%f bytes per sec)" %
(bytesTransferred, bytesPerSec))
def AcquireData(board, fft_module, recordLength_samples):
# TODO: Specify the number of records per DMA buffer
recordsPerBuffer = 10
# TODO: Specify the total number of buffers to capture
buffersPerAcquisition = 10
# TODO: Select the active channels.
channels = ats.CHANNEL_A
channelCount = 0
for c in ats.channels:
channelCount += (c & channels == c)
# TODO: Select the FFT output format
outputFormat = ats.FFT_OUTPUT_FORMAT_U16_LOG
# TODO: Select the presence of NPT footers
footer = ats.FFT_FOOTER_NONE
# Compute the number of bytes per record and per buffer
memorySize_samples, bitsPerSample = board.getChannelInfo()
# TODO: Should data be saved to file?
saveData = False
dataFile = None
if saveData:
dataFile = open(os.path.join(os.path.dirname(__file__), "data.bin"),
'wb')
# Configure the FFT
fftLength_samples = 1
while fftLength_samples < recordLength_samples:
fftLength_samples *= 2
bytesPerOutputRecord = fft_module.fftSetup(channels, recordLength_samples,
fftLength_samples, outputFormat,
footer, 0)
bytesPerBuffer = bytesPerOutputRecord * recordsPerBuffer
# TODO: Select number of DMA buffers to allocate
bufferCount = 4
# Allocate DMA buffers
if ((outputFormat == ats.FFT_OUTPUT_FORMAT_U8_LOG)
or (outputFormat == ats.FFT_OUTPUT_FORMAT_U8_AMP2)):
sample_type = ctypes.c_uint8
elif ((outputFormat == ats.FFT_OUTPUT_FORMAT_U16_LOG)
or (outputFormat == ats.FFT_OUTPUT_FORMAT_U16_AMP2)):
sample_type = ctypes.c_uint16
elif (outputFormat == ats.FFT_OUTPUT_FORMAT_U32):
sample_type = ctypes.c_uint32
elif ((outputFormat == ats.FFT_OUTPUT_FORMAT_REAL_S32)
or (outputFormat == ats.FFT_OUTPUT_FORMAT_IMAG_S32)):
sample_type = ctypes.c_int32
else:
sample_type = ctypes.c_float
buffers = []
for i in range(bufferCount):
buffers.append(ats.DMABuffer(board.handle, sample_type,
bytesPerBuffer))
# Configure the board to make an NPT AutoDMA acquisition
board.beforeAsyncRead(
channels, 0, bytesPerOutputRecord, recordsPerBuffer, 0x7FFFFFFF,
ats.ADMA_EXTERNAL_STARTCAPTURE | ats.ADMA_NPT | ats.ADMA_DSP)
# Post DMA buffers to board
for buffer in buffers:
board.postAsyncBuffer(buffer.addr, buffer.size_bytes)
start = time.clock() # Keep track of when acquisition started
try:
board.startCapture() # Start the acquisition
print("Capturing %d buffers. Press <enter> to abort" %
buffersPerAcquisition)
buffersCompleted = 0
bytesTransferred = 0
while (buffersCompleted < buffersPerAcquisition
and not ats.enter_pressed()):
# Wait for the buffer at the head of the list of available
# buffers to be filled by the board.
timeout_ms = 5000
buffer = buffers[buffersCompleted % len(buffers)]
board.dspGetBuffer(buffer.addr, timeout_ms)
buffersCompleted += 1
bytesTransferred += buffer.size_bytes
# TODO: Process sample data in this buffer. Data is available
# as a NumPy array at buffer.buffer
# NOTE:
#
# While you are processing this buffer, the board is already
# filling the next available buffer(s).
#
# You MUST finish processing this buffer and post it back to the
# board before the board fills all of its available DMA buffers
# and on-board memory.
#
# Samples are arranged in the buffer as follows:
# S0A, S0B, ..., S1A, S1B, ...
# with SXY the sample number X of channel Y.
#
# A 12-bit sample code is stored in the most significant bits of
# each 16-bit sample value.
#
# Sample codes are unsigned by default. As a result:
# - 0x0000 represents a negative full scale input signal.
# - 0x8000 represents a ~0V signal.
# - 0xFFFF represents a positive full scale input signal.
# Optionaly save data to file
if dataFile:
buffer.buffer.tofile(dataFile)
# Add the buffer to the end of the list of available buffers.
board.postAsyncBuffer(buffer.addr, buffer.size_bytes)
finally:
board.dspAbortCapture()
if dataFile:
dataFile.close()
# Compute the total transfer time, and display performance information.
transferTime_sec = time.clock() - start
print("Capture completed in %f sec" % transferTime_sec)
buffersPerSec = 0
bytesPerSec = 0
recordsPerSec = 0
if transferTime_sec > 0:
buffersPerSec = buffersCompleted / transferTime_sec
bytesPerSec = bytesTransferred / transferTime_sec
recordsPerSec = recordsPerBuffer * buffersCompleted / transferTime_sec
print("Captured %d buffers (%f buffers per sec)" %
(buffersCompleted, buffersPerSec))
print("Captured %d records (%f records per sec)" %
(recordsPerBuffer * buffersCompleted, recordsPerSec))
print("Transferred %d bytes (%f bytes per sec)" %
(bytesTransferred, bytesPerSec))
def AcquireData_OCT_RT(board, preTriggerSamples, postTriggerSamples, recordsPerBuffer, buffersPerAcquisition,channel_sel):
# TODO: Select the active channels.
if channel_sel == "B":
channels = ats.CHANNEL_B
elif channel_sel =="A":
channels = ats.CHANNEL_A
channelCount = 0
for c in ats.channels:
channelCount += (c & channels == c)
# Compute the number of bytes per record and per buffer
memorySize_samples, bitsPerSample = board.getChannelInfo()
bytesPerSample = (bitsPerSample.value + 7) // 8
samplesPerRecord = preTriggerSamples + postTriggerSamples
bytesPerRecord = bytesPerSample * samplesPerRecord
bytesPerBuffer = bytesPerRecord * recordsPerBuffer * channelCount
# TODO: Select number of DMA buffers to allocate
bufferCount = 4
# Allocate DMA buffers
sample_type = ctypes.c_uint8
if bytesPerSample > 1:
sample_type = ctypes.c_uint16
buffers = []
for i in range(bufferCount):
buffers.append(ats.DMABuffer(board.handle, sample_type, bytesPerBuffer))
# Set the record size
board.setRecordSize(preTriggerSamples, postTriggerSamples)
recordsPerAcquisition = recordsPerBuffer * buffersPerAcquisition
# Configure the board to make an NPT AutoDMA acquisition
board.beforeAsyncRead(channels,
-preTriggerSamples,
samplesPerRecord,
recordsPerBuffer,
recordsPerAcquisition,
ats.ADMA_EXTERNAL_STARTCAPTURE | ats.ADMA_TRADITIONAL_MODE)
# Post DMA buffers to board
for buffer in buffers:
board.postAsyncBuffer(buffer.addr, buffer.size_bytes)
# start = time.perf_counter() # Keep track of when acquisition started
try:
board.startCapture() # Start the acquisition
print("Capturing %d buffers. Press <enter> to abort" %
buffersPerAcquisition)
buffersCompleted = 0
bytesTransferred = 0
while (buffersCompleted < buffersPerAcquisition and not
ats.enter_pressed()):
# Wait for the buffer at the head of the list of available
# buffers to be filled by the board.
buffer = buffers[buffersCompleted % len(buffers)]
board.waitAsyncBufferComplete(buffer.addr, timeout_ms=5000)
buffersCompleted += 1
bytesTransferred += buffer.size_bytes
# TODO: Process sample data in this buffer. Data is available
# as a NumPy array at buffer.buffer
# NOTE:
#
# While you are processing this buffer, the board is already
# filling the next available buffer(s).
#
# You MUST finish processing this buffer and post it back to the
# board before the board fills all of its available DMA buffers
# and on-board memory.
#
# Samples are arranged in the buffer as follows:
# S0A, S0B, ..., S1A, S1B, ...
# with SXY the sample number X of channel Y.
#
# A 12-bit sample code is stored in the most significant bits of
# each 16-bit sample value.
#
# Sample codes are unsigned by default. As a result:
# - 0x0000 represents a negative full scale input signal.
# - 0x8000 represents a ~0V signal.
# - 0xFFFF represents a positive full scale input signal.
# Optionaly save data to file
# print(buffer.buffer)
# if dataFile:
# buffer.buffer.tofile(dataFile)
n = 0
sampleValue = []
for i in range(0, len(buffer.buffer)):
val = bin(buffer.buffer[i] >> 4)
val = int(val, 2)
sampleValue.append(val)
sampleValue = np.array(sampleValue)
reshapedSampleValue = sampleValue.reshape(recordsPerBuffer*channelCount, -1)
data_ampl = reshapedSampleValue
data_ampl_avg = np.mean(data_ampl, axis = 0)
data_ampl_avg = np.transpose(data_ampl_avg)
return data_ampl_avg
# Add the buffer to the end of the list of available buffers.
board.postAsyncBuffer(buffer.addr, buffer.size_bytes)
finally:
board.abortAsyncRead()