{"id":2814,"date":"2017-06-09T22:23:20","date_gmt":"2017-06-09T22:23:20","guid":{"rendered":"https:\/\/blog.ecotronics.ch\/wordpress\/?p=2814"},"modified":"2020-06-06T11:22:53","modified_gmt":"2020-06-06T11:22:53","slug":"sonic-pi-advanced-programming","status":"publish","type":"post","link":"https:\/\/blog.ecotronics.ch\/wordpress\/?p=2814","title":{"rendered":"Sonic Pi – Advanced programming"},"content":{"rendered":"\n

Recently I stumbled upon Sonic Pi<\/strong>, a sequencer<\/strong> with which you can generate music programmatically. There exist versions for Windows, Mac, Linux and Raspberry Pi (that’s where the names comes from). For Windows you can get it as stickware, no installation needed. And the best: it’s free!<\/p>\n\n\n\n

If you don’t have it yet, go and get it: http:\/\/sonic-pi.net\/<\/a><\/p>\n\n\n\n

I was fascinated and spent hours exploring the endless possibilities of this software. As a developer my focus was on the possibilities of the programming language.<\/p>\n\n\n\n

\"Sonic<\/a><\/figure><\/div>\n\n\n\n

In this article I sum up some of the programming questions I stumbled upon. As Sonic Pi aims at electronic artist, musicians and music teachers, the documentation is much better on the musical possibilities than on documenting programming features. Just try to find such topics as operators or data types in the official Sonic Pi documentation!<\/p>\n\n\n\n

Some sort of Ruby<\/h1>\n\n\n\n

This is not an introduction into Sonic Pi, the basics you can perfectly learn in the excellent tutorial integrated in the program. No need to repeat this here. As I said before, here I document some advanced undocumented topics. The most important thing you have to know is that the programming language of Sonic Pi is a simplified Ruby<\/strong>. If you don’t find an answer to your programming question in the official Sonic Pi documentation you can just google it with Ruby. Many features of Ruby work, just try it out.<\/p>\n\n\n\n

The wonders of division<\/h1>\n\n\n\n

Very early I stumbled over a phenomenon that can drive a programming newbie to tears. Just look at the following code:<\/p>\n\n\n\n

\n\nmy_number1 = 5\/4\nprint my_number1 # result 1\n\nmy_number2 = 3\/4\nprint my_number2 # result 0\n\n<\/pre><\/pre>\n\n\n\n
Oops! As a Java programmer I’m not really astonished: The types of the two numbers define the type of the result<\/strong>. If you want to have a decimal as a result, at least one number has to be a decimal. If this is not the case, for example because the numbers are the lengths of lists (more of this later), then multiply one of them with 1.0, this will do the trick.<\/p>\n\n\n\n
\n\nmy_number1 = 1.0\/3\nprint my_number1 # result 0.3333333333333333\n\nmy_number2 = 1\/0.25\nprint my_number2 # result 4.0\n\nmy_number3 = 5\/4\nprint my_number3 # result 1\n\nmy_number4 = 3\/4\nprint my_number4 # result 0\n\nmy_number4 = (3*1.0)\/4\nprint my_number4 # result 0.75\n\n<\/pre><\/pre>\n\n\n\n
Note Names and Note Numbers<\/h1>\n\n\n\n
When using play in Sonic Pi you can use it with the note name, for example :c4 or its number value 60.<\/p>\n\n\n\n
Of course, you can convert the names in numbers and vice versa.<\/p>\n\n\n\n
\n# from note name to note value\nprint :c4.to_i&amp;amp;amp;nbsp;&amp;amp;amp;nbsp;&amp;amp;amp;nbsp;&amp;amp;amp;nbsp;&amp;amp;amp;nbsp;&amp;amp;amp;nbsp;&amp;amp;amp;nbsp;&amp;amp;amp;nbsp;&amp;amp;amp;nbsp;&amp;amp;amp;nbsp;&amp;amp;amp;nbsp;&amp;amp;amp;nbsp;&amp;amp;amp;nbsp;&amp;amp;amp;nbsp;&amp;amp;amp;nbsp;&amp;amp;amp;nbsp;&amp;amp;amp;nbsp;&amp;amp;amp;nbsp; # =&amp;amp;amp;gt; 60\n\n# from note value to note name\nprint note_info(60).midi_string&amp;amp;amp;nbsp; # =&amp;amp;amp;gt; C4\n\n# note name without octave\nprint Note.resolve_note_name(60) # =&amp;amp;amp;gt; :C\n\nprint note_info(60).octave&amp;amp;amp;nbsp;&amp;amp;amp;nbsp;&amp;amp;amp;nbsp;&amp;amp;amp;nbsp;&amp;amp;amp;nbsp;&amp;amp;amp;nbsp; # =&amp;amp;amp;gt; 4\nprint note_info(60).pitch_class&amp;amp;amp;nbsp; # =&amp;amp;amp;gt; :C\nprint note_info(60).midi_note&amp;amp;amp;nbsp;&amp;amp;amp;nbsp;&amp;amp;amp;nbsp; # =&amp;amp;amp;gt; 60\nprint note_info(60).inspect&amp;amp;amp;nbsp;&amp;amp;amp;nbsp;&amp;amp;amp;nbsp;&amp;amp;amp;nbsp;&amp;amp;amp;nbsp; # =&amp;amp;amp;gt; "#&amp;amp;amp;lt;SonicPi::Note :C4&amp;amp;amp;gt;"\n\n# convert midi to Hertz value\nprint midi_to_hz(:c4)&amp;amp;amp;nbsp;&amp;amp;amp;nbsp;&amp;amp;amp;nbsp;&amp;amp;amp;nbsp;&amp;amp;amp;nbsp;&amp;amp;amp;nbsp;&amp;amp;amp;nbsp;&amp;amp;amp;nbsp;&amp;amp;amp;nbsp;&amp;amp;amp;nbsp;&amp;amp;amp;nbsp; # =&amp;amp;amp;gt; 261.6255653005986\n\n# calculate interval difference\nprint :c4 - :d4&amp;amp;amp;nbsp;&amp;amp;amp;nbsp;&amp;amp;amp;nbsp;&amp;amp;amp;nbsp;&amp;amp;amp;nbsp;&amp;amp;amp;nbsp;&amp;amp;amp;nbsp;&amp;amp;amp;nbsp;&amp;amp;amp;nbsp;&amp;amp;amp;nbsp;&amp;amp;amp;nbsp;&amp;amp;amp;nbsp;&amp;amp;amp;nbsp;&amp;amp;amp;nbsp;&amp;amp;amp;nbsp;&amp;amp;amp;nbsp;&amp;amp;amp;nbsp; # =&amp;amp;amp;gt; -2\n\n# play midi_string\nplay note_info(61).midi_string\n<\/pre><\/pre>\n\n\n\n
Source: http:\/\/www.rubydoc.info\/github\/samaaron\/sonic-pi\/SonicPi\/Note#resolve_midi_note-class_method<\/p>\n\n\n\n
To make a lowercase symbol<\/strong> from the values of a scale is more complicated:<\/p>\n\n\n
\n#define a minor scale\nmy_scale = scale :c4, :minor, num_octaves: 1\n#fetch the second note and transform it to a symbol\nmy_note = note_info(my_scale[1]).midi_string.downcase.to_sym\nprint my_note # output :d4\n<\/pre><\/div>\n\n\n
String Concatenation<\/h1>\n\n\n\n
What a word! Basically it’s just the question how can sew text snippets together. Why do we need this an a music sequencer? For debugging I recommend to print out messages to the protocol window. The beginning is easy: Just put a +-sign between to texts:<\/p>\n\n\n
\nprint \"Hello\" + \" World\"\n<\/pre><\/div>\n\n\n
Works like a charm! But then you want to know the length of a sample:<\/p>\n\n\n
\nprint \"Duration of ambi_glass_hum: \" + sample_duration :ambi_glass_hum\n<\/pre><\/div>\n\n\n
Don’t be astonished that this gives you an ugly error message.<\/strong> Of course, it’s types again. Although you see nothing like a type declaration, Sonic Pi is a typed language<\/strong>. And as the result of sample_duration is a number, this cannot be concatenated with a string. There are two solutions for this problem:<\/p>\n\n\n\n
  1. Use your number in the string with #{your_number}<\/strong><\/li>
  2. Convert the number to a string with .to_s<\/strong><\/li><\/ol>\n\n\n
    \nmy_string_1 = \"one\"\nmy_string_2 = \"two\"\nmy_result_1 = \"my_result_1: #{my_string_1}, #{my_string_2}\"\nprint my_result_1\n\nmy_result_2 = \"my_result_2: \" + my_string_1 + \", \" + my_string_2\nprint my_result_2\n\nmy_length = sample_duration :ambi_glass_hum\nprint \"sample: #{my_length}\"\n# or\nprint \"sample: \" + my_length.to_s\n<\/pre><\/div>\n\n\n
    Arrays, Maps and Rings<\/h1>\n\n\n\n
    As many other programming languages, Sonic Pi knows arrays<\/strong> (or lists, there seems to be no difference) and maps<\/strong>. I can use these to save sequences of notes or note lengths. But there is a third element, which is very specific to music sequencers: rings<\/strong>. A ring<\/strong> is nothing else than an array that automatically starts again when it has reached the last element<\/strong>. This is very handy because in Sonic Pi you don’t work with counters as in a conventional progamming language (although it is possible). The universal counter that controls all your parallel loops is the tick<\/strong>. And as the loops can run a long time, the ticks will soon be much larger than the length of any array. If you convert an array, you don’t have to care for your index, Sonic Pi handles this.<\/p>\n\n\n\n
    From lists to rings and back<\/h2>\n\n\n\n
    So it’s very useful, if you know how to convert an array to a ring and back with .ring and .to_a. Here is the code:<\/p>\n\n\n
    \nmy_ring = [1, 2, 3].ring\nmy_array = my_ring.to_a\n<\/pre><\/div>\n\n\n
    Reusable procedures with lists<\/h2>\n\n\n\n
    But why use these collections at all? As a software developer, I’m interested in reusability. I don’t want to write dozens of lines of code for every new melody. My vision is to make procedures that can play any sort of melody you give them as an argument. The most simple form is a procedure with to arguments, a list of notes and list of note lengths.<\/p>\n\n\n\n
    Another important property of lists and maps is its lenght. You can get it just with .lenght, for example [1, 2, 3].length<\/strong>.<\/p>\n\n\n
    \n#use this procedure to play any simple melody\ndefine :play_my_melody do |my_note_list, my_sleep_list|\n  tick_reset(:my_melody_tick)\n  my_length = my_note_list.length\n\n  my_length.times do\n    my_counter = tick(:my_melody_tick)\n    play my_note_list.ring[my_counter]\n    sleep my_sleep_list.ring[my_counter]\n  end\nend\n\nmy_melody_twinkle = [:c4, :c4, :g4, :g4, :a4, :a4, :g4]\nmy_sleep_twinkle = [1, 1, 1, 1, 1, 1, 2]\nplay_my_melody my_melody_twinkle, my_sleep_twinkle\nsleep 2\n\nmy_melody_godownmoses = [:d4, :bb4, :bb4, :a4, :a4, :bb4, :bb4, :g4]\nmy_sleep_godownmoses = [1, 1, 1, 1, 1, 1, 1, 2]\nplay_my_melody my_melody_godownmoses, my_sleep_godownmoses\n<\/pre><\/div>\n\n\n
    From a musical standpoint the result is not really convincing, but as a program it works.<\/p>\n\n\n\n