I am writing a metro-type external that takes an inital tempo argument, and then 2 floats as additional arguments that are ratios of the initial tempo to determine the subsequent beats of the metronome. The object works when I input the floats through the inlets but it doesn't work when I input arguments directly into the object box. Pls help!

#include "ext.h" // Required for all Max external objects

void *class; // Required. Global pointing to this class

typedef struct _metro /* data structure for this object */

t_object m_ob; /* must always be the first field; used by Max */

void *m_clock; /* pointer to clock object */

void *m_clock1a; /* pointer to clock object */

void *m_clock1b; /* pointer to clock object */

void *m_clock2; /* pointer to clock object */

void *m_clock2a; /* pointer to clock object */

void *m_clock2b; /* pointer to clock object */

void *m_clock3; /* pointer to clock object */

long m_interval; /* tempo in milliseconds */

float m_interval2; /* ratio, relative to initial tempo, of 2nd bang */

float m_interval3; /* ratio, relative to initial tempo, of 3rd bang */

void *m_bang_outlet; /* pointers to bang outlet */

void *m_time_outlet; /* pointers to time outlet */

void *metro_new(long value, float value2, float value3);

void metro_in2(t_metro *m, float value2);

void metro_in3(t_metro *m, float value3);

void metro_assist(t_metro *m, t_object *b, long msg, long arg, char *s);

/* set up our class: create a class definition */

setup((t_messlist **) &class, (method)metro_new, (method)metro_free,

(short)sizeof(t_metro), 0L, A_DEFLONG, A_DEFFLOAT, A_DEFFLOAT, 0);

/* bind method "metro_bang" to the "bang" message */

/* bind method "metro_in1" to int's received in the 1st inlet */

/* bind method "metro_in2" to int's received in the 2nd inlet */

m->m_interval2 = value2; // save tempo argument from box

post("2nd beat tempo set to %f", (float) (value2 * (float) m->m_interval));

m->m_interval2 = DEFAULT_TEMPO2; // set to default tempo

post("2nd beat set to default tempo of %f", DEFAULT_TEMPO2);

m->m_interval3 = value3; // save tempo argument from box

post("3rd beat tempo set to %f", (float) ((float) value * value3));

m->m_interval3 = DEFAULT_TEMPO3; // set to default tempo

post("3rd beat set to default tempo of %f", DEFAULT_TEMPO3);

m->m_clock = clock_new(m, (method)clock_function); // create the metronome clock

m->m_clock1a = clock_new(m, (method)clock_function1a); // create the metronome clock

m->m_clock1b = clock_new(m, (method)clock_function1b); // create the metronome clock

m->m_clock2 = clock_new(m, (method)clock_function2); // create the metronome clock

m->m_clock2a = clock_new(m, (method)clock_function2a); // create the metronome clock

m->m_clock2b = clock_new(m, (method)clock_function2b); // create the metronome clock

m->m_clock3 = clock_new(m, (method)clock_function3); // create the metronome clock

m->m_time_outlet = intout(m); // create right outlet for time

m->m_bang_outlet = bangout(m); // create left outlet for ticks

/*************************************************************************************

description: stores the new metronome tempo value

*************************************************************************************/

m->m_interval = value; // store the new metronome interval

post("metronome tempo changed to %ld", value);

m->m_interval2 = value2; // store the new metronome interval

post("2nd beat changed to %f", (value2 * m->m_interval));

m->m_interval3 = value3; // store the new metronome interval

post("3rd beat changed to %f", (value3 * m->m_interval));

description: method called when bang is received: it starts the metronome

clock_delay(m->m_clock, 0L); // set clock to go off now, 1st beat

clock_delay(m->m_clock1a, ((2 * m->m_interval) + (m->m_interval2 * (float) m->m_interval) + (m->m_interval3 * (float) m->m_interval))); // set clock to go off later, 1st beat continued after m_clock is stopped

clock_delay(m->m_clock1b, (m->m_interval + 1)); // set clock to go off later, will turn off m_clock

clock_delay(m->m_clock2, 0L); // set clock to go off now, 2nd beat

