Gtaylor@rtqe.net at 16:13, 6 July 2012

2012-07-06T16:13:30Z

Gtaylor@rtqe.net at 15:58, 6 July 2012

2012-07-06T15:58:41Z

Gtaylor@rtqe.net at 15:32, 28 June 2012

2012-06-28T15:32:25Z

Admin at 22:53, 24 June 2012

2012-06-24T22:53:52Z

Admin: Created page with " Click here to open the tutorial patch: 01iMappingMIDItoMSP.maxpat ===Introduction=== In this group of tutorials..."

2012-06-24T22:53:27Z

Created page with "<chapter name="MSP MIDI Tutorial 1: Mapping MIDI to MSP"> Click here to open the tutorial patch: 01iMappingMIDItoMSP.maxpat ===Introduction=== In this group of tutorials..."

New page

<chapter name="MSP MIDI Tutorial 1: Mapping MIDI to MSP">
Click here to open the tutorial patch: [[01iMappingMIDItoMSP.maxpat]]

===Introduction===

In this group of tutorials, we'll look at different strategies for integrating
MIDI control into MSP patchers. Commercial hardware synthesizers and samplers
typically implement MIDI in some form or another in fairly standardized ways;
software systems that mimic these devices (such as Max patches) can use all
the same routing and mapping systems to successfully control our sound-producing
systems with MIDI controllers.

A review of the tutorials that cover
<link type="tutorial" module="max" name="midichapter01">MIDI objects</link>
in Max may be useful before reading these tutorials.

* To use the tutorial patchers in this section of the tutorial, make sure you
have a correctly configured MIDI controller connected to your computer. The
tutorials in this section use a variety of MIDI messages as example input; if
your controller lacks any of these features, you can simulate their input with
user interface objects in the tutorial.

===MIDI, Redux===

The MIDI standard was developed to enable the control of electronic music devices
through the use of a simple serial communications standard that would be easy to
implement on any platform and could be used by anyone. As music performance
equipment has evolved in the 25 years since, MIDI has remained a standard-issue
interface protocol for nearly all music-making equipment, whether we're talking
about hardware or software. Whether you're interested in routing a keyboard,
slider box, or software sequencer in Max, you need to deal with translating
MIDI messages into numbers that make sense for MSP.

* Take a look at the tutorial patcher. The patcher logic consists of an FM synthesis
abstraction called <code>simpleFM~</code> controlled by a number of signal objects, the
values of which are set by floating-point {{maxword|name=number}} boxes. Turn on the
audio in the patcher by clicking on the {{maxword|name=ezdac~}} object and turn
up the {{maxword|name=gain~}} slider. Familiarize yourself with the
way the audio portion of the patcher works by trying different values is in
the {{maxword|name=number}} boxes labeled <code>1</code> through <code>5</code>.

Our patcher uses frequency modulation synthesis as we looked at earlier in the
tutorials, with the addition of a circuit that provides ''vibrato'' to the
main frequency of the synthesizer. The {{maxword|name=cycle~}} object labeled <code>Vibrato rate</code>
is scaled by the <code>Vibrato depth</code> control to oscillate the main frequency (the
output of the {{maxword|name=line~}} object on the right of the patcher. Unlike a vibrato circuit
which ''adds'' the output of a modulating oscillator to a constant frequency, this
patcher logic ''multiplies'' the constant frequency by the output of the oscillator
treated as an exponent by the {{maxword|name=pow~}} object. A vibrato depth of <code>1</code>,
therefore, has the equivalent of turning off the vibrato (raising <code>1</code> to
any power yields <code>1</code>, which leaves our main frequency untouched). A depth
of <code>2</code> scales the {{maxword|name=cycle~}} object to the range of <code>0.5</code> to <code>2.0</code>,
scaling the main frequency up and down by an octave.

The <code>Octave bend</code> value on the left allows us to use a value as a
frequency multiplier in a range where each unit of value transposes the
pitch by an octave. Like the vibrato circuit, it uses an exponential
scaling logic; a value of <code>0.</code> as the bend amount raises <code>2</code> to
the power of <code>0.</code>, yielding a multiplier of <code>1.</code> for the frequency.
An octave bend of <code>1.</code> yields a multiple of <code>2.</code>; a bend of <code>-1.</code>
yields a multiple of <code>0.5</code>.

===Scaling MIDI for signal control===

* Configure a MIDI continuous controller connected to your computer so that
it sends CC#1 on any MIDI channel (the modulation wheel on a keyboard
controller is a good candidate for this mapping). From the {{maxword|name=umenu}} object
labeled <code>A</code>, select option <code>1</code> ('Octave Pitch Bend'). Move your
controller and listen to and watch the result.

The Max {{maxword|name=ctlin}} object transmits our controller through the {{maxword|name=slider}} object
in the patcher and from there through a {{maxword|name=scale}} object. The {{maxword|name=gate}} object
allows us to route the controller to different destination {{maxword|name=number}} boxes
in the patcher. Notice that, with the default scaling, our MIDI number
range (<code>0</code> to <code>127</code>) maps to a floating-point value between <code>0.</code>
and <code>1.</code>

