seralf

I have this problem: i'm actually using a NIDAQmx 6008i card on WinXp, and i have the need of write an external that take care of its driver via the API provided.

The external should have ideally two messages ("start" and "stop") over the main inlet, and probably some arguments to set up the card. Then i should map all the phisical channel as outlets, in order to control the device in the best simple and intuitive way (i mean: i want to offer 8 outlets, even if i could use only some of them on some patch). These outlets should offer 8 floating point values, updating them in real time as they come from the card.

The card offer by API an integrated task-based system, based on an internal clock. At the moment i was able to write my external and start/stop the reading task over the phisical channels of the device: i write the values on the MAX window using a simple "post" function: the problem i still have is to transfer the value i read from the card in the 8 outlets. I'm not sure i have correctly understand in the manual what is the right method to write a value "into" an outlet, and what kind of data structure i should use for internal rapresentation of a float value to be send to the outlet.

In the example "thresh", for example, the value are updated by an internal clock watch, and the value are inserted from the user... i have indeed the need of generate the values from the reading task of the card and being able to emits them by the outlets... i hope i was clear in the description.

Sorry if this was a dummy question, thanks for the support

Hi to all
I have this problem: i'm actually using a NIDAQmx 6008i card on WinXp, and i have the need of write an external that take care of its driver via the API provided.
The external should have ideally two messages ("start" and "stop") over the main inlet, and probably some arguments to set up the card. Then i should map all the phisical channel as outlets, in order to control the device in the best simple and intuitive way (i mean: i want to offer 8 outlets, even if i could use only some of them on some patch). These outlets should offer 8 floating point values, updating them in real time as they come from the card. 

The card offer by API an integrated task-based system, based on an internal clock. At the moment i was able to write my external and start/stop the reading task over the phisical channels of the device: i write the values on the MAX window using a simple "post" function: the problem i still have is to transfer the value i read from the card in the 8 outlets. I'm not sure i have correctly understand in the manual what is the right method to write a value "into" an outlet, and what kind of data structure i should use for internal rapresentation of a float value to be send to the outlet.
In the example "thresh", for example, the value are updated by an internal clock watch, and the value are inserted from the user... i have indeed the need of generate the values from the reading task of the card and being able to emits them by the outlets... i hope i was clear in the description.

emits-floats-outlets-by-nidaqmx-driver-in-an-external

look at the SDK pdf or the maximum.c source file in the SDK:

use floatout() [see p.53 pdf/ line 161 maximum.c] to create an outlet 

in your new() function. beware of the fact that these need to be 

call outlet_float() [see p.60 / line 88 in maximum.c] to output your 

float value through the corresponding outlet.

On 18/06/2007, at 17:48:31, seralf wrote:

> I have this problem: i'm actually using a NIDAQmx 6008i card on 

> WinXp, and i have the need of write an external that take care of 

> The external should have ideally two messages ("start" and "stop") 

> over the main inlet, and probably some arguments to set up the 

> card. Then i should map all the phisical channel as outlets, in 

> order to control the device in the best simple and intuitive way (i 

> mean: i want to offer 8 outlets, even if i could use only some of 

> them on some patch). These outlets should offer 8 floating point 

> values, updating them in real time as they come from the card.

> The card offer by API an integrated task-based system, based on an 

> internal clock. At the moment i was able to write my external and 

> start/stop the reading task over the phisical channels of the 

> device: i write the values on the MAX window using a simple "post" 

> function: the problem i still have is to transfer the value i read 

> from the card in the 8 outlets. I'm not sure i have correctly 

> understand in the manual what is the right method to write a value 

> "into" an outlet, and what kind of data structure i should use for 

> internal rapresentation of a float value to be send to the outlet.

> In the example "thresh", for example, the value are updated by an 

> internal clock watch, and the value are inserted from the user... i 

> have indeed the need of generate the values from the reading task 

> of the card and being able to emits them by the outlets... i hope i 

> Sorry if this was a dummy question, thanks for the support

