Foreign-Call Controller

The 'foreign-call controller can be created using the following Lisp syntax:

The 'foreign-call controller takes the following arguments:

• dimension: number of dimensions for the output controller.
• period: the time between controller updates (in synthesis seconds).
• foreign_function: a Lisp or Scheme function representing the expression to be evaluated. see details, below.
• controller1, controller2, etc...: controllers to "plug-in" to the math expression.

The output controller can be optionally re-sampled using the period argument. A period of 0, as always, indicates the controller will be updated every sample.

The Lisp or Scheme lambda function with no arguments, says how to update the "output latch" from the "input latches". See description, below, for details.

A variable number of controllers may be provided as a list.

Here is a practical example of how to use the 'foreign-call controller to multiply two controllers (my-ctl1 and my-ctl2):

That is equivalent to the 'expression controller:

Or the 'arithmetic controller:

Naturally, apart from simply accepting input controllers, any Modalys or Lisp programming function may be called within the lambda function. Here is an example of how the speed of an access can be obtained using the 'foreign-call controller:

Obtaining the access speed this way is considerably more computationally expensive than using the 'access-speed controller, however, there may be other esoteric uses of the 'foreign-call controller to obtain seldom-accessed Modalys data.

Although we generally recommend using the 'expression, 'arithmetic or other controllers when and where possible (did we mention that they were a lot faster???!), there may be some advanced or expert techniques which require the 'foreign-call controller to do specific tasks, so the function has been retained in the Modalys environment.

It's worth studying the update function a bit (actually you need to know how to program a little bit in Lisp, Scheme or a related programming language in order to really understand this well). The update function must begin like this (of course, "inputs" and "output" could be other variable names like "ins" and "out"):

This is then followed by programming statements that are used to change the value in the controller's "output box" by using the function (vset ... ). Therefore, to put the value 31.2 in the first dimension of your output box, you would write:

Notice that the output dimensions are numbered starting from zero. Thus, you could change the second dimension using:

and so forth. Naturally, to know how to update its output, the function must have access to all the values in the input controllers. To get the inputs, you use the (vget ... ) function like this:

This gets the first dimension of the first input - both are numbered starting from 0. So, if you type:

you get the second dimension of the first input, or if you type:

you get the first dimension of the second input, and so on. Therefore:

would get the 22nd dimension of the 19th input. So you can see that the following function:

means that the update rule is: "get the first dimension of the first input controller; then, get the first dimension of the second input controller. Multiply them together, and stick the result in the first dimension of my own output box."

This is a useful general-programming-like way of using a controller, however for most basic math operations you can use the 'arithmetic controller or for more complex expressions, the 'expression controller.

This controller was formerly called (make-controller 'scheme ... ) and had a slightly different syntax where the number of input controllers had to be explicitly given before the list containing them:

Additionally, the scheme lambda function syntax was a tiny bit different. The simple example shown in the discussion, above, would have looked like this:

Any very old Modalys scripts which still use scheme controllers will need to be updated to use the 'foreign-call or, preferably, the 'expression controller, instead.