Create a folder called workspace, and unzip all files contained in mck_0228.zip and mckc025.zip into this folder. Now extract only nesasm.exe from mkit251_dos.zip into this same folder. Next, create a new folder inside workspace called DMCconv, and extract the files from dmcconv005.zip into this folder.

Create a new text file, call it songdata.mml, and place it in your workspace folder. This is the text file from which you will use the Music Macro Language (MML) to program your tune. First, open make_nsf.txt, and scroll to the end of the file where you will find several .include statements. After the last one, add this line to the file: .include "songdata.h".

Also look for these lines in make_nsf.txt:

.org    $800E
   db   "Song Name"
   db   $00
.org    $802E
   db   "Artist"
   db   $00
.org    $804E
   db   "Maker"
   db   $00

This is the part of the NSF header that identifies the tune. Modify these header fields appropriately, as shown next (be aware that there is a 31-character limit for each):

.org    $800E
   db   "My First NES Chip"
   db   $00
.org    $802E
   db   "Nullsleep"
   db   $00
.org    $804E
   db   "2003 Jeremiah Johnson"
   db   $00

After opening up songdata.mml in your preferred text editor, you should add header lines to the top of the file; these identify yourself as the composer and note the title of the song. For example:

#TITLE My First NES Chip
#COMPOSER Nullsleep
#PROGRAMER 2003 Jeremiah Johnson

Note that the incorrect spelling of #PROGRAMER is a typo within MCK itself.

The NES has five channels that are defined in MML as:

This hack covers the programming conventions for each channel; because their operation is identical, A and B are covered together.

Tempo can be set individually for each channel; however, it’s likely that you will usually want all channels to play at the same speed to keep everything in sync. The tempo for all channels can be set simultaneously by typing ABCDE t150.

In MML notation, this says: for channels A, B, C, D, and E, set the tempo to 150 beats per minute. The valid range of values for the tempo is 1 to 255.

The pulse wave channels (A and B) and the noise channel (D) of the NES have volume control, while the triangle wave channel (C) and the DPCM channel (E) can only be turned on or off. For the pulse and noise channels, there are two options for setting volume. The first is to just set a constant volume level: A v15.

This sets the volume level for channel A to 15. However, in most cases, using a volume envelope is a better choice. Here’s a volume envelope example:

@v0 = { 10 9 8 7 6 5 4 3 2 }

The volume envelope takes values between 0 and 15. The highest volume is 15; 0 is silence. The last value is held until another note is played. Note that if neither a constant volume nor a volume envelope is defined for the pulse channels (A and B) or the noise channel (D), you won’t hear any sound output on these channels.

Think of a pulse wave as a square wave with a variable width. In a square wave, the width is fixed at 50% (half up and half down), but pulse waves have more flexibility. This flexibility is referred to as the duty cycle (or sometimes the timbre) of the pulse wave. Here are the four possible duty cycle settings for the pulse wave channels on the NES:

   _
00  | |               | 12.5% thin raspy sound
    | |_ _ _ _ _ _ _ _|
     _ _ _
01  |   |             |  25% thick fat sound
    |   |_ _ _ _ _ _ _|
     _ _ _ _ 
02  |       |         |  50% smooth clear sound
    |       |_ _ _ _ _|
     _ _ _ _ _ _ 
03  |           |     |  75% same as 25% but phase-inverted
    |           |_ _ _|

Now that the pulse channel (A) is set up, here’s an example of a note sequence that can be programmed on it:

A c d e f g4 a16 b16 >c c d e f g4 a16 b16 >c<<

If you know standard music notation, most of this should look familiar. Basically, it’s just note values followed by note lengths. Create sharps or flats by adding either a + or -, respectively, after the note value. The notes in an octave, as seen on a piano keyboard are:

    c+ d+    f+ g+ a+
 |  #  #  |  #  #  #  |  additionally:
 |  #  #  |  #  #  #  |  r = rest
 |  #  #  |  #  #  #  |  w = wait (rest without silencing
 |__|__|__|__|__|__|__|            the previous note)
  c  d  e   f  g  a  b

Because the default note length for channel A is set to eighth notes, this melody plays c d e f notes for an eighth length each, then the g note for a quarter length, followed by the a and b notes for a sixteenth length each. Next is the > symbol, which switches an octave up (to the fifth octave), and then the c eighth note plays. Now the scale repeats again before finally switching back down two octaves (to the original fourth octave set for the channel). Additionally, in reference to note duration, it’s possible to use dotted notes. Dotting a note increases the duration of that note by half its value. These examples should help illustrate this:

Now, getting back to the previous example programmed on the first pulse wave channel (A), notice that this sequence plays only once. The full sequence or small portions of it can be looped using brackets followed by a loop count, as shown here:

A [c d e f g4 a16 b16 >c c d e f g4 a16 b16 >c<<]2

This loops the entire sequence twice, which can be handy for keeping your MML code clean and saving unnecessary typing. To give this sequence a little more of a dynamic feel, set up another volume envelope, and switch between the two. You’ll end up with something like this:

#TITLE My First NES Chip
#COMPOSER Nullsleep
#PROGRAMER 2003 Jeremiah Johnson
@v0 = { 10 9 8 7 6 5 4 3 2 }
@v1 = { 15 15 14 14 13 13 12 12 11 11 10 10 9 9 8 8 7 7 6 6 }
ABCDE t150
A l8 o4 @01 @v0
A [c d e f @v1 g4 @v0 a16 b16 >c c d e f @v1 g4 @v0 a16 b16 >c<<]2

This volume envelope switching puts a slight emphasis on the quarter notes because of the higher initial volume setting of the new volume envelope and its slower decay rate. All of this can be applied identically to the second pulse channel (B) as well.

Here are a couple of simple volume envelopes that can be used for some basic percussion on the noise channel:

@v2 = { 15 12 10 8 6 3 2 1 0 }
@v3 = { 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0 }

After setting up the volume envelopes, initialize the channel:

D l4 o1 @0 @v2

For channel D, this translates to:

Here is a little sequence of simple noise drums:

D @v2 b @v3 e @v2 b @v3 e @v2 b @v3 e @v2 b @v3 e8 @v2 b8

The DMCconv program converts your samples from .wav to .bin for use with MCK. The documentation for DMCconv isn’t in English, but its operation is simple enough. For example:

DMCconv kick.wav kick.dmc

This converts a kick.wav file into a kickdrum sample usable by the NES with all the default settings.

Once all desired samples are converted, create a directory called samples within the workspace folder to store the samples and initialize the channel in the MML, as follows:

@DPCM0 = { "samples\kick.dmc",15 }
@DPCM2 = { "samples\snare.dmc",15 }
E o0 l4

This maps the first sample, kick.dmc, to @DPCM0, which corresponds to the c note on octave 0. Notice that the second sample, snare.dmc, maps to @DPCM2, which corresponds to the d note. @DPCM1 is skipped over to avoid mapping samples to sharps/flats and keep the MML more readable:

E c d c d c d c d8 c8