clock_delay(m->m_clock2a, ((2 * m->m_interval) + (2 * (m->m_interval2 * (float) m->m_interval)) + (m->m_interval3 * (float) m->m_interval))); // set clock2 to go off later, 2nd beat continued after m_clock is stopped

clock_delay(m->m_clock2b, (m->m_interval + (m->m_interval2 * (float) m->m_interval) + 1)); // set clock2 to go off later, will turn off m_clock

clock_delay(m->m_clock3, 0L); // set clock to go off now, 3rd beat

description: method called when myMetro receives "stop" message. Stops the metronome

clock_unset(m->m_clock); // remove the clock routine from the scheduler

clock_unset(m->m_clock1a); // remove the clock routine from the scheduler

clock_unset(m->m_clock1b); // remove the clock routine from the scheduler

clock_unset(m->m_clock2); // remove the clock routine from the scheduler

clock_unset(m->m_clock2a); // remove the clock routine from the scheduler

clock_unset(m->m_clock2b); // remove the clock routine from the scheduler

clock_unset(m->m_clock3); // remove the clock routine from the scheduler

description: method called when clock goes off: it outputs a bang to be sent to the

outlet and resets the clock to go off after the next interval.

clock_delay(m->m_clock, m->m_interval); // schedule another metronome click

outlet_bang(m->m_bang_outlet); // send out a bang

outlet_int(m->m_time_outlet, time); // send current time to right outlet

    clock_unset(m->m_clock); // remove the clock routine from the scheduler

