This tutorial focuses on automated actions and the ability to control them. We will work with the toggle
user interface object to control the metro
timing object. We will also look further into object arguments and overriding those arguments.
One of the most used objects in your home is the light switch – it provides a simple user interface to a complex system (the lights in your home). Likewise, the toggle
object, combined with the automated timing function of metro
, offer a simple interface into an otherwise complicated world of automated and scheduled actions.
Take a look at the 04mMetroAndToggle patcher. The left-most patch features a series of message
boxes (and a button
) connected to a square box. Start by clicking in that box – we see its interior fill with a checkbox. A message was also sent from the object downstream to the number
box connected below it. Clicking in the object again will remove the checkbox and send out a . That's all this object does - it outputs either a zero or non-zero value, depending on its state (off or on). This object’s formal name is toggle
, and it is one of the most-used objects in Max programming.
Unlike most of the checkboxes that we run into when using our computers, this checkbox can be automated
by sending it messages. Click on the message
boxes that are connected to the toggle
to see their effect on the object’s state. By looking at the connected number
box, we see that any number other than turns it to "on" (the check mark is visually set); the toggle
also "echoes" the value of the number that turned it on out its outlet. Clicking on the message turns the toggle
off, and outputs a .
The action of the button
object is even more interesting. Clicking on the button
switches the toggle
object on and off, with the output (seen in the Max window and in the number
box) alternating between and . This is the root of the toggle
object's name – its ability to "toggle" states based on incoming messages.
The patch in the center introduces a new object: metro
. The metro
produces messages, much like the button
object. However, unlike button
objects send these messages automatically on a scheduled basis. Once started, metro
will continue to send messages until stopped. Click on the toggle
that is connected to the metro
, and watch the result – it sends a message (in this case, to a button
object) once every second. We can turn it off by un-checking (turning off) the toggle
. the metro
object is one of the Max objects that can be used to create automated or self-running actions in our programs.
If we click on the button
that is connected to the metro
we see that it, too, starts the metro
running. If we click on it again, we see that it immediately triggers a out of the metro
immediately; rapidly click on the button
, and the output continues being generated. It is only when we pause that we see the scheduled event generation. When a metro
receives a , the metro
will "re-start" itself and begin scheduling subsequent messages from the moment we triggered it. When we want to turn it off, we can click on the message to turn off event generation; telling a metro
to with a message is equivalent to sending it a .
How did we determine the speed
at which the metro
outputs messages? We determine the speed of a metro
by setting its period. The metro
object takes an argument
(the number , in this case) that sets the time interval (in milliseconds
) between messages. 1000 milliseconds equals 1 second, which is why we see the messages coming out at that rate. How do we change this rate? That is the function of metro
object's right inlet
– it allows you to send a new time interval setting without having to type in a new argument value.
In our patch, there is a number
box with several message
boxes connected to it. Click on the message, and (after the next scheduled period) the output will slow to one message every two seconds. Click on the and the metro
speeds up, sending messages twice a second. The message will cause four messages per second. Changing the interval setting doesn’t change any other aspect of metro
(e.g. whether it is "on" or "off").
Changing the interval with a message in the right inlet also does not change the argument of the metro
. Why not? Wouldn’t it be convenient to see the new value? Perhaps, but it would mean that any changes to the object would change the value saved with the patch – and, most times, you want to maintain the typed-in argument since it functions as the default starting value of the metro
. Many Max objects behave in this way: they have one or more arguments that can be overridden
by messages sent into inlets.
The third patcher in our tutorial features a single toggle
attached to three additional toggle
objects, each of which is connected to a metro
with a different argument. Turn on the top-level toggle
, and the metro
objects generate a "galloping" light show. This is because the three time interval arguments of the metro
objects are related: the first metro
fires every second ( milliseconds), the second triggers three times per second, and the third fires every quarter-second. There is nothing managing this pattern – it just occurs because the scheduled output of the metro
objects are constant, so the pattern keeps appearing. Note that the time interval of a metro
can be both an integer
(e.g. ) or a floating-point
(e.g. ) number.
Let’s expand on the idea of creating rhythmic patterns by using some of the other ideas we just learned. We can change the pattern by changing the time values of each metro
; let’s start by adding three message
boxes, of values , and , and connecting one to the right inlet of each metro
. When we click them to change the time intervals of our metro
objects, no apparent pattern exists. This is because we need to synchronize the start of the metro
objects to see the pattern. This can be accomplished by turning the top-most toggle
off and on again. The result is a quickly flashing center light, with a syncopated outside pattern.
Let’s make another pattern, using message
boxes for the values , , and , respectively. However, instead of using the toggle
to switch the metro
objects off and on, connect a single button
object to the left inlet of all three metro
objects. Click on the three message
boxes, and then click on the button
to restart all of the metro
objects. The button
forces the metro
objects to restart in sync
, giving us the expected "rolling" light show.
Automated actions are at the heart of many Max performance patches, and metro
objects are often used as the starting point for these actions. Once started, the scheduling system of Max provides a stable timing system for Max output, and we can allow the events to run without further interaction.
Controlling patches using the checkbox-like toggle
object is also a key programming tool, since a single toggle
can provide a simple on/off interface to much more complicated processes.
Switch between off and on (0 and 1)
Output a bang message at regular intervals