hello seralf,
look at the SDK pdf or the maximum.c source file in the SDK:

use floatout() [see p.53 pdf/ line 161 maximum.c] to create an outlet  
in your new() function. beware of the fact that these need to be  
created in reverse right to left order.

call outlet_float() [see p.60 / line 88 in maximum.c] to output your  
float value through the corresponding outlet.

>
> Hi to all
> I have this problem: i'm actually using a NIDAQmx 6008i card on  
> WinXp, and i have the need of write an external that take care of  
> its driver via the API provided.
> The external should have ideally two messages ("start" and "stop")  
> over the main inlet, and probably some arguments to set up the  
> card. Then i should map all the phisical channel as outlets, in  
> order to control the device in the best simple and intuitive way (i  
> mean: i want to offer 8 outlets, even if i could use only some of  
> them on some patch). These outlets should offer 8 floating point  
> values, updating them in real time as they come from the card.
>
> The card offer by API an integrated task-based system, based on an  
> internal clock. At the moment i was able to write my external and  
> start/stop the reading task over the phisical channels of the  
> device: i write the values on the MAX window using a simple "post"  
> function: the problem i still have is to transfer the value i read  
> from the card in the 8 outlets. I'm not sure i have correctly  
> understand in the manual what is the right method to write a value  
> "into" an outlet, and what kind of data structure i should use for  
> internal rapresentation of a float value to be send to the outlet.
> In the example "thresh", for example, the value are updated by an  
> internal clock watch, and the value are inserted from the user... i  
> have indeed the need of generate the values from the reading task  
> of the card and being able to emits them by the outlets... i hope i  
> was clear in the description.
>
> Sorry if this was a dummy question, thanks for the support
>
> Alfredo Serafini


i look at "minimum" example, but my problem is that i have a callback function that does the reading task over every sample... the code works well if i take those samples and just print them in the MAX console, but if i try to use outlet_float() instead of print them, the program crashes.

Probably there is some problem with Threads or i do a wrong use of the reference for my outlets...?

i attach some little code (please note it is a very "working" version, based on "thresh" example :-), if you like to take a look over it to have a much clearer idea

suggestions are really welcome: i need this external to go well as it is intended to be used on a patch for my thesis very very soon... and maybe i have too much "rusty" C/C++ skills :-/

thanks very much for your reply, by the way, Alfredo

suggestions are really welcome: i need this external to go well as it is intended to be used on a patch for my thesis very very soon...  and maybe i have too much "rusty" C/C++ skills :-/

thanks very much for your reply, by the way, Alfredo


I haven't looked at the code example, but you typically can't use 

object outlets from threads other than the main one. You might look 

at the defer() and defer_low() functions for a relatively painless 

way to get back to the main thread from your callback.

> Probably there is some problem with Threads or i do a wrong use of 

I haven't looked at the code example, but you typically can't use  
object outlets from threads other than the main one. You might look  
at the defer() and defer_low() functions for a relatively painless  
way to get back to the main thread from your callback.

> Probably there is some problem with Threads or i do a wrong use of  
> the reference for my outlets...?


thanks Jeremy, i'll take a look on that on the manual: i didn't know that function

i'm trying to use the defer_low() method without good results... can you please suggest me a very simple example, in order i could understand the mechanism?

(thanks for the support and the suggestions)

void deferfun(t_myobject *x, t_symbol *s, long ac, t_atom *av)

outlet_float(x->an_outlet, atom_getfloat(av));

void threadfun(t_myobject *x, double val)

defer_low(x, (method)deferfun, NULL, 1, &a);

> i'm trying to use the defer_low() method without good results... 

> can you please suggest me a very simple example, in order i could 

> (thanks for the support and the suggestions)

void deferfun(t_myobject *x, t_symbol *s, long ac, t_atom *av)
{
   if (ac && av && av->a_type == A_FLOAT) {
     outlet_float(x->an_outlet, atom_getfloat(av));
   }
}

