The Dev Bin

Now we have covered the basics of pulse width modulation and playing a tone using our Netduino. We can use abstraction and quickly start playing melodies. In fact we can build code to parse and play Nokia Ring Tone Transfer Language. The good news is the wiring diagram is the same as the last tutorial. All we have to do is write new code, but first we have to discuss what is needed to play melodies, and ring tones.

Download the Code

https://github.com/ianlintner/Netduino-Ring-Tone-Player

Playing a melody requires two elements Pitch (Note) and Duration. Once we have those two elements we can closely mimic most single note melody. Thirdly we will need a tempo to determine how fast we play the melody.

Pitch is the frequency of the current sound being played, usually expressed by a letter and sharp or flat, e.g. C#,D, E, F#

Duration is the length of the note usually expressed as fraction of a whole note e.g. whole (1/1), half note (1/2, quarter (1/4), eight (1/8)

Tempo determines how fast we play it is commonly expressed as beats (quarter-notes) per minute: 60 bpm, 120 bpm, 130 bpm.

From the last tutorial we already know how to play a tone (SetPulse), and how long to play it (Thread.Sleep). We could just string these calls together, or we could abstract this out to play more melodies.

Code Organization

Main Program — See Below for explanation of Classes and Functionality

         public class Program
    {

        static bool IsPlay = true;
        static PWM Speaker = new PWM(Pins.GPIO_PIN_D5);
        static Song CurrentSong;
        static InterruptPort Button = new InterruptPort(Pins.ONBOARD_SW1, false, ResistorModes.Disabled, InterruptModes.InterruptEdgeBoth);
        static Queue SongQueue = new Queue();
        public static void Main()
        {
            //Set interuppt
            Button.OnInterrupt += new NativeEventHandler(ButtonPushed);

            //Looping
            while (true)
            {

                //Reload the Queue -- Not exactly efficient but it's just for fun
                if(SongQueue.Count < 1)
                {
                    SongQueue = Playlist.GetQueue();
                }

                //Check to see what stat our play variable is at based on switch press
                if (IsPlay)
                {
                    CurrentSong = (Song)SongQueue.Dequeue();
                    Play();
                    Thread.Sleep(2000);
                }
                else
                {
                    Thread.Sleep(100);
                }
            }
        }

        //Function to play notes from song class -- our work horse
        public static void Play()
        {

            //loop through each notation object in the arraylist
            foreach (Notation myNotation in CurrentSong.Notations)
            {
                if (IsPlay)
                {
                    //see earlier tutorial on playing on notes on netduino using a piezo
                    if (myNotation.Note != 0)
                    {
                        Speaker.SetPulse(myNotation.Period, myNotation.Period / 2);
                        Thread.Sleep(myNotation.SleepDuration(CurrentSong.Interval()));
                        Speaker.SetDutyCycle(0);
                        Thread.Sleep(10);

                    }
                    else
                    {
                        Speaker.SetDutyCycle(0);
                        Thread.Sleep(myNotation.SleepDuration(CurrentSong.Interval()));
                    }
                }
            }
        }

        //Changes IsPlay state on button press
        public static void ButtonPushed(uint data1, uint data2, DateTime time)
        {
            Microsoft.SPOT.Debug.Print(data2.ToString());

            if (data2 == 0)
            {
                //
            }
            else
            {
                IsPlay = !IsPlay;
            }

        }

    }

To build the code we need we are going to need some basic classes to organize our data.

• Note Class to Store all the Note Names / Frequencies for easy access.
• Notation Class to store a pitch, duration, and do basic calculations to convert properties into machine usable values.
• Song Class to store a List of Notations and other song information.

Combine these elements with a basic SetPulse / Sleep loop (and a little logic) we have everything we need to play melodies.

We are not going to stop here, As I said we would parse and play RTTTL Ringtones. Which requires the addition of one more class:

• RTTTL Class to store and parse RTTTL values.

The RTTTL Class is a pretty heavy class in relation. The parsing of the Ringtones are straightforward, but there are some pitfalls.

Here is a RTTTL string:

StWars:d=4,o=5,b=180:8f,8f,8f,2a#.,2f.6,8d#6,8d6,8c6,2a#.6,...

Our RTTTL class first will have to divide the RTTL into three parts, which are delimited by a colon (:).

• Title: String of Song Title (StWars)
• Song Setup: Duration, Octave, Beat (d=4,o=5,b=180)
• Song Data: The Notes (8f,8f,8f,2a#.,2f.6,8d#6,8d6,8c6,2a#.6)

            //Code to Parse Header and Get Notes to Parsable format
            Divisions = song.Split(':');

            Name = Divisions[0];
            Header = Divisions[1].Split(',');
            Notes = Divisions[2].Split(',');

            Duration = int.Parse(Header[0].Substring(2, Header[0].Length - 2));
            Octave = int.Parse(Header[1].Substring(2, Header[1].Length - 2));
            Beat = int.Parse(Header[2].Substring(2, Header[2].Length - 2));

To view the rest of the RTTTL Parsing Code Go Here.

Here is a good place to start finding RTTTL Ringtones.
Here is a geekier site dedicated to video game ringtones ArcadeTones.

Finally we will add one more utility class:

• Playlist a simple class to hard code songs onto the Netduino.