Peter Nyboer

I have a few functions in a js that output values *and update an interface. I'd like to limit the data that updates the interface. For example, if a data stream has values coming every ms, I'd like to send those values at that rate, but limit the value going to the interface to 33 ms. It seems that there's a way to do this with a Task object, but I seem to be tying my brain into knots figuring how that might work.

So the big question is...Is there a simple/elegant way to limit the data output from a javascript function?

I have a few functions in a js that output values *and update an  interface.  I'd like to limit the data that updates the interface. For example, if a data stream has values coming every ms, I'd like to send those values at that rate, but limit the value going to the interface to 33 ms.  It seems that there's a way to do this with a Task object, but I seem to be tying my brain into knots figuring how that might work.
So the big question is...Is there a simple/elegant way to limit the data output from a javascript function?

speedlim-type-function-in-js

> I have a few functions in a js that output values *and update an 

> interface. I'd like to limit the data that updates the interface. 

> For example, if a data stream has values coming every ms, I'd like 

> to send those values at that rate, but limit the value going to the 

> interface to 33 ms. It seems that there's a way to do this with a 

> Task object, but I seem to be tying my brain into knots figuring 

> So the big question is...Is there a simple/elegant way to limit the 

> data output from a javascript function?

You just need to read the content of a variable at a certain speed. 

The following reproduce more or less the speedlim object. This should 

        tsk.interval = TASK_INTERVAL;

> I have a few functions in a js that output values *and update an   
> interface.  I'd like to limit the data that updates the interface.  
> For example, if a data stream has values coming every ms, I'd like  
> to send those values at that rate, but limit the value going to the  
> interface to 33 ms.  It seems that there's a way to do this with a  
> Task object, but I seem to be tying my brain into knots figuring  
> how that might work.
> So the big question is...Is there a simple/elegant way to limit the  
> data output from a javascript function?

You just need to read the content of a variable at a certain speed.  
The following reproduce more or less the speedlim object. This should  
be a good start.

const TASK_INTERVAL = 33;
var tsk = new Task(repeatValue,this);
var theValue;
var lastValue;

function msg_int(i)
{
	startTask();
	theValue = i;
}

function startTask()
{
	if (!tsk.running) {
		tsk.interval = TASK_INTERVAL;
		tsk.repeat();
	}
}
startTask.local = 1;

function repeatValue()
{
	if (theValue != lastValue) {
		outlet(0, theValue);
		lastValue = theValue;
	}
}
repeatValue.immediate = 1;
repeatValue.local = 1;


thanks for a more articulate version of what I've been playing with...that helps clear up my head a bit!

However, since I have a number of functions in this js that process values and update interface elements, it seems I may be faced with creating a task for each function, which makes the js a bit cumbersome...if I have 5 functions in the js, suddenly I'm faced with 5 more, plus 5 Tasks, which makes for a messy document :( The other option would be a Task that updates all interface elements in one "burst", though, if the interface grows, that could get to be a big burst..hmmm...

I guess what I'm dreaming of is some simple built in function that would go something like this:

In reality, here's an example of the functions that I'm dealing with,and what I'd really like to limit is the "toknob.set(v)".

takes a value in and scales it and passes it to pattrstorage. If the value is coming from an "external interface" (eg MIDI), then it is appended with a "1" to enable the onscreen knob to display the external interface's values.

    var scaled = 2*v/127; //turn 0-127 into range of 0.-2.

    outlet(0,"1MovieLoop::"+name,scaled);

        var toknob = this.patcher.getnamed(name);

However, since I have a number of functions in this js that process values and update interface elements, it seems I may be faced with creating a task for each function, which makes the js a bit cumbersome...if I have 5 functions in the js, suddenly I'm  faced with 5 more, plus 5 Tasks, which makes for a messy document :(  The other option would be a Task that updates all interface elements in one "burst", though, if the interface grows, that could get to be a big burst..hmmm...

I guess what I'm dreaming of is some simple built in function that would go something like this:
outletlimit(0,33,);

/*
takes a value in and scales it and passes it to pattrstorage.  If the value is coming from an "external interface" (eg MIDI), then it is appended with a "1" to enable the onscreen knob to display the external interface's values.
*/
function b(v,r)
{	
	var scaled = 2*v/127; //turn 0-127 into range of 0.-2.
	var name = "Bright";
	outlet(0,"1MovieLoop::"+name,scaled);
	if(r){
		var toknob = this.patcher.getnamed(name);
		toknob.set(v);
	}
}


> thanks for a more articulate version of what I've been playing 

> with...that helps clear up my head a bit!

> However, since I have a number of functions in this js that process 

> values and update interface elements, it seems I may be faced with 

> creating a task for each function, which makes the js a bit 

> cumbersome...if I have 5 functions in the js, suddenly I'm faced 

> with 5 more, plus 5 Tasks, which makes for a messy document :( The 

> other option would be a Task that updates all interface elements in 

> one "burst", though, if the interface grows, that could get to be a 

You can probably use one Task which read the five values. Otherwise 

there's no other route that I am aware of: you'll have to use one 

task for each element you want to send out.

> thanks for a more articulate version of what I've been playing  
> with...that helps clear up my head a bit!
>
> However, since I have a number of functions in this js that process  
> values and update interface elements, it seems I may be faced with  
> creating a task for each function, which makes the js a bit  
> cumbersome...if I have 5 functions in the js, suddenly I'm  faced  
> with 5 more, plus 5 Tasks, which makes for a messy document :(  The  
> other option would be a Task that updates all interface elements in  
> one "burst", though, if the interface grows, that could get to be a  
> big burst..hmmm...

You can probably use one Task which read the five values. Otherwise  
there's no other route that I am aware of: you'll have to use one  
task for each element you want to send out.

speedlim-type function in JS