Pull the Trigger
The most commonly used type of macro is often referred to as a “trigger” macro. Typically, this is a series of short commands that are added to a cue, sequence, page change, view, or other console operation. These pre-defined commands allow the programmer to initiate a command at the same instance as a different action. For instance, a trigger macro can start chase 22 when cue 4 of a cuelist is played. By adding a unique trigger macro “code” to cue 4, the console knows to automatically start chase 22 whenever cue 4 is played.
Trigger-type macros are extremely powerful because they let programmers create complex triggering structures with very simple commands. Quite often, these are used within programming to automate tasks that would be difficult to accomplish manually. At other times, they are used to turn on or off various playbacks. In addition, trigger macros can be used for other console events such as page or view changes, thus changing the state of the console when certain cues are played. Trigger macros can often be triggered not only by playbacks, but by other events such as clock triggers, page changes or MIDI events.
Having a Good Start
Another wonderful use of trigger macros is to use these shortcuts in an “autostart” or boot capacity. If your console allows this functionality, you can define what happens when your show file is loaded into the console. Once defined, the console will automatically trigger the commands as the file opens. I find this extremely useful — I can set the state of the console every time it is turned on. Typically, I like to have a startup macro select a view, go to a specific page, and select a master playback.
With some shows, I also set up MIDI or SMPTE inputs, trigger specific playbacks or pop up messaging dialog boxes. Startup macros are very useful when you program a show but will not be operating it. That way, you are assured that the operator will start from the same configuration every time.
Automated Keystrokes
The other types of macro found on automated lighting consoles is commonly known as “keystroke” or “recorded” macros. These routines will record all your actions on the console and allow you to play them back as desired in either real time or instantly.
The power of recorded macros is that they allow the programmer to create and automate almost any type of functionality that is desired. Because of the power of repetition, you need to use caution when working with keystroke macros. It is important to think about what you are recording and understand how you will use this information when the macro is played back. It is also a good idea to know how to stop macro playback in the event that the macro is not working as expected.
Typically, your console will have a method to allow you to start recording a macro. From that moment on, everything you do on the desk will be recorded. Any button presses, touch screen events, encoder or fader movements will be logged into the macro. When you have finished recording, you initiate a command to let the console know to stop recording the macro. Once recorded, you can simply manually or remotely trigger the macro to playback, and it will repeat your commands exactly as recorded. If you paused for 30 seconds to think about your next keystroke, your macro will also pause for that duration. Some consoles allow you to edit the macro and adjust the duration between steps or to remove all timing completely for instantaneous playback. There are three key reasons for using keystroke macros: repetition, automation and additional functionality.
Macros for Repitition
Keystroke macros are most commonly used to aid in repeated tasks. For example, imagine that you have 100 cues programmed with 24 wash lights in various colors throughout the cues. Now the LD has decided that he wants to change all the cues so that the current color of the truss fixtures (the first 12 wash lights) is the same as the floor fixtures (the other 12). This would take you some time to go through and copy the color data from 1-12 to 13-24 in each and every cue. However, you could create a macro that does this once and then run the macro 100 times. This would speed up the process by saving you the repeated keystrokes. You could go further and make another macro (or cuelist with a trigger macro for the recorded macro) that runs your keystroke macro exactly 100 times. Now you can just press one button and watch the console make these changes for you. There are many times where keystroke macros are useful for repeated tasks, such as copying, altering data and correcting timing.
Making it Automatic
Consoles often need further automation than what is provided by the development team. With the use of a well-recorded keystroke macro, you can automate any combination of functions that would normally require multiple button presses. For instance, imagine that in the middle of a show you want to change an setting in the programming options window of your console. This change needs to happen before the top of Act II every night. You could simply record your actions of making this change into a macro and then trigger the macro at intermission. Now, every time the intermission cue is played, the option state will change. Of course, you probably also will want to create a macro at the top of the show to restore the option to the state needed for Act I. Not all shows will require the use of this type of macro, but they are very handy when you need automation of console tasks.
Adding Functionality
My favorite use of keystroke macros is to create things that aid in the use of the console, and, in doing so, I feel like I am adding functionality to the console. For instance, I recently worked on a show that had heavy use of media servers. I found that I was often turning an encoder wheel just a little bit to advance to the next file on the server. This mundane task was going to be repeated over and over as the LD was looking for content to play. Instead of taping the encoder wheel each time he called out “Next,” I created a macro. I simply recorded the action of turning the encoder a tiny bit to the right to advance one file. Then I recorded a second macro doing the same in the opposite direction. Once recorded, I created two single cues, each with a trigger macro to one of the recorded macros. Now I was able to press a flash key on the playback portion of my desk to increase or decrease the file parameter by a value of one. This was much easier than taping the encoder wheel, and far more accurate. I had “created” new functionality on the console by using a playback key as a programming key that did not previously exist on the desk. With a little thought, you will find other instances where you can build new features into your console too.
Where’s the Cheese?
Crafting macros on a lighting console can be fun and useful for any lighting programmer. By using both trigger and keystroke macros, you have many options available to you. Remember to use caution with macros, as they can also place consoles into endless loops or bizarre states that may be unexpected to the software. Macros can also be cheesy fun by enabling you to “chase” console LEDs or screens and other silly, useless tasks. If you are not using macros already, read up on the macro abilities of your console and start using this wonderful tool.