void threadfun(t_myobject *x, double val)
{
   t_atom a;

   atom_setfloat(&a, val);
   defer_low(x, (method)deferfun, NULL, 1, &a);
}

>
> i'm trying to use the defer_low() method without good results...  
> can you please suggest me a very simple example, in order i could  
> understand the mechanism?
>
> (thanks for the support and the suggestions)
>
> AS


thanks very much to Jeremy to the fast reply and the example snippet.

I made several test using that example, but i still have problems.

If i don't make use of the method defer_low the program crashes, if i use it the program slow down and down and then it seems to be blocked.

The fact is that if i write the samples taken from the card in the output window of MAX, they are written very fast and without problem, and i'm able to control the output with a simple "start"/"stop" message system to the first outlet of my external.

Indeed if i try to write the same values to the outlets the program crashes or blocks, as i say before.

How is it possible that in the output window i have no problem, and still i have in acting on outlets? are the two context managed by different threads maybe? any suggestions? i expect i could write in the same way any value in two context, i expect i have only difference regarding how to write the data structure (in the output window i only write long or float values)

my question is: taking for example the "uzi" internal (imagine an uzi with an infinite number of repetitions), is it possible to have an idea of its own implementation? maybe could fit my needs, a bit.

any suggestions are really welcome: i have to fix this problem as soon as possible, and i have no more idea on how i could :-(

thanks very much to Jeremy to the fast reply and the example snippet.
I made several test using that example, but i still have problems.
If i don't make use of the method defer_low the program crashes, if i use it the program slow down and down and then it seems to be blocked.
The fact is that if i write the samples taken from the card in the output window of MAX, they are written very fast and without problem, and i'm able to control the output with a simple "start"/"stop" message system to the first outlet of my external.
Indeed if i try to write the same values to the outlets the program crashes or blocks, as i say before.
How is it possible that in the output window i have no problem, and still i have in acting on outlets? are the two context managed by different threads maybe? any suggestions? i expect i could write in the same way any value in two context, i expect i have only difference regarding how to write the data structure (in the output window i only write long or float values)

any suggestions are really welcome: i have to fix this problem as soon as possible, and i have no more idea on how i could :-(


OK, you're causing the event queue to get backed up. Can you post the 

code you're using in your perform() method?

As new values come in, buffer them to a static array somewhere. 

Periodically flush this array (use a clock or qelem to do so). You 

should be able to avoid the backlog if you don't defer for every value.

> If i don't make use of the method defer_low the program crashes, if 

> i use it the program slow down and down and then it seems to be 

OK, you're causing the event queue to get backed up. Can you post the  
code you're using in your perform() method?

As new values come in, buffer them to a static array somewhere.  
Periodically flush this array (use a clock or qelem to do so). You  
should be able to avoid the backlog if you don't defer for every value.

> If i don't make use of the method defer_low the program crashes, if  
> i use it the program slow down and down and then it seems to be  
> blocked.


I was thinking at the possibility to go and use a clock() or a quelem(), but i'm really new to write externals... (this is my first: i know i could start with something less particular, but i had no choice: i need this :-)

now i'm reading the manual and searching in the examples in order to understand how i could use the clock or quelem system.

I started my coding on the thresh example, then i converted my dataBuffer structure in a static structure: i was on the right way, then. But in this direction i don't understand that much how to register a method to act periodically, when i need it to flush the values from my static buffer to the specifi outlets.

As you ask for a snippet, i attach my actual working code (i tried to make it a little more readable, sorry for the disorder)

as you could see there is a callback method (called from a thread managed by the card driver) called "EveryNSamplesCallback" that reads the samples...

you could see into that a line suche this:

in which i simply read the samples in order (and correctly print them on the output window). What i need to do is "simply" to put them in the specific outlets: i imagine i must code a method who acts the output to the outlets at some clock time, but i didn't yet understand how... i'm looking at manuals and examples.

thanks very much for your support, by the way

thanks for the good suggestions Jeremy.
I was thinking at the possibility to go and use a clock() or a quelem(), but i'm really new to write externals... (this is my first: i know i could start with something less particular, but i had no choice: i need this :-)
now i'm reading the manual and searching in the examples in order to understand how i could use the clock or quelem system.

you could see into that a line suche this:
post(...dataBuffer[i]);

OK, were you previously calling defer_low 8 times at this point? If 

so, you might try the following, which probably won't back up the 

scheduler, presuming that your callback isn't being called every 8 

samples. If it is, then you likely will need to do some buffering.

defer_low(x, (method)outputfun, NULL, 8, a);

void outputfun(t_myobj *x, t_symbol *s, long ac, t_atom *av)

outlet_float(x->out+i, atom_getfloat(av+i));

This presumes that you allocated your outlets as an array of void*s 

> in which i simply read the samples in order (and correctly print 

> them on the output window). What i need to do is "simply" to put 

> them in the specific outlets: i imagine i must code a method who 

> acts the output to the outlets at some clock time, but i didn't yet 

> understand how... i'm looking at manuals and examples.

OK, were you previously calling defer_low 8 times at this point? If  
so, you might try the following, which probably won't back up the  
scheduler, presuming that your callback isn't being called every 8  
samples. If it is, then you likely will need to do some buffering.

for (i = 0; i < 8; i++)
   atom_setfloat(a+i, dataBuffer[i]);

void outputfun(t_myobj *x, t_symbol *s, long ac, t_atom *av)
{
   for (i = 0; i < ac; i++)
     outlet_float(x->out+i, atom_getfloat(av+i));
}

This presumes that you allocated your outlets as an array of void*s  
beginning at x->out.

> in which i simply read the samples in order (and correctly print  
> them on the output window). What i need to do is "simply" to put  
> them in the specific outlets: i imagine i must code a method who  
> acts the output to the outlets at some clock time, but i didn't yet  
> understand how... i'm looking at manuals and examples.


>> OK, were you previously calling defer_low 8 times at this point? 

yes, i did call defer_low into this cycle...

thanks for the example, i'll try to follow your suggestion and i will let you know (i see that probably i have done some confusion here)

>> OK, were you previously calling defer_low 8 times at this point? 
yes, i did call defer_low into this cycle...

i'm actually reading the section dedicated to qelem or clocks (i think qelem maybe could be the right choice)

introducing defer_low mechanism, i still have two problems:

1. to be able to update the values in the outlet: i used the inlets as in thresh example, then i have done some experiment on how to update their values, with no good results. Ok, this is surely a problem of mine: i must have done something wrong on the code, and i'll fix it

2. stricly dependant on the precedent, i think: no way to update the value with the sample values i read from the card. The good news is that the mechanism it's ok regarding the crashes: MAX does'nt crashes at all, then i am probably near to a fine solution (thanks to Jeremy). The values in my callback function are right, i have the problem of putting them in some atom structure for outputting them on outlets, and then "refresh" the outlets values (maybe i should invoke the _bang method from my callback simulating an input from user?)

i attach the last working-copy of the code, if like to propose to me some fix or snippet, thanks

(At the moment i'm working on a simple example on how to use clocks & qelems)

introducing defer_low mechanism, i still have two problems:
1. to be able to update the values in the outlet: i used the inlets as in thresh example, then i have done some experiment on how to update their values, with no good results. Ok, this is surely a problem of mine: i must have done something wrong on the code, and i'll fix it
2. stricly dependant on the precedent, i think: no way to update the value with the sample values i read from the card. The good news is that the mechanism it's ok regarding the crashes: MAX does'nt crashes at all, then i am probably near to a fine solution (thanks to Jeremy). The values in my callback function are right, i have the problem of putting them in some atom structure for outputting them on outlets, and then "refresh" the outlets values (maybe i should invoke the _bang method from my callback simulating an input from user?)

Let's back up for a second. I think you're grasping at tools without 

necessary thinking through what the problem is that you're trying to 

- The object receives values constantly, but outputs nothing until 

the user sends a bang message (or the object polls itself, as if it 

had an internal metronome). It then outputs the most recent values it 

- The object outputs values as soon as it receives them.

- How do they function? The 8 to the right seem to send out a single 

float value, but the 1 on the left appears to send out a list.

- What is the difference between the data being output from the 

> i'm actually reading the section dedicated to qelem or clocks (i 

> think qelem maybe could be the right choice)

> introducing defer_low mechanism, i still have two problems:

> 1. to be able to update the values in the outlet: i used the inlets 

> as in thresh example, then i have done some experiment on how to 

> update their values, with no good results. Ok, this is surely a 

> problem of mine: i must have done something wrong on the code, and 

> 2. stricly dependant on the precedent, i think: no way to update 

> the value with the sample values i read from the card. The good 

> news is that the mechanism it's ok regarding the crashes: MAX 

> does'nt crashes at all, then i am probably near to a fine solution 

> (thanks to Jeremy). The values in my callback function are right, i 

> have the problem of putting them in some atom structure for 

> outputting them on outlets, and then "refresh" the outlets values 

> (maybe i should invoke the _bang method from my callback simulating 

> i attach the last working-copy of the code, if like to propose to 

> (At the moment i'm working on a simple example on how to use clocks 

Let's back up for a second. I think you're grasping at tools without  
necessary thinking through what the problem is that you're trying to  
solve.

- The object receives values constantly, but outputs nothing until  
the user sends a bang message (or the object polls itself, as if it  
had an internal metronome). It then outputs the most recent values it  
received.

- How do they function? The 8 to the right seem to send out a single  
float value, but the 1 on the left appears to send out a list.

- What is the difference between the data being output from the  
different outlets?

> i'm actually reading the section dedicated to qelem or clocks (i  
> think qelem maybe could be the right choice)
>
> introducing defer_low mechanism, i still have two problems:
> 1. to be able to update the values in the outlet: i used the inlets  
> as in thresh example, then i have done some experiment on how to  
> update their values, with no good results. Ok, this is surely a  
> problem of mine: i must have done something wrong on the code, and  
> i'll fix it
> 2. stricly dependant on the precedent, i think: no way to update  
> the value with the sample values i read from the card. The good  
> news is that the mechanism it's ok regarding the crashes: MAX  
> does'nt crashes at all, then i am probably near to a fine solution  
> (thanks to Jeremy). The values in my callback function are right, i  
> have the problem of putting them in some atom structure for  
> outputting them on outlets, and then "refresh" the outlets values  
> (maybe i should invoke the _bang method from my callback simulating  
> an input from user?)
>
> i attach the last working-copy of the code, if like to propose to  
> me some fix or snippet, thanks
>
> (At the moment i'm working on a simple example on how to use clocks  
> & qelems)
>
> thanks, A.
>


yes, i know i must seem to be working with no idea :-)

the fact is that i have to make the things working and my code is not that "beautiful", at the moment...

please consider only the outlet from 0 to 7, the last has remains fsince i have used as a start-up for my code the "thresh" example, and i leave it there because i could use it (it is yet coded) for others data. If i will find no intereset in other data, i will remove that part. Sorry for being not that much clear on this point.

The card receive voltages from a couple of sensors, and translates them in 8 samples channels: the standard reading messages is the one i used with the callback function.

At the moment the object receive two very simple mssages (start and stop) to control the reading, which is continuous (at about internal card clock rate), and is able to write the values correctly in the max ouput window with no problem. The values readen are stored in a static buffer dataBuffer[],in order to be transferred to the outlets objects.

if i try to write to the outlets for every sample, the program crashes... with the introduction of a defer mechanism seems to be ok, but i have problems in update the value: they are correctly printed in output but no way to write them in an outlet... seems like i must do some bang or some "refresh" to see the results changing in real time

i hope i was much clearer about my needs, sorry for some confusion, and thanks for the interest

>> How should your object function?
The card receive voltages from a couple of sensors, and translates them in 8 samples channels: the standard reading messages is the one i used with the callback function.
At the moment the object receive two very simple mssages (start and stop) to control the reading, which is continuous (at about internal card  clock rate), and is able to write the values correctly in the max ouput window with no problem. The values readen are stored in a static buffer dataBuffer[],in order to be transferred to the outlets objects.
if i try to write to the outlets for every sample, the program crashes... with the introduction of a defer mechanism  seems to be ok, but i have problems in update the value: they are correctly printed in output but no way to write them in an outlet... seems like i must do some bang or some "refresh" to see the results changing in real time

Here is a modified version of your file. I've disabled everything 

which looked useless for your described needs. I haven't tried to 

compile this, but it should work. You don't need clocks or qelems, 

presuming that this doesn't backlog the scheduler.

Note that we're sending the 8 values to output to the defer_low 

function. They are copied and arrive at the function where the 

outlets are triggered in the main thread. You don't need to save 

these values - just pass them into defer_low.

> yes, i know i must seem to be working with no idea :-)

> the fact is that i have to make the things working and my code is 

> please consider only the outlet from 0 to 7, the last has remains 

> fsince i have used as a start-up for my code the "thresh" example, 

> and i leave it there because i could use it (it is yet coded) for 

> others data. If i will find no intereset in other data, i will 

> remove that part. Sorry for being not that much clear on this point.

> The card receive voltages from a couple of sensors, and translates 

> them in 8 samples channels: the standard reading messages is the 

> At the moment the object receive two very simple mssages (start and 

> stop) to control the reading, which is continuous (at about 

> internal card clock rate), and is able to write the values 

> correctly in the max ouput window with no problem. The values 

> readen are stored in a static buffer dataBuffer[],in order to be 

> if i try to write to the outlets for every sample, the program 

> crashes... with the introduction of a defer mechanism seems to be 

> ok, but i have problems in update the value: they are correctly 

> printed in output but no way to write them in an outlet... seems 

> like i must do some bang or some "refresh" to see the results 

> i hope i was much clearer about my needs, sorry for some confusion, 

Here is a modified version of your file. I've disabled everything  
which looked useless for your described needs. I haven't tried to  
compile this, but it should work. You don't need clocks or qelems,  
presuming that this doesn't backlog the scheduler.

Note that we're sending the 8 values to output to the defer_low  
function. They are copied and arrive at the function where the  
outlets are triggered in the main thread. You don't need to save  
these values - just pass them into defer_low.

>
> yes, i know i must seem to be working with no idea :-)
>
> the fact is that i have to make the things working and my code is  
> not that "beautiful", at the moment...
>
> please consider only the outlet from 0 to 7, the last has remains  
> fsince i have used as a start-up for my code the "thresh" example,  
> and i leave it there because i could use it (it is yet coded) for  
> others data. If i will find no intereset in other data, i will  
> remove that part. Sorry for being not that much clear on this point.
>
>>> How should your object function?
> The card receive voltages from a couple of sensors, and translates  
> them in 8 samples channels: the standard reading messages is the  
> one i used with the callback function.
> At the moment the object receive two very simple mssages (start and  
> stop) to control the reading, which is continuous (at about  
> internal card  clock rate), and is able to write the values  
> correctly in the max ouput window with no problem. The values  
> readen are stored in a static buffer dataBuffer[],in order to be  
> transferred to the outlets objects.
> if i try to write to the outlets for every sample, the program  
> crashes... with the introduction of a defer mechanism  seems to be  
> ok, but i have problems in update the value: they are correctly  
> printed in output but no way to write them in an outlet... seems  
> like i must do some bang or some "refresh" to see the results  
> changing in real time
>
> i hope i was much clearer about my needs, sorry for some confusion,  
> and thanks for the interest
>
> Alfredo


thanks for yout time jeremy, but i see no attachment. could you please re-post?

emits floats outlets by NIDAQmx driver in an external