if (time == (2 * m->m_interval) + m->m_interval2 + time) {

    clock_delay(m->m_clock, m->m_interval); // schedule another metronome click

clock_delay(m->m_clock1a, (m->m_interval + (m->m_interval2 * (float) m->m_interval) + (m->m_interval3 * (float) m->m_interval))); // schedule another metronome click

clock_delay(m->m_clock2, (m->m_interval + (m->m_interval2 * (float) m->m_interval))); // schedule another metronome click

clock_delay(m->m_clock2a, (m->m_interval + (m->m_interval2 * (float) m->m_interval) + (m->m_interval3 * (float) m->m_interval))); // schedule another metronome click

clock_delay(m->m_clock3, m->m_interval + (m->m_interval2 * (float) m->m_interval) + (m->m_interval3 * (float) m->m_interval)); // schedule another metronome click

description: method called when t_metro objects is destroyed. It is used to free memory

clock_free(m->m_clock); // free the clock memory

clock_free(m->m_clock1a); // free the clock memory

clock_free(m->m_clock1b); // free the clock memory

clock_free(m->m_clock2); // free the clock memory

clock_free(m->m_clock2a); // free the clock memory

clock_free(m->m_clock2b); // free the clock memory

clock_free(m->m_clock3); // free the clock memory

void metro_assist(t_metro *m, t_object *b, long msg, long arg, char *s)

        case 0: sprintf(s, "%s", "bang to start, 'stop' to stop");

        case 1: sprintf(s, "%s", "tempo / scaling factor in milliseconds");

        case 2: sprintf(s, "%s", "2nd beat, input float ratio of tempo");

        case 3: sprintf(s, "%s", "3rd beat, input float ratio of tempo");

        case 0: sprintf(s, "%s", "bangs at each metronome interval");

        case 1: sprintf(s, "%s", "outputs current time");        

I am writing a metro-type external that takes an inital tempo argument, and then 2 floats as additional arguments that are ratios of the initial tempo to determine the subsequent beats of the metronome.  The object works when I input the floats through the inlets but it doesn't work when I input arguments directly into the object box.  Pls help!

#include "ext.h" // Required for all Max external objects
void *class; // Required. Global pointing to this class
#define DEFAULT_TEMPO 1000
#define MIN_TEMPO 15
#define DEFAULT_TEMPO2 1.0
#define MIN_TEMPO2 0.00001
#define DEFAULT_TEMPO3 1.0
#define MIN_TEMPO3 0.00001
typedef struct _metro /* data structure for this object */
{
t_object m_ob; /* must always be the first field; used by Max */
void *m_clock; /* pointer to clock object */
void *m_clock1a; /* pointer to clock object */
void *m_clock1b; /* pointer to clock object */
void *m_clock2; /* pointer to clock object */
void *m_clock2a; /* pointer to clock object */
void *m_clock2b; /* pointer to clock object */
void *m_clock3; /* pointer to clock object */
long m_interval; /* tempo in milliseconds */
float m_interval2; /* ratio, relative to initial tempo, of 2nd bang */
float m_interval3; /* ratio, relative to initial tempo, of 3rd bang */
void *m_bang_outlet; /* pointers to bang outlet */
void *m_time_outlet; /* pointers to time outlet */
} t_metro;
void *metro_new(long value, float value2, float value3);
void metro_in1(t_metro *m, long value);
void metro_in2(t_metro *m, float value2);
void metro_in3(t_metro *m, float value3);
void metro_bang(t_metro *m);
void metro_assist(t_metro *m, t_object *b, long msg, long arg, char *s);
void metro_free(t_metro *m);
void metro_stop(t_metro *m);
void clock_function(t_metro *m);
void clock_function1a(t_metro *m);
void clock_function1b(t_metro *m);
void clock_function2(t_metro *m);
void clock_function2a(t_metro *m);
void clock_function2b(t_metro *m);
void clock_function3(t_metro *m);
int main(void)
{
/* set up our class: create a class definition */
setup((t_messlist **) &class, (method)metro_new, (method)metro_free,
(short)sizeof(t_metro), 0L, A_DEFLONG, A_DEFFLOAT, A_DEFFLOAT, 0);
/* bind method "metro_bang" to the "bang" message */
addbang((method)metro_bang);
/* bind method "metro_in1" to int's received in the 1st inlet */
addinx((method)metro_in1,1);
/* bind method "metro_in2" to int's received in the 2nd inlet */
addinx((method)metro_in2,2);
/* bind method "metro_in3" to int's received in the 3rd inlet */
addinx((method)metro_in3,3);
/* bind method "metro_stop" to the "stop" message" */
addmess((method)metro_stop,"stop",0);
/* bind method "metro_assist" to the assistance message" */
addmess((method)metro_assist,"assist",A_CANT,0);
/* add class to the New object list */
finder_addclass("All Objects","phrasetro");
return (0);
}
/**********************************************************************************
metro_new(long value)
inputs: value - the integer from the typed in argument in the object box
description: creates a new instance of this class metro.
returns: pointer to new instance
*************************************************************************************/
void *metro_new(long value, float value2, float value3)
{
t_metro *m;
m = (t_metro *)newobject(class); // create the new instance and return a pointer to it
if (value > MIN_TEMPO) // initialize
{
m->m_interval = value; // save tempo argument from box
post("phrasetro tempo set to %ld", value);
}
else
{
m->m_interval = DEFAULT_TEMPO; // set to default tempo
post("phrasetro set to default tempo of %ld ms", DEFAULT_TEMPO);
}

if (value2 > MIN_TEMPO2) // initialize
{
m->m_interval2 = value2; // save tempo argument from box
post("2nd beat tempo set to %f", (float) (value2 * (float) m->m_interval));
}
else
{
m->m_interval2 = DEFAULT_TEMPO2; // set to default tempo
post("2nd beat set to default tempo of %f", DEFAULT_TEMPO2);
}

if (value3 > MIN_TEMPO3) // initialize
{
m->m_interval3 = value3; // save tempo argument from box
post("3rd beat tempo set to %f", (float) ((float) value * value3));
}
else
{
m->m_interval3 = DEFAULT_TEMPO3; // set to default tempo
post("3rd beat set to default tempo of %f", DEFAULT_TEMPO3);
}

m->m_clock = clock_new(m, (method)clock_function); // create the metronome clock
m->m_clock1a = clock_new(m, (method)clock_function1a); // create the metronome clock
m->m_clock1b = clock_new(m, (method)clock_function1b); // create the metronome clock
m->m_clock2 = clock_new(m, (method)clock_function2); // create the metronome clock
m->m_clock2a = clock_new(m, (method)clock_function2a); // create the metronome clock
m->m_clock2b = clock_new(m, (method)clock_function2b); // create the metronome clock
m->m_clock3 = clock_new(m, (method)clock_function3); // create the metronome clock
intin(m, 3); // create the 4th inlet
intin(m, 2); // create the 3rd inlet
intin(m, 1); // create the 2nd inlet
m->m_time_outlet = intout(m); // create right outlet for time
m->m_bang_outlet = bangout(m); // create left outlet for ticks
return(m);
}
/*************************************************************************************
metro_in1(t_metro *m, long value)
inputs: m -- pointer to our object
value -- value received in the inlet
description: stores the new metronome tempo value
*************************************************************************************/
void metro_in1(t_metro *m, long value)
{
m->m_interval = value; // store the new metronome interval
post("metronome tempo changed to %ld", value);
}

void metro_in2(t_metro *m, float value2)
{
m->m_interval2 = value2; // store the new metronome interval
post("2nd beat changed to %f", (value2 * m->m_interval));
}

void metro_in3(t_metro *m, float value3)
{
m->m_interval3 = value3; // store the new metronome interval
post("3rd beat changed to %f", (value3 * m->m_interval));
}

/*************************************************************************************
void metro_bang(t_metro *m)
inputs: m -- pointer to our object
description: method called when bang is received: it starts the metronome
*************************************************************************************/
void metro_bang(t_metro *m)
{
long time;
time = gettime(); // get current time
clock_delay(m->m_clock, 0L); // set clock to go off now, 1st beat
clock_delay(m->m_clock1a, ((2 * m->m_interval) + (m->m_interval2 * (float) m->m_interval) + (m->m_interval3 * (float) m->m_interval))); // set clock to go off later, 1st beat continued after m_clock is stopped
clock_delay(m->m_clock1b, (m->m_interval + 1)); // set clock to go off later, will turn off m_clock
clock_delay(m->m_clock2, 0L); // set clock to go off now, 2nd beat
clock_delay(m->m_clock2a, ((2 * m->m_interval) + (2 * (m->m_interval2 * (float) m->m_interval)) + (m->m_interval3 * (float) m->m_interval))); // set clock2 to go off later, 2nd beat continued after m_clock is stopped
clock_delay(m->m_clock2b, (m->m_interval + (m->m_interval2 * (float) m->m_interval) + 1)); // set clock2 to go off later, will turn off m_clock
clock_delay(m->m_clock3, 0L); // set clock to go off now, 3rd beat
post("clock started at %ld", time);
}
/*************************************************************************************
void metro_stop(t_metro *m)
inputs: m -- pointer to our object
description: method called when myMetro receives "stop" message. Stops the metronome
*************************************************************************************/
void metro_stop(t_metro *m)
{
long time;
time = gettime(); // get current time
clock_unset(m->m_clock); // remove the clock routine from the scheduler
clock_unset(m->m_clock1a); // remove the clock routine from the scheduler
clock_unset(m->m_clock1b); // remove the clock routine from the scheduler
clock_unset(m->m_clock2); // remove the clock routine from the scheduler
clock_unset(m->m_clock2a); // remove the clock routine from the scheduler
clock_unset(m->m_clock2b); // remove the clock routine from the scheduler
clock_unset(m->m_clock3); // remove the clock routine from the scheduler
outlet_int(m->m_time_outlet, time);
post("metronome stopped at %ld", time);
}
/*************************************************************************************
void clock_function(t_metro *m)
inputs: m -- pointer to our object
description: method called when clock goes off: it outputs a bang to be sent to the
outlet and resets the clock to go off after the next interval.
*************************************************************************************/
void clock_function(t_metro *m)
{
long time;

time = gettime(); // get current time
clock_delay(m->m_clock, m->m_interval); // schedule another metronome click
outlet_bang(m->m_bang_outlet); // send out a bang
outlet_int(m->m_time_outlet, time); // send current time to right outlet
post("clock_function 1 %ld", time);
}
/* if (time == time + m->m_interval) {
	clock_unset(m->m_clock); // remove the clock routine from the scheduler
	post("clock1 off");
	}
if (time == (2 * m->m_interval) + m->m_interval2 + time) {
	clock_delay(m->m_clock, m->m_interval); // schedule another metronome click
	post("clock1-2 on");
	} 
*/

void clock_function1a(t_metro *m)
{
long time;

time = gettime(); // get current time
clock_delay(m->m_clock1a, (m->m_interval + (m->m_interval2 * (float) m->m_interval) + (m->m_interval3 * (float) m->m_interval))); // schedule another metronome click
outlet_bang(m->m_bang_outlet); // send out a bang
outlet_int(m->m_time_outlet, time); // send current time to right outlet
post("clock_function 1a %ld", time);
}

void clock_function1b(t_metro *m)
{
long time;

time = gettime(); // get current time
clock_unset(m->m_clock); // remove the clock routine from the scheduler
outlet_int(m->m_time_outlet, time); // send current time to right outlet
post("clock1 stopped at %ld", time);
}

void clock_function2(t_metro *m)
{
long time;

time = gettime(); // get current time
clock_delay(m->m_clock2, (m->m_interval + (m->m_interval2 * (float) m->m_interval))); // schedule another metronome click
outlet_bang(m->m_bang_outlet); // send out a bang
outlet_int(m->m_time_outlet, time); // send current time to right outlet
post("clock_function 2 %ld", time);
}

void clock_function2a(t_metro *m)
{
long time;

time = gettime(); // get current time
clock_delay(m->m_clock2a, (m->m_interval + (m->m_interval2 * (float) m->m_interval) + (m->m_interval3 * (float) m->m_interval))); // schedule another metronome click
outlet_bang(m->m_bang_outlet); // send out a bang
outlet_int(m->m_time_outlet, time); // send current time to right outlet
post("clock_function 2a %ld", time);
}

void clock_function2b(t_metro *m)
{
long time;

time = gettime(); // get current time
clock_unset(m->m_clock2); // remove the clock routine from the scheduler
outlet_int(m->m_time_outlet, time); // send current time to right outlet
post("clock2 stopped at %ld", time);
}

void clock_function3(t_metro *m)
{
long time;

time = gettime(); // get current time
clock_delay(m->m_clock3, m->m_interval + (m->m_interval2 * (float) m->m_interval) + (m->m_interval3 * (float) m->m_interval)); // schedule another metronome click
outlet_bang(m->m_bang_outlet); // send out a bang
outlet_int(m->m_time_outlet, time); // send current time to right outlet
post("clock_function 3 %ld", time);
}

/*************************************************************************************
metro_free(t_metro *m)
inputs: m -- pointer to our object
description: method called when t_metro objects is destroyed. It is used to free memory
allocated to the clock.
*************************************************************************************/
void metro_free(t_metro *m)
{
clock_unset(m->m_clock); // remove the clock routine from the scheduler
clock_unset(m->m_clock1a); // remove the clock routine from the scheduler
clock_unset(m->m_clock1b); // remove the clock routine from the scheduler
clock_unset(m->m_clock2); // remove the clock routine from the scheduler
clock_unset(m->m_clock2a); // remove the clock routine from the scheduler
clock_unset(m->m_clock2b); // remove the clock routine from the scheduler
clock_unset(m->m_clock3); // remove the clock routine from the scheduler
clock_free(m->m_clock); // free the clock memory
clock_free(m->m_clock1a); // free the clock memory
clock_free(m->m_clock1b); // free the clock memory
clock_free(m->m_clock2); // free the clock memory
clock_free(m->m_clock2a); // free the clock memory
clock_free(m->m_clock2b); // free the clock memory
clock_free(m->m_clock3); // free the clock memory
}

void metro_assist(t_metro *m, t_object *b, long msg, long arg, char *s)
{
	if (msg == ASSIST_INLET)
	{
		switch (arg)
		{
		case 0: sprintf(s, "%s", "bang to start, 'stop' to stop");
				break;
		case 1: sprintf(s, "%s", "tempo / scaling factor in milliseconds");
				break;
		case 2: sprintf(s, "%s", "2nd beat, input float ratio of tempo");
				break;
		case 3: sprintf(s, "%s", "3rd beat, input float ratio of tempo");
		}
	} 

	else if (msg == ASSIST_OUTLET)
	{
		switch (arg)
		{
		case 0: sprintf(s, "%s", "bangs at each metronome interval");
				break;
		case 1: sprintf(s, "%s", "outputs current time");		
		}
	}
}


problem-w-arguments-in-external

> I am writing a metro-type external that takes an inital tempo argument,

> and then 2 floats as additional arguments that are ratios of the initial

> tempo to determine the subsequent beats of the metronome. The object works

> when I input the floats through the inlets but it doesn't work when I input

> arguments directly into the object box. Pls help!

Haven't had a very close look at your code, but at first glance I'd say

make the arguments to your new function "double". The use of A_DEFFLOAT for

your new function is correct, but use double in the actual function calls.

Max uses the "double" type for floating point numbers.

On 12/11/06, Scott  wrote:
>
>
> I am writing a metro-type external that takes an inital tempo argument,
> and then 2 floats as additional arguments that are ratios of the initial
> tempo to determine the subsequent beats of the metronome.  The object works
> when I input the floats through the inlets but it doesn't work when I input
> arguments directly into the object box.  Pls help!

Haven't had a  very close look at your code, but at first glance I'd say
make the arguments to your new function "double". The use of A_DEFFLOAT for
your new function is correct, but use double in the actual function calls.
Max uses the "double" type for floating point numbers.

I tried replacing "float" w/ "double" and that didn't fix the problem. It seems to me the problem is somewhere in the *metro_new function but I can't seem to figure out what it is. The object is not responding to the input arguments within the object box and when there are no arguments input, the object isn't outputting the correct default values...

I tried replacing "float" w/ "double" and that didn't fix the problem.  It seems to me the problem is somewhere in the *metro_new function but I can't seem to figure out what it is.  The object is not responding to the input arguments within the object box and when there are no arguments input, the object isn't outputting the correct default values...


I haven't looked at your code closely either, but are you sure the 

constructor is executing properly? Do your various post messages 

> I tried replacing "float" w/ "double" and that didn't fix the

> problem. It seems to me the problem is somewhere in the *metro_new

> function but I can't seem to figure out what it is. The object is

> not responding to the input arguments within the object box and when

> there are no arguments input, the object isn't outputting the correct

I haven't looked at your code closely either, but are you sure the 
constructor is executing properly? Do your various post messages 
actually appear?

Scott wrote:
> I tried replacing "float" w/ "double" and that didn't fix the
> problem.  It seems to me the problem is somewhere in the *metro_new
> function but I can't seem to figure out what it is.  The object is
> not responding to the input arguments within the object box and when
> there are no arguments input, the object isn't outputting the correct


> I tried replacing "float" w/ "double" and that didn't fix the 

> problem. It seems to me the problem is somewhere in the *metro_new 

> function but I can't seem to figure out what it is. The object is 

> not responding to the input arguments within the object box and 

> when there are no arguments input, the object isn't outputting the 

Since your object s seems to be named 'metro'... ahem, sorry for 

asking, but are you sure what you get in your patch is not the metro 

>
> I tried replacing "float" w/ "double" and that didn't fix the  
> problem.  It seems to me the problem is somewhere in the *metro_new  
> function but I can't seem to figure out what it is.  The object is  
> not responding to the input arguments within the object box and  
> when there are no arguments input, the object isn't outputting the  
> correct default values...

Since your object s seems to be named 'metro'... ahem, sorry for  
asking, but are you sure what you get in your patch is not the metro  
object that comes with Max/MSP?

it is actually called phrasetro, everything else in the object works correctly, it just isn't recognizing the 2nd and 3rd initial argument.

I am not sure where the problem is. The thing is, when I input floats into the object from number boxes, everything works fine. The problem is when I type in floats as arguments in the object box.

I am not sure where the problem is.  The thing is, when I input floats into the object from number boxes, everything works fine.  The problem is when I type in floats as arguments in the object box.


But when you instantiate the object with args, you see the messages from 

your post() calls in the message window, yes?

The point is to try and nail down what's going on - either something's 

not happening, or the right thing is happening and then something 

unhappens it, or there's something weird at work. When mystified I tend 

to plaster everything in post() calls, or equivalent, so you can really 

> I am not sure where the problem is. The thing is, when I input

> floats into the object from number boxes, everything works fine. The

> problem is when I type in floats as arguments in the object box.

But when you instantiate the object with args, you see the messages from 
your post() calls in the message window, yes?

The point is to try and nail down what's going on - either something's 
not happening, or the right thing is happening and then something 
unhappens it, or there's something weird at work. When mystified I tend 
to plaster everything in post() calls, or equivalent, so you can really 
get an idea of what's happening where.

Scott wrote:
> I am not sure where the problem is.  The thing is, when I input
> floats into the object from number boxes, everything works fine.  The
> problem is when I type in floats as arguments in the object box.


right, totally, that is actually how I know something is wrong. So here are the posts:

when I just type the name of the object I get:

phrasetro set to default tempo of 1000 /* which is correct */ 

2nd beat set to default tempo of 1.000 /* which is correct */

3rd beat tempo set to 0.000 /* this is wrong, it should say "3rd beat set to default tempo of 1.00*/

when I type in the arguments 1000 .5 .2 I get:

2nd beat set to default tempo of 1.000 /* which is incorrect, it should say "2nd beat set to 0.5" */

3rd beat tempo set to 4503599627370496000.000 /* this is very wrong, it should say "3rd beat set to 0.2*/

right, totally, that is actually how I know something is wrong.  So here  are the posts:

phrasetro set to default tempo of 1000  /* which is correct */ 
2nd beat set to default tempo of 1.000 /* which is correct */
3rd beat tempo set to 0.000 /* this is wrong, it should say "3rd beat set to default tempo of 1.00*/

phrasetro set to default tempo of 1000  /* which is correct */ 
2nd beat set to default tempo of 1.000 /* which is incorrect, it should say "2nd beat set to 0.5" */
3rd beat tempo set to 4503599627370496000.000 /* this is very wrong, it should say "3rd beat set to 0.2*/

I recommend that beyond collecting a single parameter, you use the A_GIMME approach for parameter collection. This will bypass MaxMSP's non-intuitive limitations on the number and type of arguments that can be safely passed when specifying individual elements a la A_FLOAT, A_LONG, etc.

> void *metro_new(long value, float value2, float value3)

Since about 1998 all floating point parameters are passed as double- 

precision in Max. This is documented in the SDK. Although it's easy 

enough to get confused (because Atoms are single precision), it is 

absolutely essential to get the parameter passing straight, otherwise 

It's the floats that make toil and trouble.

Some compilers automatically treat upgrade float to double in 

function declarations, but you don't say which compiler you're using. 

On 12-Dec-2006, at 10:27, Eric Lyon wrote:

> I recommend that beyond collecting a single parameter, you use the 

> A_GIMME approach for parameter collection. This will bypass 

> MaxMSP's non-intuitive limitations on the number and type of 

> arguments that can be safely passed when specifying individual 

The limitations are wierd but have been documented on the dev list in 

the distant past. The problem is that the Max argument parser is 

broken for argument lists with mixed types if there are more than 3 

arguments (or maybe it's starting with 3 args).

    setup(... A_LONG, A_LONG, A_LONG, A_LONG, 0); // cool

    setup(... A_FLOAT, A_FLOAT, A_FLOAT, A_FLOAT, 0); // groovy

    setup(... A_FLOAT, A_LONG, A_FLOAT, A_FLOAT, 0); // URK!

In the third example you must use A_GIMME.

Problem w/ arguments in external