void AUEffectBase::MaintainKernels()
{
#if TARGET_OS_IPHONE
UInt32 nKernels = mOnlyOneKernel ? 1 : GetNumberOfChannels();
#else
UInt32 nKernels = GetNumberOfChannels();
#endif
if (mKernelList.size() < nKernels) {
mKernelList.reserve(nKernels);
for (UInt32 i = (UInt32)mKernelList.size(); i < nKernels; ++i)
mKernelList.push_back(NewKernel());
} else {
while (mKernelList.size() > nKernels) {
AUKernelBase *kernel = mKernelList.back();
delete kernel;
mKernelList.pop_back();
}
}
for(unsigned int i = 0; i < nKernels; i++ )
{
if(mKernelList[i]) {
mKernelList[i]->SetChannelNum (i);
}
}
}
Channel* Measurement::GetChannel(int ch)
{
// FILE_LOG(logDEBUG3) << "Measurement::GetChannel (channel=" << ch << ")";
int n = GetNumberOfChannels();
if(ch>=0 && ch<n) {
// FILE_LOG(logDEBUG4) << "Measurement::GetChannel -> channel " << (char)('A'+ch) << " - " << channels[ch] << ", index " << channels[ch]->GetIndex();
return channels[ch];
} else {
char message[200];
sprintf(message, "Picoscope has only channels 0-%d. You cannot request channel with number %d",
GetNumberOfChannels(), ch);
throw(message);
return NULL;
}
}
Measurement::Measurement(Picoscope *p)
{
FILE_LOG(logDEBUG3) << "Measurement::Measurement (Picoscope=" << p << ")";
int i;
picoscope = p;
trigger = NULL;
is_triggered = false;
max_memory_consumption = 0;
max_trace_length_to_fetch = 0;
ntraces = 1;
max_traces_to_fetch = 1;
timebase_reported_by_osciloscope = 0.0;
use_signal_generator = false;
rate_per_second = 0.0;
for(i=0; i<GetNumberOfChannels(); i++) {
// initialize the channels
FILE_LOG(logDEBUG4) << "Measurement::Measurement - initialize channel nr. " << i;
channels[i]=new Channel(i, this);
data[i] = NULL;
data_allocated[i] = false;
data_length[i] = 0;
}
// only a temporary setting; this needs to be fixed if more than a single channel is enabled
timebase = 0UL;
}
void SonogramViewDemo::AllocateBuffers()
{
mBlockSize = 1024;
mNumBins = mBlockSize>>1;
if (mSpectrumBuffer) {
// delete calls deallocate
delete (mSpectrumBuffer);
}
mSpectrumBuffer = new CARingBuffer();
mSpectrumBuffer->Allocate(GetNumberOfChannels(), mNumBins*sizeof(Float32), kMaxSonogramLatency);
CAStreamBasicDescription bufClientDesc;
bufClientDesc.SetCanonical(GetNumberOfChannels(), false);
bufClientDesc.mSampleRate = GetSampleRate();
UInt32 frameLength = kDefaultValue_BufferSize*sizeof(Float32);
if (mFetchingBufferList) {
mFetchingBufferList->DeallocateBuffers();
delete(mFetchingBufferList);
}
mFetchingBufferList = CABufferList::New("fetch buffer", bufClientDesc );
mFetchingBufferList->AllocateBuffers(frameLength);
if (mSpectralDataBufferList) {
mSpectralDataBufferList->DeallocateBuffers();
delete(mSpectralDataBufferList);
}
mSpectralDataBufferList = CABufferList::New("temp buffer", bufClientDesc );
mSpectralDataBufferList->AllocateBuffers(frameLength);
memset (&mRenderStamp, 0, sizeof(AudioTimeStamp));
mRenderStamp.mFlags = kAudioTimeStampSampleTimeValid;
mSpectralProcessor.free();
mSpectralProcessor = new CASpectralProcessor(mBlockSize, mNumBins, GetNumberOfChannels(), GetMaxFramesPerSlice());
if (mMinAmp) free(mMinAmp);
mMinAmp = (Float32*) calloc(GetNumberOfChannels(), sizeof(Float32));
if (mMaxAmp) free(mMaxAmp);
mMaxAmp = (Float32*) calloc(GetNumberOfChannels(), sizeof(Float32));
}
void Measurement::AllocateMemoryRapidBlock(unsigned long bytes)
{
FILE_LOG(logDEBUG3) << "Measurement::AllocateMemoryRapidBlock (bytes=" << bytes << ")";
int i;
unsigned long maxtraces, maxlen, memlen;
SetMaxMemoryConsumption(bytes);
maxtraces = GetMaxTracesToFetch();
// TODO: one should not multiply with GetNumberOfEnabledChannels() !!!
maxlen = maxtraces*GetLength();
memlen = maxlen*sizeof(short)*GetNumberOfEnabledChannels();
std::cerr << "Allocating memory of length ";
if(memlen<1e3) {
std::cerr << memlen;
} else if(memlen<5e5) {
std::cerr << memlen*1e-3f << "k";
} else if(memlen<5e8) {
std::cerr << memlen*1e-6f << "M";
} else {
std::cerr << memlen*1e-9f << "G";
}
std::cerr << " ... ";
try {
for(i=0; i<GetNumberOfChannels(); i++) {
if(GetChannel(i)->IsEnabled()) {
if(data_allocated[i]) {
if(data_length[i] == maxlen) {
// no need to do anything; data is already allocated and of the proper size
// however it is still weird to call this function
std::cerr << "Warning: Memory for channel " << (char)('A'+i) << " has already been allocated.\n";
} else {
std::cerr << "Warning: Memory for channel " << (char)('A'+i) << " has already been allocated; changing size.\n";
delete [] data[i];
// std::cerr << "allocate channel " << i << " with size" << maxlen << "\n";
data[i] = new short[maxlen];
data_allocated[i] = true;
data_length[i] = maxlen;
}
} else {
std::cerr << "(allocate channel " << (char)(i+'A') << " with size " << maxlen << ")\n";
data[i] = new short[maxlen];
data_allocated[i] = true;
data_length[i] = maxlen;
}
}
}
FILE_LOG(logDEBUG4) << "!!!!!!!!!Measurement::AllocateMemoryBlock - maxlen=" << maxlen;
std::cerr << "OK\n";
} catch(...) {
std::cerr << "Unable to allocate memory in Measurement::AllocateMemoryBlock, tried to allocate " << bytes << "bytes." << std::endl;
throw;
}
}
// TODO: we might want to use multiple buffers at the same time
void Measurement::WriteDataBin(FILE *f, int channel)
{
Timing t;
long size_written;
int i, j;
const unsigned int length_datachunk = 1000000;
char data_8bit[1000000];
// std::vector<char>data_8bit(1000);
std::cerr << "Write binary data for channel " << (char)('A'+channel) << " ... ";
t.Start();
// TODO: test if file exists
if(channel < 0 || channel >= GetNumberOfChannels()) {
throw "You can only write data for channels 0 - (N-1).";
} else {
if(GetChannel(channel)->IsEnabled()) {
/*
size_written = fwrite(data[channel], sizeof(short), GetLengthFetched(), f);
// make sure the data is written
fflush(f);
if(size_written < GetLengthFetched()) {
FILE_LOG(logERROR) << "Measurement::WriteDataBin didn't manage to write to file.";
}*/
// TODO: if only 8 bits
int length_fetched = GetLengthFetched();
// int length_datachunk = data_8bit.size();
for(i=0; i<length_fetched; i+=length_datachunk) {
if(GetSeries() == PICO_6000) {
for(j=0; j<length_datachunk && i+j<length_fetched; j++) {
data_8bit[j] = data[channel][i+j] >> 8;
}
size_written = fwrite(data_8bit, sizeof(char), j, f);
} else {
// TODO: test!!!
size_written = fwrite(data[channel]+1, sizeof(data[0][0]), j, f);
}
fflush(f);
if(size_written < j) {
FILE_LOG(logERROR) << "Measurement::WriteDataBin didn't manage to write to file.";
}
}
// size_written = fwrite(data[channel], sizeof(short), GetLengthFetched(), f);
// make sure the data is written
// fflush(f);
// if(size_written < GetLengthFetched()) {
// FILE_LOG(logERROR) << "Measurement::WriteDataBin didn't manage to write to file.";
// }
} else {
OSStatus Talkbox::Initialize()
{
OSStatus status = AUEffectBase::Initialize();
if (status == noErr)
{
numAllocatedChannels = GetNumberOfChannels();
dspKernels = (TalkboxDSP**) malloc(numAllocatedChannels * sizeof(TalkboxDSP*));
for (UInt32 i=0; i < numAllocatedChannels; i++)
dspKernels[i] = new TalkboxDSP(this);
}
return status;
}
void WaveformViewDemo::AllocateBuffers()
{
if (mAudioBuffer) delete (mAudioBuffer);
mAudioBuffer = new CARingBuffer();
mAudioBuffer->Allocate(GetNumberOfChannels(), sizeof(Float32), kDefaultValue_BufferSize);
// unlike the spectral buffers we write one number at a time, the spectral ones do entire analysis at a time
CAStreamBasicDescription bufClientDesc;
bufClientDesc.SetCanonical(GetNumberOfChannels(), false);
bufClientDesc.mSampleRate = GetSampleRate();
if (mFetchingBufferList) {
mFetchingBufferList->DeallocateBuffers();
delete(mFetchingBufferList);
}
mFetchingBufferList = CABufferList::New("fetch buffer", bufClientDesc );
mFetchingBufferList->AllocateBuffers(sizeof(Float32) * kDefaultValue_BufferSize);
memset (&mRenderStamp, 0, sizeof(AudioTimeStamp));
mRenderStamp.mFlags = kAudioTimeStampSampleTimeValid;
}
XnStatus XnSensorAudioStream::ReallocBuffer()
{
XnStatus nRetVal = XN_STATUS_OK;
if (m_buffer.pAudioBuffer == NULL)
{
// we allocate enough for 5 seconds of audio
XnUInt32 nSampleSize = 2 * 2; // 16-bit per channel (2 bytes) * max number of channels (2)
XnUInt32 nSamples = 48000 * 5; // max sample rate * number of seconds
XnUInt32 nMaxBufferSize = nSamples * nSampleSize;
// find min packet size (so we'll have max packet count)
XnUInt32 nMinPacketSize = XN_MIN(XN_SENSOR_PROTOCOL_AUDIO_PACKET_SIZE_BULK, XN_SENSOR_PROTOCOL_AUDIO_PACKET_SIZE_ISO);
XnUInt32 nMaxPacketCount = nMaxBufferSize / nMinPacketSize - 1;
nRetVal = RequiredSizeProperty().UnsafeUpdateValue(nMaxBufferSize);
XN_IS_STATUS_OK(nRetVal);
m_buffer.pAudioPacketsTimestamps = (XnUInt64*)xnOSMallocAligned(sizeof(XnUInt64) * nMaxPacketCount, XN_DEFAULT_MEM_ALIGN);
m_buffer.pAudioBuffer = (XnUInt8*)xnOSMallocAligned(nMaxBufferSize, XN_DEFAULT_MEM_ALIGN);
m_buffer.nAudioBufferSize = nMaxBufferSize;
}
// calculate current packet size
m_buffer.nAudioPacketSize = m_nOrigAudioPacketSize;
if (m_Helper.GetFirmwareVersion() >= XN_SENSOR_FW_VER_5_2 && GetNumberOfChannels() == 1)
{
m_buffer.nAudioPacketSize /= 2;
}
m_buffer.nAudioBufferNumOfPackets = m_buffer.nAudioBufferSize / m_buffer.nAudioPacketSize;
m_buffer.nAudioBufferSize = m_buffer.nAudioBufferNumOfPackets * m_buffer.nAudioPacketSize;
m_header.nPacketCount = m_buffer.nAudioBufferNumOfPackets;
m_header.nPacketSize = m_buffer.nAudioPacketSize;
// set read and write indices
m_buffer.nAudioReadIndex = 0;
m_buffer.nAudioWriteIndex = 0;
return (XN_STATUS_OK);
}
Measurement::~Measurement()
{
FILE_LOG(logDEBUG3) << "Measurement::~Measurement";
int i;
for(i=0; i<GetNumberOfChannels(); i++) {
// delete the channels
delete channels[i];
// delete data
if(data_allocated[i]) {
delete [] data[i];
// not that it really matters now when the object is gone anyway
data_allocated[i] = false;
data_length[i] = 0;
}
}
if(trigger != NULL) {
delete trigger;
}
}
bool mitk::Image::IsValidSlice(int s, int t, int n) const
{
if(m_Initialized)
return ((s>=0) && (s<(int)m_Dimensions[2]) && (t>=0) && (t< (int) m_Dimensions[3]) && (n>=0) && (n< (int)GetNumberOfChannels()));
else
return false;
}
void mitk::Image::Initialize(const mitk::PixelType& type, unsigned int dimension, const unsigned int *dimensions, unsigned int channels)
{
Clear();
m_Dimension=dimension;
if(!dimensions)
itkExceptionMacro(<< "invalid zero dimension image");
unsigned int i;
for(i=0;i<dimension;++i)
{
if(dimensions[i]<1)
itkExceptionMacro(<< "invalid dimension[" << i << "]: " << dimensions[i]);
}
// create new array since the old was deleted
m_Dimensions = new unsigned int[MAX_IMAGE_DIMENSIONS];
// initialize the first four dimensions to 1, the remaining 4 to 0
FILL_C_ARRAY(m_Dimensions, 4, 1u);
FILL_C_ARRAY((m_Dimensions+4), 4, 0u);
// copy in the passed dimension information
std::memcpy(m_Dimensions, dimensions, sizeof(unsigned int)*m_Dimension);
this->m_ImageDescriptor = mitk::ImageDescriptor::New();
this->m_ImageDescriptor->Initialize( this->m_Dimensions, this->m_Dimension );
for(i=0;i<4;++i)
{
m_LargestPossibleRegion.SetIndex(i, 0);
m_LargestPossibleRegion.SetSize (i, m_Dimensions[i]);
}
m_LargestPossibleRegion.SetIndex(i, 0);
m_LargestPossibleRegion.SetSize(i, channels);
if(m_LargestPossibleRegion.GetNumberOfPixels()==0)
{
delete [] m_Dimensions;
m_Dimensions = NULL;
return;
}
for( unsigned int i=0u; i<channels; i++)
{
this->m_ImageDescriptor->AddNewChannel( type );
}
PlaneGeometry::Pointer planegeometry = PlaneGeometry::New();
planegeometry->InitializeStandardPlane(m_Dimensions[0], m_Dimensions[1]);
SlicedGeometry3D::Pointer slicedGeometry = SlicedGeometry3D::New();
slicedGeometry->InitializeEvenlySpaced(planegeometry, m_Dimensions[2]);
if(dimension>=4)
{
TimeBounds timebounds;
timebounds[0] = 0.0;
timebounds[1] = 1.0;
slicedGeometry->SetTimeBounds(timebounds);
}
ProportionalTimeGeometry::Pointer timeGeometry = ProportionalTimeGeometry::New();
timeGeometry->Initialize(slicedGeometry, m_Dimensions[3]);
for (TimeStepType step = 0; step < timeGeometry->CountTimeSteps(); ++step)
{
timeGeometry->GetGeometryForTimeStep(step)->ImageGeometryOn();
}
SetTimeGeometry(timeGeometry);
ImageDataItemPointer dnull=NULL;
m_Channels.assign(GetNumberOfChannels(), dnull);
m_Volumes.assign(GetNumberOfChannels()*m_Dimensions[3], dnull);
m_Slices.assign(GetNumberOfChannels()*m_Dimensions[3]*m_Dimensions[2], dnull);
ComputeOffsetTable();
Initialize();
m_Initialized = true;
}
XnStatus XnSensorAudioStream::ReallocBuffer()
{
XnStatus nRetVal = XN_STATUS_OK;
XnDevicePrivateData* pDevicePrivateData = m_Helper.GetPrivateData();
if (m_hSharedMemory == NULL)
{
// first time, create shared memory
// we allocate enough for 5 seconds of audio
XnUInt32 nSampleSize = 2 * 2; // 16-bit per channel (2 bytes) * max number of channels (2)
XnUInt32 nSamples = 48000 * 5; // max sample rate * number of seconds
XnUInt32 nMaxBufferSize = nSamples * nSampleSize;
// find min packet size (so we'll have max packet count)
XnUInt32 nMinPacketSize = XN_MIN(XN_SENSOR_PROTOCOL_AUDIO_PACKET_SIZE_BULK, XN_SENSOR_PROTOCOL_AUDIO_PACKET_SIZE_ISO);
XnUInt32 nMaxPacketCount = nMaxBufferSize / nMinPacketSize - 1;
XnUInt32 nSharedBufferSize =
sizeof(XnAudioSharedBuffer) + // header
sizeof(XnUInt64) * nMaxPacketCount + // packet timestamps
nMaxBufferSize;
// to make the name unique, we'll add process ID
XN_PROCESS_ID procID;
xnOSGetCurrentProcessID(&procID);
XnChar strSharedName[XN_DEVICE_MAX_STRING_LENGTH];
sprintf(strSharedName, "%u_%s_%s", procID, m_strDeviceName, GetName());
nRetVal = m_SharedBufferName.UnsafeUpdateValue(strSharedName);
XN_IS_STATUS_OK(nRetVal);
nRetVal = RequiredSizeProperty().UnsafeUpdateValue(nMaxBufferSize);
XN_IS_STATUS_OK(nRetVal);
nRetVal = xnOSCreateSharedMemory(strSharedName, nSharedBufferSize, XN_OS_FILE_READ | XN_OS_FILE_WRITE, &m_hSharedMemory);
XN_IS_STATUS_OK(nRetVal);
XnUChar* pAddress;
nRetVal = xnOSSharedMemoryGetAddress(m_hSharedMemory, (void**)&pAddress);
XN_IS_STATUS_OK(nRetVal);
m_pSharedHeader = (XnAudioSharedBuffer*)pAddress;
pDevicePrivateData->pAudioPacketsTimestamps = (XnUInt64*)(pAddress + sizeof(XnAudioSharedBuffer));
pDevicePrivateData->pAudioBuffer = (XN_AUDIO_TYPE*)(pAddress + sizeof(XnAudioSharedBuffer) + sizeof(XnUInt64) * nMaxPacketCount);
pDevicePrivateData->nAudioBufferSize = nMaxBufferSize;
m_pSharedHeader->nTimestampsListOffset = sizeof(XnAudioSharedBuffer);
m_pSharedHeader->nBufferOffset = pDevicePrivateData->pAudioBuffer - pAddress;
}
// calculate current packet size
pDevicePrivateData->nAudioPacketSize = m_nOrigAudioPacketSize;
if (m_Helper.GetFirmwareVersion() >= XN_SENSOR_FW_VER_5_2 && GetNumberOfChannels() == 1)
{
pDevicePrivateData->nAudioPacketSize /= 2;
}
pDevicePrivateData->nAudioBufferNumOfPackets = pDevicePrivateData->nAudioBufferSize / pDevicePrivateData->nAudioPacketSize;
pDevicePrivateData->nAudioBufferSize = pDevicePrivateData->nAudioBufferNumOfPackets * pDevicePrivateData->nAudioPacketSize;
m_pSharedHeader->nPacketCount = pDevicePrivateData->nAudioBufferNumOfPackets;
m_pSharedHeader->nPacketSize = pDevicePrivateData->nAudioPacketSize;
// set read and write indices
pDevicePrivateData->nAudioReadIndex = 0;
pDevicePrivateData->nAudioWriteIndex = 0;
return (XN_STATUS_OK);
}
unsigned long Measurement::GetNextDataBulk()
{
FILE_LOG(logDEBUG3) << "Measurement::GetNextDataBulk";
unsigned long i, j, index;
short *overflow;
uint32_t traces_asked_for, length_of_trace_fetched;
// unsigned long length_of_trace_askedfor, length_of_trace_fetched;
Timing t;
// std::cerr << "(GetNextDataBulk: " << GetNextIndex() << ", " << GetMaxTracesToFetch() << ")\n";
// it makes no sense to read any further: we are already at the end
if(GetNextIndex() >= GetNTraces()) {
std::cerr << "Stop fetching data from ociloscope." << std::endl;
return 0UL;
}
/*
try {
for(i=0; i<GetNumberOfChannels(); i++) {
if(GetChannel(i)->IsEnabled()) {
delete [] data[i];
data[i] = new short[GetMaxTracesToFetch()*GetLength()];
}
}
} catch(...) {
std::cerr << "Unable to allocate memory in Measurement::AllocateMemoryBlock." << std::endl;
throw;
}
/**/
traces_asked_for = GetMaxTracesToFetch();
if(GetNextIndex() + traces_asked_for > GetNTraces()) {
traces_asked_for = GetNTraces() - GetNextIndex();
}
// allocate buffers
for(i=0; i<GetNumberOfChannels(); i++) {
if(GetChannel(i)->IsEnabled()) {
FILE_LOG(logDEBUG4) << "Measurement::GetNextDataBulk - memset data[i]" << GetLength()*traces_asked_for*sizeof(short);
memset(data[i], 0, GetLength()*traces_asked_for*sizeof(short));
FILE_LOG(logDEBUG4) << "done";
}
for(j=0; j<traces_asked_for; j++) {
index = j+GetNextIndex();
if(GetChannel(i)->IsEnabled()) {
if(data_allocated[i] == false) {
throw "Unable to get data. Memory is not allocated.";
}
if(GetSeries() == PICO_4000) {
// GetPicoscope()->SetStatus(ps4000SetDataBufferBulk(
// GetHandle(), // handle
// (PS4000_CHANNEL)i, // channel
// data[i], // *buffer
// GetMaxTraceLengthToFetch())); // bufferLength
GetPicoscope()->SetStatus(ps4000SetDataBufferBulk(
GetHandle(), // handle
(PS4000_CHANNEL)i, // channel
&data[i][j*GetLength()], // *buffer
GetLength(), // bufferLength
index)); // waveform
} else {
// unsigned long dj = (j+GetNextIndex()/GetMaxTracesToFetch())%traces_asked_for;
// std::cerr << "-- (set data buffer bulk: [" << i << "][" << dj
// << "], len:" << GetLength() << ", index:" << index
// << ", from:" << GetNextIndex()
// << ", to:" << GetNextIndex()+traces_asked_for-1 << "\n";
GetPicoscope()->SetStatus(ps6000SetDataBufferBulk(
GetHandle(), // handle
(PS6000_CHANNEL)i, // channel
&data[i][j*GetLength()], // *buffer
GetLength(), // bufferLength
index, // waveform
PS6000_RATIO_MODE_NONE)); // downSampleRatioMode
}
if(GetPicoscope()->GetStatus() != PICO_OK) {
std::cerr << "Unable to set memory for channel." << std::endl;
throw Picoscope::PicoscopeException(GetPicoscope()->GetStatus());
}
}
}
}
// fetch data
// length_of_trace_fetched = length_of_trace_askedfor;
std::cerr << "Get data for traces " << GetNextIndex() << "-" << GetNextIndex()+traces_asked_for << " (" << 100.0*(GetNextIndex()+traces_asked_for)/GetNTraces() << "%) ... ";
overflow = new short[traces_asked_for];
memset(overflow, 0, traces_asked_for*sizeof(short));
// std::cerr << "-- x1\n";
t.Start();
// std::cerr << "length of buffer: " << data_length[0] << ", length of requested trace: " << length_of_trace_askedfor << " ... ";
if(GetSeries() == PICO_4000) {
length_of_trace_fetched = GetLength();
GetPicoscope()->SetStatus(ps4000GetValuesBulk(
GetHandle(), // handle
&length_of_trace_fetched, // *noOfSamples
// TODO: start index
GetNextIndex(), // fromSegmentIndex
GetNextIndex()+traces_asked_for-1, // toSegmentIndex
// this could also be min(GetMaxTraceLengthToFetch(),wholeLength-startindex)
overflow)); // *overflow
} else {
// TODO: not sure about this ...
length_of_trace_fetched = GetLength();
GetPicoscope()->SetStatus(ps6000GetValuesBulk(
GetHandle(), // handle
&length_of_trace_fetched, // *noOfSamples
// TODO: start index
GetNextIndex(), // fromSegmentIndex
GetNextIndex()+traces_asked_for-1, // toSegmentIndex
// this could also be min(GetMaxTraceLengthToFetch(),wholeLength-startindex)
1, // downSampleRatio
PS6000_RATIO_MODE_NONE, // downSampleRatioMode
overflow)); // *overflow
}
t.Stop();
// std::cerr << "-- x2\n";
if(GetPicoscope()->GetStatus() != PICO_OK) {
std::cerr << "Unable to set memory for channel." << std::endl;
throw Picoscope::PicoscopeException(GetPicoscope()->GetStatus());
}
for(i=0; i<traces_asked_for; i++) {
for(j=0; i<GetNumberOfChannels(); i++) {
if(overflow[i] & (1<<j)) {
FILE_LOG(logWARNING) << "Warning: Overflow on channel " << (char)('A'+j) << " of trace " << i+GetNextIndex() << ".\n";
}
}
}
delete [] overflow;
// if(length_of_trace_fetched != length_of_trace_askedfor) {
// std::cerr << "Warning: The number of read samples was smaller than requested.\n";
// }
// getting timestamps
int64_t *timestamps;
PS6000_TIME_UNITS *timeunits;
timestamps = new int64_t[traces_asked_for];
timeunits = new PS6000_TIME_UNITS[traces_asked_for];
if(GetSeries() == PICO_4000) {
// NOT YET IMPLEMENTED
} else {
FILE_LOG(logDEBUG2) << "ps6000GetValuesTriggerTimeOffsetBulk64(handle=" << GetHandle() << ", *timestamps, *timeunits, fromSegmentIndex=" << GetNextIndex() << ", toSegmentIndex=" << GetNextIndex()+traces_asked_for-1 << ")";
GetPicoscope()->SetStatus(ps6000GetValuesTriggerTimeOffsetBulk64(
GetHandle(), // handle
timestamps, // *times
timeunits, // *timeUnits
GetNextIndex(), // fromSegmentIndex
GetNextIndex()+traces_asked_for-1)); // toSegmentIndex
}
if(GetPicoscope()->GetStatus() != PICO_OK) {
std::cerr << "Unable to get timestamps." << std::endl;
throw Picoscope::PicoscopeException(GetPicoscope()->GetStatus());
}
// for(i=0; i<traces_asked_for; i++) {
// std::cerr << "time " << i << ": " << timestamps[i] << "\n";
// }
SetRate(traces_asked_for, timestamps[0], timeunits[0], timestamps[traces_asked_for-1], timeunits[traces_asked_for-1]);
// if(timeunits[0] != timeunits[traces_asked_for-1]) {
// FILE_LOG(logWARNING) << "time unit of the first and last sample differ; rate is not reliable; TIMING seems to be broken anyway";
// }
delete [] timestamps;
delete [] timeunits;
std::cerr << "OK ("<< t.GetSecondsDouble() <<"s)\n";
// std::cerr << "length of trace fetched: " << length_of_trace_fetched << "\n";
// std::cerr << "total length: " << traces_asked_for*length_of_trace_fetched << "\n";
SetLengthFetched(traces_asked_for*length_of_trace_fetched);
// std::cerr << "-- next index is now " << GetNextIndex() << ", will be set to " << GetNextIndex() + traces_asked_for << "\n";
SetNextIndex(GetNextIndex()+traces_asked_for);
// std::cerr << "-- next index is now " << GetNextIndex() << "\n";
// std::cerr << "-- return value " << traces_asked_for << "\n";
return traces_asked_for;
}
// TODO: we might want to use multiple buffers at the same time
// returns the length of data
// TODO: the first part only needs to be called once; so we should move the code at the end of RunBlock
// unless we want to alternate between allocated memory (to enable parallel readouts)
unsigned long Measurement::GetNextData()
{
FILE_LOG(logDEBUG3) << "Measurement::GetNextData";
int i;
short overflow=0;
uint32_t length_of_trace_askedfor, length_of_trace_fetched;
Timing t;
// it makes no sense to read any further: we are already at the end
if(GetNextIndex() >= GetLength()) {
std::cerr << "Stop fetching data from osciloscope." << std::endl;
return 0UL;
}
length_of_trace_askedfor = GetMaxTraceLengthToFetch();
if(GetNextIndex() + length_of_trace_askedfor > GetLength()) {
length_of_trace_askedfor = GetLength() - GetNextIndex();
}
// allocate buffers
for(i=0; i<GetNumberOfChannels(); i++) {
if(GetChannel(i)->IsEnabled()) {
if(data_allocated[i] == false) {
throw "Unable to get data. Memory is not allocated.";
}
if(GetSeries() == PICO_4000) {
FILE_LOG(logDEBUG2) << "ps4000SetDataBuffer(handle=" << GetHandle() << ", channel=" << i << ", *buffer=<data[i]>, bufferLength=" << GetMaxTraceLengthToFetch() << ")";
GetPicoscope()->SetStatus(ps4000SetDataBuffer(
GetHandle(), // handle
(PS4000_CHANNEL)i, // channel
data[i], // *buffer
GetMaxTraceLengthToFetch())); // bufferLength
} else {
FILE_LOG(logDEBUG2) << "ps6000SetDataBuffer(handle=" << GetHandle() << ", channel=" << i << ", *buffer=<data[i]>, bufferLength=" << GetMaxTraceLengthToFetch() << ", downSampleRatioMode=PS6000_RATIO_MODE_NONE)";
GetPicoscope()->SetStatus(ps6000SetDataBuffer(
GetHandle(), // handle
(PS6000_CHANNEL)i, // channel
data[i], // *buffer
GetMaxTraceLengthToFetch(), // bufferLength
PS6000_RATIO_MODE_NONE)); // downSampleRatioMode
}
if(GetPicoscope()->GetStatus() != PICO_OK) {
std::cerr << "Unable to set memory for channel." << std::endl;
throw Picoscope::PicoscopeException(GetPicoscope()->GetStatus());
}
}
}
// fetch data
length_of_trace_fetched = length_of_trace_askedfor;
std::cerr << "Get data for points " << GetNextIndex() << "-" << GetNextIndex()+length_of_trace_askedfor << " (" << 100.0*(GetNextIndex()+length_of_trace_askedfor)/GetLength() << "%) ... ";
t.Start();
// std::cerr << "length of buffer: " << data_length[0] << ", length of requested trace: " << length_of_trace_askedfor << " ... ";
if(GetSeries() == PICO_4000) {
FILE_LOG(logDEBUG2) << "ps4000GetValues(handle=" << GetHandle() << ", startIndex=" << GetNextIndex() << ", *noOfSamples=" << length_of_trace_fetched << ", downSampleRatio=1, downSampleRatioMode=PS4000_RATIO_MODE_NONE, segmentIndex=0, *overflow)";
GetPicoscope()->SetStatus(ps4000GetValues(
GetHandle(), // handle
// TODO: start index
GetNextIndex(), // startIndex
// this could also be min(GetMaxTraceLengthToFetch(),wholeLength-startindex)
&length_of_trace_fetched, // *noOfSamples
1, // downSampleRatio
PS4000_RATIO_MODE_NONE, // downSampleRatioMode
0, // segmentIndex
&overflow)); // *overflow
FILE_LOG(logDEBUG2) << "-> length_of_trace_fetched=" << length_of_trace_fetched << "\n";
} else {
FILE_LOG(logDEBUG2) << "ps6000GetValues(handle=" << GetHandle() << ", startIndex=" << GetNextIndex() << ", *noOfSamples=" << length_of_trace_fetched << ", downSampleRatio=1, downSampleRatioMode=PS6000_RATIO_MODE_NONE, segmentIndex=0, *overflow)";
GetPicoscope()->SetStatus(ps6000GetValues(
GetHandle(), // handle
// TODO: start index
GetNextIndex(), // startIndex
// this could also be min(GetMaxTraceLengthToFetch(),wholeLength-startindex)
&length_of_trace_fetched, // *noOfSamples
1, // downSampleRatio
PS6000_RATIO_MODE_NONE, // downSampleRatioMode
0, // segmentIndex
&overflow)); // *overflow
FILE_LOG(logDEBUG2) << "-> length_of_trace_fetched=" << length_of_trace_fetched << "\n";
}
t.Stop();
if(GetPicoscope()->GetStatus() != PICO_OK) {
std::cerr << "Unable to set memory for channel." << std::endl;
throw Picoscope::PicoscopeException(GetPicoscope()->GetStatus());
}
if(overflow) {
for(i=0; i<GetNumberOfChannels(); i++) {
if(overflow & (1<<i)) {
std::cerr << "Warning: Overflow on channel " << (char)('A'+i) << ".\n";
}
}
}
if(length_of_trace_fetched != length_of_trace_askedfor) {
std::cerr << "Warning: The number of read samples was smaller than requested.\n";
}
std::cerr << "OK ("<< t.GetSecondsDouble() <<"s)\n";
SetLengthFetched(length_of_trace_fetched);
SetNextIndex(GetNextIndex()+length_of_trace_fetched);
return length_of_trace_fetched;
}
void Measurement::RunBlock()
{
FILE_LOG(logDEBUG3) << "Measurement::RunBlock";
int i;
Timing t;
uint32_t max_length=0;
// we will have to start reading our data from beginning again
SetNextIndex(0);
// test if channel settings have already been passed to picoscope
// and only pass them again if that isn't the case
FILE_LOG(logDEBUG4) << "Measurement::RunBlock - we have " << GetNumberOfChannels() << " channels";
for(i=0; i<GetNumberOfChannels(); i++) {
FILE_LOG(logDEBUG4) << "Measurement::RunBlock - setting channel " << (char)('A'+i) << " (which holds index " << GetChannel(i)->GetIndex() << ")";
GetChannel(i)->SetChannelInPicoscope();
}
// this fixes the timebase if more than a single channel is selected
FixTimebase();
// timebase
SetTimebaseInPicoscope();
// trigger
if(IsTriggered()) {
GetTrigger()->SetTriggerInPicoscope();
}
// for rapid block mode
if(GetNTraces() > 1) {
// TODO - check that GetLength()*GetNumberOfEnabledChannels()*GetNTraces() doesn't exceed the limit
if(GetSeries() == PICO_4000) {
FILE_LOG(logDEBUG2) << "ps4000SetNoOfCaptures(handle=" << GetHandle() << ", nCaptures=" << GetNTraces() << ")";
GetPicoscope()->SetStatus(ps4000SetNoOfCaptures(
GetHandle(), // handle
GetNTraces())); // nCaptures
} else {
FILE_LOG(logDEBUG2) << "ps6000SetNoOfCaptures(handle=" << GetHandle() << ", nCaptures=" << GetNTraces() << ")";
GetPicoscope()->SetStatus(ps6000SetNoOfCaptures(
GetHandle(), // handle
GetNTraces())); // nCaptures
}
if(GetPicoscope()->GetStatus() != PICO_OK) {
std::cerr << "Unable to set number of captures to " << GetNTraces() << std::endl;
throw Picoscope::PicoscopeException(GetPicoscope()->GetStatus());
}
if(GetSeries() == PICO_4000) {
FILE_LOG(logDEBUG2) << "ps4000MemorySegments(handle=" << GetHandle() << ", nSegments=" << GetNTraces() << ", &max_length=" << max_length << ")";
GetPicoscope()->SetStatus(ps4000MemorySegments(
GetHandle(), // handle
GetNTraces(), // nSegments
&max_length));
FILE_LOG(logDEBUG2) << "->ps4000MemorySegments(... max_length=" << max_length << ")";
} else {
FILE_LOG(logDEBUG2) << "ps6000MemorySegments(handle=" << GetHandle() << ", nSegments=" << GetNTraces() << ", &max_length=" << max_length << ")";
GetPicoscope()->SetStatus(ps6000MemorySegments(
GetHandle(), // handle
GetNTraces(), // nSegments
&max_length));
FILE_LOG(logDEBUG2) << "->ps6000MemorySegments(... max_length=" << max_length << ")";
}
if(GetPicoscope()->GetStatus() != PICO_OK) {
std::cerr << "Unable to set number of segments to " << GetNTraces() << std::endl;
throw Picoscope::PicoscopeException(GetPicoscope()->GetStatus());
}
if(max_length < GetLength()) { // TODO: times number of enabled channels
std::cerr << "The maximum length of trace you can get with " << GetNTraces()
<< " traces is " << max_length << ", but you requested " << GetLength() << "\n";
throw;
}
if(GetSeries() == PICO_4000) {
FILE_LOG(logDEBUG2) << "ps4000SetNoOfCaptures(handle=" << GetHandle() << ", nCaptures=" << GetNTraces() << ")";
GetPicoscope()->SetStatus(ps4000SetNoOfCaptures(
GetHandle(), // handle
GetNTraces())); // nCaptures
} else {
FILE_LOG(logDEBUG2) << "ps6000SetNoOfCaptures(handle=" << GetHandle() << ", nCaptures=" << GetNTraces() << ")";
GetPicoscope()->SetStatus(ps6000SetNoOfCaptures(
GetHandle(), // handle
GetNTraces())); // nCaptures
}
if(GetPicoscope()->GetStatus() != PICO_OK) {
std::cerr << "Unable to set number of captures to " << GetNTraces() << std::endl;
throw Picoscope::PicoscopeException(GetPicoscope()->GetStatus());
}
}
//std::cerr << "\nPress a key to start fetching the data ...\n";
//_getch();
t.Start();
GetPicoscope()->SetReady(false);
if(GetSeries() == PICO_4000) {
FILE_LOG(logDEBUG2) << "ps4000RunBlock(handle=" << GetHandle() << ", noOfPreTriggerSamples=" << GetLengthBeforeTrigger() << ", noOfPostTriggerSamples=" << GetLengthAfterTrigger() << ", timebase=" << timebase << ", oversample=1, *timeIndisposedMs=NULL, segmentIndex=0, lpReady=CallBackBlock, *pParameter=NULL)";
GetPicoscope()->SetStatus(ps4000RunBlock(
GetHandle(), // handle
GetLengthBeforeTrigger(), // noOfPreTriggerSamples
GetLengthAfterTrigger(), // noOfPostTriggerSamples
timebase, // timebase
1, // ovesample
NULL, // *timeIndisposedMs
0, // segmentIndex
CallBackBlock, // lpReady
NULL)); // *pParameter
} else {
FILE_LOG(logDEBUG2) << "ps6000RunBlock(handle=" << GetHandle() << ", noOfPreTriggerSamples=" << GetLengthBeforeTrigger() << ", noOfPostTriggerSamples=" << GetLengthAfterTrigger() << ", timebase=" << timebase << ", oversample=1, *timeIndisposedMs=NULL, segmentIndex=0, lpReady=CallBackBlock, *pParameter=NULL)";
GetPicoscope()->SetStatus(ps6000RunBlock(
GetHandle(), // handle
GetLengthBeforeTrigger(), // noOfPreTriggerSamples
GetLengthAfterTrigger(), // noOfPostTriggerSamples
timebase, // timebase
1, // ovesample
NULL, // *timeIndisposedMs
0, // segmentIndex
CallBackBlock, // lpReady
NULL)); // *pParameter
}
if(GetPicoscope()->GetStatus() != PICO_OK) {
std::cerr << "Unable to start collecting samples" << std::endl;
throw Picoscope::PicoscopeException(GetPicoscope()->GetStatus());
} else {
std::cerr << "Start collecting samples in "
<< ((GetNTraces() > 1) ? "rapid " : "") << "block mode ... ";
}
// TODO: maybe we want it to be asynchronous
// TODO: catch the _kbhit event!!!
// while (!Picoscope::IsReady() && !_kbhit()) {
while (!Picoscope::IsReady()) {
Sleep(200);
}
t.Stop();
std::cerr << "OK (" << t.GetSecondsDouble() << "s)\n";
// sets the index from where we want to start reading data to zero
SetNextIndex(0UL);
}
