Matlab events and listeners: propagate information out of the Event call

Question

I have an object that incorporates an event which is created in my program(specifically, a session based ni daq with a 'DataAvailable' event which fires every time a set number of samples is acquired.) This event will be fired at random times during the course of running my program that will do other stuff independent of recording. When fired, it will collect and save the data chunk in a file.

My issue is that everytime the Event is triggered, i need to increase a counter (i name it "chunk") in my original program. This is critical as a number of features in my program depend on my being able to measure the number of chunks accurately.

QUESTION: how can i propagate the fact that an event has been triggered into my main program?

For people who process (pseudo)code better:

setupStuff();
endLoop = false;
while ~endLoop
  if ~recording
    session  = createDAQSessionObject(params);
    chunkNum = 0;
    session.addListener('DataAvailable',@(src,event)saveChunk(src,event,chunkNum));
    session.startBackGround()
    recording  = true;
  end
  endLoop = doOtherStuff();
  pause(0.1);
end

function saveChunk(src,event,numChunk)
  filename = sprintf('chunk%d.mat',numChunk);
  times = event.TimeStamps;
  data = event.Data;
  save(filename,'times','data');
  % but now the next time around we need to get in numChunks+1 (but we never will because we have no way of knowing that the event was called...
end

Thanks

-bas

`global numChunk`? or `persistent numChunk`? http://www.mathworks.com/help/matlab/ref/persistent.html and http://www.mathworks.com/help/matlab/ref/global.html — Yvon, Aug 13 '14 at 06:05
Define your main program as handle class, and pass the object to saveChunk. Since objects of class handle are passed by reference, you'll have the correct count anywhere. — Jonas, Aug 13 '14 at 07:57

score 3 · Answer 1 · answered Aug 13 '14 at 07:06

Using global or persistent does the job in this minimal example -

Define a class to be the event source.

classdef bar < handle
    events
        sayhello
    end
end

Build a function that uses a persistent variable num. num is visible only to function foo, but it is "persistent" between calls to foo. It remains in foo's workspace until clear all is excecuted, or Matlab quits.

function foo(~,~)
persistent num
if isempty(num)
    num = 1;
else
    num = num+1;
end
fprintf('hi %d\n', num);
end

.... and call it from main script

bigjob = bar;
addlistener(bigjob, 'sayhello', @foo);

for ii = 1:10
    notify(bigjob, 'sayhello')
end

Output:

hi 1
hi 2
hi 3
hi 4
hi 5
hi 6
hi 7
hi 8
hi 9
hi 10
>>

Build another function that uses a global variable num. num is kept in base workspace, visible to all functions as well as the main script, and is alive until clear global num is called or Matlab quits.
```
function foo(~,~)
global num
num = num+1;
fprintf('hi %d\n', num);
end
```
.... and change the script to declare and initialize the global num
```
global num
num = 0;
bigjob = bar;
addlistener(bigjob, 'sayhello', @foo);

for ii = 1:10
    notify(bigjob, 'sayhello')
end
```
Output:
```
hi 1
hi 2
hi 3
hi 4
hi 5
hi 6
hi 7
hi 8
hi 9
hi 10
>> 
```

Efficiency concerns

Using global or persistent is costly. I changed my code to ii = 50000, and muted the fprintf, to perform a benchmark.

According to Profiler, using global takes ~10% of total running time; by "using global" I mean declaring global num in function foo.

.... while using persistent takes ~25% of total running time (it adds up to the total, so running persistent is slower than global); by "using persistent" I mean these lines

persistent num
if isempty(num)
else
end

Thanks, I was hoping that this wont be necessary. Is there any understanding about who calls the listener function? Is it in the same thread? What happens when the original function is in the process of doing other things? Does it stop that and do the listen event? Or does matlab spool another process? — bas, Aug 13 '14 at 16:25
@bas To identify the caller, you can add a caller id as an event argument. http://www.mathworks.com/help/matlab/matlab_external/using-events.html#f90010 — Yvon, Aug 13 '14 at 16:33
@bas check this documentation for DAQ http://www.mathworks.com/help/daq/examples/generate-continuous-and-background-signals-using-ni-devices.html — Yvon, Aug 13 '14 at 16:41
thanks. that was useful. my current strategy: subclass a session with a public proeprty called chunkNum. and in the listener event modify the chunkNum everytime the event is fired! I'll keep this post updated as I progress. — bas, Aug 13 '14 at 18:37

Matlab events and listeners: propagate information out of the Event call

1 Answers1

Efficiency concerns