When working with MIDI messages, the general rule of thumb is that they
transmit integers which are typically in the range of <code>0</code> to <code>127</code>.
While these values make sense within the MIDI domain, when applied to signal
values these ranges are usually wrong. When we want to control an oscillator,
we need to think in terms of ''frequency'' (cycles per second or Hz), not
the ''pitch'' that MIDI note numbers refer to. When thinking about ''amplitude'',
we might want these numbers scaled between <code>0.</code> and <code>1.</code> to control the output
of a {{maxword|name=*~}} object. The {{maxword|name=scale}} object is an important utility object in Max
for performing these calculations.

* In the {{maxword|name=preset}} object at the right of the patcher, click the first circle.
The values for the {{maxword|name=scale}} object should change so that the <code>xmin</code>
and <code>xmax</code> values read <code>0</code> and <code>127</code>; the <code>ymin</code> and <code>ymax</code>
values should read <code>0.</code> and <code>2.</code> Move the MIDI controller and notice the
difference.

Using the settings controlled by this preset, we can take a MIDI controller
and use it to give us an octave bend range of two octaves. Setting the
controller to its lowest value will leave our FM synthesizer untransposed.
Moving it all the way up will cause the frequency to output two octaves
higher, at <code>880</code> Hz.

* Click in the {{maxword|name=number}} box labeled <code>ymin</code> and enter the value of <code>-2.</code>
Move your MIDI controller and notice the difference.

The {{maxword|name=scale}} object can map any range to any other range, including
negative values. Now our controller leaves the synthesizer untransposed in
the ''middle'' of its range; moving it downwards and upwards gives us
two octaves of shift in either direction.

* Click the other {{maxword|name=preset}} states available and try them out; each one
contains a different mapping and routing:

1 - Octave Pitch Bend. The controller outputs values from <code>0.</code> to <code>2.</code>

2 - Vibrato Rate. The controller outputs values from <code>2.</code> to <code>0.</code>, inverting
the scaling so that it runs from high to low.

3 - Vibrato Depth. The controller scales its input to run from <code>1.</code> to <code>100.</code>

4 - Modulation Index. The MIDI gets scaled from <code>0.</code> to <code>20.</code>

5 - Amplitude. The MIDI goes from <code>0.</code> to <code>1.</code> with an ''exponential scaling'' factor of <code>1.06</code>. Using this value means that upper values of the MIDI range control a wider part of the mapping than lower values.

Notice that different MSP parameters in our patch require different scalings,
none of which directly correspond to the default values of MIDI controllers.

* In patcher area <code>B</code>, look at the {{maxword|name=number}} boxes below the
{{maxword|name=notein}} object. Play some notes on a MIDI keyboard connected to
your computer.

When dealing with pitch in MIDI values, a utility Max object called {{maxword|name=mtof}} allows
us to convert directly to frequency. The {{maxword|name=stripnote}} object in this patch is
necessary to prevent double-triggering of values due to the note-off events
generated by the keyboard. Notice that because our MSP synth in this patch is
monophonic, only one note can be sounded at a time.

===Summary===

Working with MIDI controllers within the Max environment is extremely simple.
Using these values with MSP patches requires an understanding of how to ''map'' the
MIDI values appropriately for the different parameters of a digital signal
network. The Max {{maxword|name=scale}} and {{maxword|name=mtof}} objects are incredibly useful
for performing this function, and allow you to map MIDI input into
appropriate ranges for any number of applications.

===See Also===

{{maxword|name=scale}} - Map an input range of values to an output range

{{maxword|name=mtof}} - Convert a MIDI note number to frequency

[[Category:Teaching Material]]

← Older revision		Revision as of 16:13, 6 July 2012
Line 1:		Line 1:
−	Click here to open the tutorial ~~patches~~: [[Media:01iMappingMIDI.zip]]	+	Click here to open the tutorial patch and files: [[Media:01iMappingMIDI.zip]]

	===Introduction===		===Introduction===

← Older revision		Revision as of 15:58, 6 July 2012
Line 1:		Line 1:
−	Click here to open the tutorial ~~patch~~: [[Media:~~01iMappingMIDItoMSP~~.~~maxpat~~]]	+	Click here to open the tutorial patches: [[Media:01iMappingMIDI.zip]]

	===Introduction===		===Introduction===

← Older revision		Revision as of 15:32, 28 June 2012
Line 1:		Line 1:
−	Click here to open the tutorial patch: [[01iMappingMIDItoMSP.maxpat]]	+	Click here to open the tutorial patch: [[Media:01iMappingMIDItoMSP.maxpat]]

	===Introduction===		===Introduction===

← Older revision		Revision as of 22:53, 24 June 2012
Line 1:		Line 1:
−	~~<chapter name="MSP MIDI Tutorial 1: Mapping MIDI to MSP">~~
	Click here to open the tutorial patch: [[01iMappingMIDItoMSP.maxpat]]		Click here to open the tutorial patch: [[01iMappingMIDItoMSP.maxpat]]

MSP MIDI Tutorial 1: Mapping MIDI to MSP - Revision history

Gtaylor@rtqe.net at 16:13, 6 July 2012

Gtaylor@rtqe.net at 15:58, 6 July 2012

Gtaylor@rtqe.net at 15:32, 28 June 2012

Admin at 22:53, 24 June 2012

Admin: Created page with " Click here to open the tutorial patch: 01iMappingMIDItoMSP.maxpat ===Introduction=== In this group of tutorials..."