Mu­ziek ma­ken met So­nic Pi

De eer­ste stap­pen met mu­ziek­soft­wa­re So­nic Pi

C’t Magazine - - Inhoud - Pit Noack

So­nic Pi is gra­tis soft­wa­re waar­mee je spe­len­der­wijs met pro­gram­meer­co­de ge­luids­ef­fec­ten maakt, en be­ats, me­lo­die­ën en com­ple­te songs kunt cre­ë­ren. Dat is leuk om te doen en biedt een ide­a­le in­stap in de we­reld van pro­gram­me­ren.

Er zijn veel mo­ge­lijk­he­den om mu­ziek te ma­ken. Je kunt gi­taar of syn­the­si­zer spe­len of met di­gi­ta­le ge­luids­stu­dio's mu­ziek pro­du­ce­ren. So­nic Pi be­wan­delt een an­de­re weg: het pro­gram­ma maakt ge­lui­den op ba­sis van co­de, waar­mee je com­ple­te num­mers kunt sa­men­stel­len. Dat is mak­ke­lij­ker dan het mis­schien klinkt. So­nic Pi werd door zijn uit­vin­der Sam Aa­ron oor­spron­ke­lijk ont­wik­keld om kin­de­ren te le­ren pro­gram­me­ren. Het is ech­ter ze­ker geen speel­goed: de in­tel­li­gen­te en uit­breid­ba­re struc­tuur maakt het pro­gram­ma ook ge­schikt voor pro­fes­si­o­nals.

In dit ar­ti­kel gaat het om de ba­sis­prin­ci­pes van So­nic Pi. Al­le co­de­voor­beel­den wer­ken zelf­stan­dig en la­ten de mo­ge­lijk­he­den van de soft­wa­re zien. So­nic Pi waar­schuwt je bij typ- en co­de­fou­ten. In een van de vol­gen­de num­mers van c't zal een an­der ar­ti­kel la­ten zien hoe je een beat met So­nic Pi maakt.

In te­gen­stel­ling tot wat de naam doet ver­moe­den, is So­nic Pi er niet al­leen voor de Rasp­ber­ry Pi, maar ook voor Win­dows, Li­nux en macOS. Voor Win­dows is er een in­stal­leer­ba­re ver­sie, maar ook een por­ta­ble va­ri­ant.

Sam­ples en syn­ths

So­nic Pi biedt twee mo­ge­lijk­he­den om klan­ken voort te bren­gen: met sam­ples of met syn­ths. Bij de eer­ste ma­nier speel je voor­ge­pro­du­ceer­de ge­lui­den af. So­nic Pi heeft 129 der­ge­lij­ke ge­lui­den, va­ri­ë­rend van slag­werk- tot pi­a­no­klan­ken – die se­lec­tie is uit te brei­den met ge­lui­den uit an­de­re bron­nen. Typ het vol­gen­de com­man­do in het buf­fer­deel in om een sam­ple te star­ten:

sam­ple :bd_haus

Druk op de Run-knop en het pro­gram­ma be­gint een tech­no-bass­drum af te spe­len. Ook al klinkt er nu maar één ge­luid, dit is toch al een eer­ste vol­waar­dig So­nic Pi-pro­gram­ma. De lijst met al­le in­ge­bouw­de sam­ples in So­nic Pi krijg je te zien door sam­ple en

een spa­tie in te ty­pen of via de Help-knop bij Sam­ples te kij­ken. De voor­ge­ïn­stal­leer­de au­diosam­ples zijn in elf groe­pen ver­deeld. De af­kor­tin­gen voor de eer­ste un­der­sco­re ge­ven de groep aan: am­bi staat voor am­bien­te ge­lui­den, bd voor bass­drum, drum voor an­de­re slag­in­stru­men­ten, elec voor elek­tro­ni­sche ge­lui­den en loop voor rit­mi­sche frag­men­ten. Speel ver­schil­len­de sam­ples af om te ont­dek­ken wel­ke ge­lui­den er al­le­maal zijn. In­te­res­san­te voor­beel­den zijn on­der meer :guit_e_­fifths, :bas­s_­voxy­_c, :loop­_a­men en am­bi_lu­nar_­land. Met de func­tie sam­ple kun je zelf op­ge­no­men ge­lui­den toe­voe­gen – meer daar­over in de in­ge­bouw­de Tu­to­ri­al bij punt 3.6 (Ex­ter­ne sam­ples).

So­nic Pi-pro­gram­ma's be­staan voor­na­me­lijk uit func­tie-aan­roe­pen. De func­tie sam­ple is er daar een van. Als ex­tra in­for­ma­tie moet je daar de naam van het ge­luid aan mee­ge­ven dat je af­ge­speeld wilt heb­ben. Der­ge­lij­ke ex­tra in­for­ma­tie heet een ar­gu­ment.

De twee­de ma­nier van ge­luids­pro­duc­tie is met syn­the­si­zer­klan­ken. Syn­ths be­re­ke­nen de ge­lui­den re­al­ti­me in plaats van een op­ge­sla­gen ge­luid af te spe­len. Met play speel je een syn­the­si­zer­klank af:

play 64

Het ge­tal 64 staat daar­bij voor de toon­hoog­te. Stel je een pi­a­no­kla­vier met 128 toet­sen voor: de toets he­le­maal links met de laag­ste noot heeft num­mer 0, de toets he­le­maal rechts met de hoog­ste noot num­mer 127. Als al­ter­na­tief voor die ge­tal­len kun je de toon­hoog­te ook met de noot­naam aan­ge­ven:

play :e4

In dit ge­val staat de e voor de be­tref­fen­de noot en de 4 voor de vier­de oc­taaf. So­nic Pi biedt veel syn­the­si­zer­klan­ken, die se­lec­teer je met use_­synth. Die keu­ze is net zo lang ac­tief tot je een nieu­we se­lec­teert.

use_­synth :pi­a­no play 30

Pro­beer ver­schil­len­de toon­hoog­ten (ge­tal­len tus­sen 0-127) en syn­the­si­zer­klan­ken uit, bij­voor­beeld :chip­lead – die klinkt als een 8-bit com­pu­ter uit de ja­ren 80 – en :tb303, een si­mu­la­tie van de le­gen­da­ri­sche Ro­land TB-303.

Me­lo­die com­po­ne­ren

Het ge­ne­re­ren van klan­ken is na­tuur­lijk nog maar het be­gin, daar heb je niet met­een een heel num­mer mee. Hoe zet je nu een aan­tal klan­ken ach­ter el­kaar, of­te­wel hoe maak je een me­lo­die of rit­me? Het sim­pel ach­ter el­kaar zet­ten van sam­ple- en play-com­man­do's is niet vol­doen­de om­dat die klan­ken dan te­ge­lij­ker­tijd af­ge­speeld wor­den. Het com­man­do sleep laat de com­pu­ter wach­ten met het uit­voe­ren van de vol­gen­de com­man­do­re­gel. Daar­mee kun je So­nic Pi de klan­ken na el­kaar la­ten af­spe­len:

sam­ple :bd_haus sleep 1 sam­ple :drum_sna­re_hard

Het ge­tal ach­ter sleep staat voor de duur van de pau­ze tus­sen de sla­gen. In dit ge­val staat 1 voor een se­con­de. Dat komt door­dat het stan­daard in­ge­stel­de tem­po bij So­nic Pi 60 bpm (be­ats per mi­nu­te) is. Als je het tem­po ver­dub­belt met het com­man­do use_bpm 120 naar 120 sla­gen per mi­nuut, dan duurt een slag een hal­ve se­con­de en dan be­te­kent sleep 1 een pau­ze van een hal­ve se­con­de. Voor het­zelf­de re­sul­taat krijg je dan:

use_bpm 120 sam­ple :bd_haus sleep 2 sam­ple :drum_sna­re_hard

Met sam­ple, play en sleep kun je al he­le mu­ziek­stuk­ken schrij­ven. Pro­beer als oe­fe­ning maar eens een po­pu­lai­re me­lo­die na te ma­ken.

Ge­lui­den ver­an­de­ren

So­nic Pi biedt veel op­ties om ge­lui­den aan te pas­sen. Be­lang­rij­ke op­ties voor zo­wel syn­ths als sam­ples zijn bij­voor­beeld amp en pan. De af­kor­ting amp staat voor am­pli­fi­ca­ti­on of­te­wel ver­ster­king. De mi­ni­ma­le waar­de is 0 (stil­te dus), maar aan de bo­ven­kant is er geen grens. Een te ho­ge ver­ster­king leidt ech­ter tot ver­vor­ming. De stan­daard in­ge­stel­de waar­de is 1.

sam­ple :am­bi_pi­a­no, amp: 0.5 sleep 2 sam­ple :am­bi_pi­a­no, amp: 1.5

De af­kor­ting pan staat voor pa­no­ra­ma. Die op­tie ver­schuift de klank in het ste­re­o­beeld van pan -1 he­le­maal links via pan 0 in het mid­den tot pan 1 he­le­maal rechts. In het vol­gen­de voor­beeld loopt een trom­mel­slag van links naar rechts: sam­ple :drum_tom_lo_hard, pan: -1 sleep 2 sam­ple :drum_tom_lo_hard, pan: -0.5 sleep 2 sam­ple :drum_tom_lo_hard, pan: 0.5 sleep 2 sam­ple :drum_tom_lo_hard, pan: 1

Veran­der je de af­speel­snel­heid bij de sam­ples, dan leidt dat vaak tot ver­ras­sen­de ge­luids­ef­fec­ten. Dat doe je met de op­tie ra­te. Het vol­gen­de voor­beeld speelt een sam­ple eerst op de nor­ma­le snel­heid af, daar­na met de hal­ve snel­heid:

sam­ple :guit_em9 sleep 4 sam­ple :guit_em9, ra­te: 0.5

Dat fe­no­meen ken je mis­schien van je pla­ten­spe­ler: het ver­an­de­ren van de af­speel­snel­heid ver­an­dert ook de toon­hoog­te. Een ver­dub­be­ling van de af­speel­snel­heid (ra­te: 2) ver­schuift de toon­hoog­te naar een oc­taaf ho­ger. Dat leidt tot een Mic­ky Mou­se-ef­fect. Het hal­ve­ren (ra­te: 0.5) be­werk­stel­ligt het te­gen­over­ge­stel­de en maakt de klank een oc­taaf la­ger. Een min voor het ge­tal draait de af­speel­rich­ting om,

de sam­ple wordt dan ach­ter­uit af­ge­speeld. Zo wordt een sam­ple met hal­ve snel­heid ach­ter­waarts af­ge­speeld:

sam­ple :guit_em9, ra­te: -0.5

Ex­pe­ri­men­teer wat met ver­schil­len­de sam­ples en snel­he­den. Der­ge­lij­ke ma­ni­pu­la­ties klin­ken met na­me in­te­res­sant bij lan­ge­re sam­ples die met guit, am­bi of loop be­gin­nen.

Op­ties die het vo­lu­me­ver­loop be­ïn­vloe­den ge­ven nog meer speel­ruim­te. De be­lang­rijk­ste ter­men daar­bij zijn at­tack en re­lea­se. De eer­ste be­paalt de duur die een klank no­dig heeft om het vol­le­di­ge vo­lu­me te be­rei­ken, de twee­de is de weg­sterf­tijd van het ge­luid. Die waar­den zijn es­sen­ti­eel voor de ka­rak­te­ris­tiek van een klank. Een xy­lo­foon die met een vil­ten stok be­speeld wordt klinkt 'zacht' en heeft dan ook een lan­ge­re at­tack. Met een hou­ten stok klinkt een xy­lo­foon har­der en meer per­cus­sief, dus met een kor­te­re at­tack. Bij een pi­a­no zorgt het rech­ter pe­daal er­voor dat de dem­pers van de sna­ren gaan, wat er­toe leidt dat de sna­ren lan­ger blij­ven door­klin­ken en dus tot een lan­ge­re re­lea­se.

Een voor­beeld voor een kor­te, per­cus­sie­ve klank in So­nic Pi:

play 64, re­lea­se: 0.1

Een klank die lang­zaam aan­zwelt en lang­zaam uit­dooft:

play 64, at­tack: 4, re­lea­se: 4

Het vol­le­di­ge sca­la aan klank­mo­ge­lijk­he­den van syn­ths is met de op­ties op­ti­maal te be­nut­ten. De synth bla­de (ge­noemd naar de film­klas­sie­ker Bla­de Run­ner) is bij­voor­beeld goed ge­schikt om elek­tro­ni­sche snaar­klan­ken met lan­ge aan­zwel- en uit­doof­fa­ses te ge­ne­re­ren:

use_­synth :bla­de play 50, at­tack: 2, re­lea­se: 4

Met at­tack en re­lea­se is al veel te doen. Er zijn nog an­de­re op­ties die het vo­lu­me­ver­loop kun­nen ver­an­de­ren, waar­on­der sustain en de­cay. Meer daar­over staat in de in­ge­bouw­de Tu­to­ri­al bij punt 2.4 (Ge­luids­duur met "En­ve­lo­pes").

Veel op­ties zijn zo­wel op syn­the­si­zer­klan­ken als sam­ples toe te pas­sen, zo­als amp en pan. De op­tie ra­te is al­leen bij sam­ples zin­vol. Bo­ven­dien zijn er op­ties die al­leen op be­paal­de syn­ths toe te pas­sen zijn. De op­tie cu­to­ff werkt bij­voor­beeld al­leen bij de syn­ths die een laag­door­laat­fil­ter heb­ben. Dat zijn on­der an­de­re tb303 en bla­de. Daar­bij be­paalt cu­to­ff de fre­quen­tie van het fil­ter. Een ho­ge­re waar­de zorgt een scher­pe­re klank, een la­ge­re waar­de klinkt diep en don­ker. Je kunt waar­den tus­sen 0 en 130 ge­brui­ken:

use_­synth :tb303 play 30, cu­to­ff: 50 sleep 1 play 30, cu­to­ff: 80 sleep 1 play 30, cu­to­ff: 110

Play it again, Sam

Pro­gram­meurs hou­den van mak­ke­lijk. Als een stuk co­de acht­maal uit­ge­voerd moet wor­den, dan is het te veel ge­doe om dat acht keer in te ty­pen. So­nic Pi biedt een mo­ge­lijk­heid stuk­ken co­de te her­ha­len:

8.ti­mes do sam­ple :bd_haus sleep 0.25 sam­ple :drum_sna­re_hard sleep 0.25 end

Co­de die tus­sen en do en een end staat, noem je een blok. Met 8.ti­mes zorg je er­voor dat dit acht keer uit­ge­voerd wordt.

Het her­ha­len met be­hulp van blok­ken maakt de co­de over­zich­te­lij­ker, en wij­zi­gin­gen aan de co­de hoe­ven dan maar één keer ge­daan te wor­den.

Toe­vals­mu­ziek

Com­pu­ters wer­ken in het ide­a­le ge­val puur lo­gisch en ken­nen geen toe­val. Dat kun je ech­ter si­mu­le­ren. Daar kun je bij het com­po­ne­ren je voor­deel mee doen.

De func­tie rand_i maakt toe­vals­ge­tal­len. Daar­bij staat rand voor random, of­te­wel wil­le­keu­rig. De i staat voor in­te­ger, dus

rand_i 30..90 le­vert een ge­heel ge­tal op tus­sen de 30 en 90.

Het vol­gen­de voor­beeld speelt acht to­nen af met een wil­le­keu­ri­ge toon­hoog­te tus­sen de 30 en 90. De func­tie play ver­wacht een ge­tal als ar­gu­ment. Al­tijd als er in de co­de een ge­tal ver­wacht wordt, kun je ook een uit­druk­king ge­brui­ken die een ge­tal op­le­vert. In dit ge­val le­vert de func­tie rand_i een der­ge­lijk ge­tal op.

use_­synth :pi­a­no 8.ti­mes do play rand_i 30..90 sleep 0.25 end

Als je die co­de nog een keer laat lo­pen, krijg je ech­ter steeds de­zelf­de to­nen te ho­ren. Daar is een goe­de re­den voor: als je je co­de naar an­de­re So­nic Pi-ge­brui­kers stuurt, moet je er ze­ker van zijn dat het re­sul­taat over­al het­zelf­de zal zijn, on­danks de wil­le­keu­ri­ge waar­den.

Met de func­tie use_random_s­eed kun je de toe­vals­ge­ne­ra­tor met een an­de­re start­waar­de la­ten be­gin­nen. Dan wor­den ie­de­re keer als je het pro­gram­ma start an­de­re toe­vals­ge­tal­len ge­ge­ne­reerd:

use_random_s­eed 672 use_­synth :pi­a­no 8.ti­mes do play rand_i 30..90 sleep 0.25 end

Kies twee wil­le­keu­ri­ge ge­tal­len en zet die af­wis­se­lend ach­ter use_random_s­eed. Dan zul je ho­ren dat de­zelf­de waar­de voor de seed tot de­zelf­de to­nen (ge­tal­volg­or­des) zal lei­den. Als je flo­a­ting­point-ge­tal­len in plaats van ge­he­le ge­tal­len no­dig hebt, ge­bruik je de func­tie rand. In het vol­gen­de voor­beeld wordt sleep met een toe­vals­ge­tal tus­sen 0.1 en 0.5 ge­voed:

use_­synth :pi­a­no 8.ti­mes do play rand_i 30..90 sleep rand 0.1..0.5 end

Twee an­de­re toe­vals­func­ties zijn te ge­brui­ken: choo­se se­lec­teert een wil­le­keu­rig ge­tal uit meer­de­re op­ge­ge­ven waar­den. In het vol­gen­de voor­beeld wordt bij el­ke door­loop een van drie op­ge­ge­ven sam­ples af­ge­speeld met een pau­ze van een kwart, hal­ve of he­le tel: 64.ti­mes do sam­ple [:bd_haus, :sn_­dub,

:elec_­blup].choo­se sleep [0.125, 0.25, 0.5].choo­se end

De func­tie on­e_in (een van) ge­bruik je als een ac­tie met een be­paal­de waar­schijn­lijk­heid moet ver­lo­pen. Die ge­bruik je in com­bi­na­tie met if. In het vol­gen­de voor­beeld wordt een sam­ple ge­mid­deld eens in de vijf keer af­ge­speeld:

128.ti­mes do if on­e_in 5

sam­ple :drum_­cym­bal_­clo­sed end sleep 0.1 end

Ge­luids­ef­fec­ten

De func­tie use_fx biedt een an­de­re mo­ge­lijk­heid klan­ken te be­wer­ken. Vaak ge­bruik­te ef­fec­ten zijn bij­voor­beeld :echo, :re­verb, en :dis­tor­ti­on. Ter ver­ge­lij­king: zo klinkt een slag op een sna­re­drum zon­der ef­fec­ten:

sam­ple :drum_sna­re_­soft

Dit is een sna­re­drum met echo:

wit­h_fx :echo do

sam­ple :drum_sna­re_­soft end

Ook de ef­fec­ten zijn met op­ties te be­wer­ken. Bij echo kun je met :pha­se de duur van de ver­tra­ging in tel­len ver­an­de­ren:

wit­h_fx :echo, pha­se: 0.5 do

sam­ple :drum_sna­re_­soft end sleep 2 wit­h_fx :echo, pha­se: 0.05 do

sam­ple :drum_sna­re_­soft end

Je kunt ef­fec­ten ook in el­kaar nes­ten. Het vol­gen­de voor­beeld voor­ziet een sna­re­slag eerst met de re­verb van een gro­te ka­mer en be­werkt het ge­luid dan nog met een flan­ger. Dat is een po­pu­lair psy­che­de­lisch ge­luids­ef­fect:

wit­h_fx :flan­ger do wit­h_fx :re­verb, room: 0.99 do

sam­ple :drum_sna­re_­soft end end Het Help-ven­ster van So­nic Pi toont bij 'Fx' al­le be­schik­ba­re ef­fec­ten en hun op­ties. Die be­schrij­vin­gen zijn nog wel in het En­gels.

Li­ve loops

Met So­nic Pi kun je thuis niet al­leen be­ats en me­lo­die­ën in el­kaar knut­se­len, maar met wat oe­fe­ning kun je met de soft­wa­re ook li­ve op het po­di­um spe­len. Sam Aa­ron, de ont­wik­ke­laar van So­nic Pi, krijgt met die ma­nier van li­ve-co­ding op fes­ti­vals men­sen aan het dan­sen.

Het cen­tra­le item van de li­ve-co­ding is de func­tie li­ve_loop, die ook met blok­ken werkt. In dit voor­beeld wordt een li­ve-loop met de naam mijn_­beat aan­ge­maakt. Je moet een naam voor een li­ve-loop op­ge­ven. De co­de in het blok wordt tot het be­ëin­di­gen van het pro­gram­ma her­haald:

li­ve_loop :mijn_­beat do sam­ple :bd_haus sleep 0.5 sam­ple :drum_sna­re_hard sleep 0.5 end

Het spe­ci­a­le aan een een li­ve-loop is dat het mo­ge­lijk is om de co­de te ver­an­de­ren ter­wijl hij loopt. Die ei­gen­schap is een ba­sis­eis om met So­nic Pi li­ve mu­ziek te kun­nen ma­ken om­dat je de mu­ziek niet kunt on­der­bre­ken om de co­de te ver­an­de­ren.

Pro­beer het eens uit: start het li­ve­loop voor­beeld. Veran­der de co­de en druk op­nieuw op de Run-knop. Scha­kel de af­zon­der­lij­ke re­gels co­de uit of in door er een # voor te zet­ten of die te ver­wij­de­ren. Ex­pe­ri­men­teer eens met meer­de­re pa­ral­lel lo­pen­de li­ve-loops. Let er daar­bij op dat de ver­schil­len­de li­ve-loops ook ver­schil­len­de na­men moe­ten heb­ben.

Ring, tick en loop

So­nic Pi kan se­ries van waar­den ont­hou­den. Dat is heel han­dig, want me­lo­die­ën zijn niets an­ders dan se­ries van toon­hoog­tes, toon­d­uren en pau­ze­tij­den. Die wor­den in zo­ge­he­ten rings op­ge­sla­gen. De naam ring komt door­dat een se­rie weer voor­aan op­nieuw be­gint als hij aan het ein­de is ge­ko­men.

Het vol­gen­de voor­beeld maakt eerst een ring aan met de waar­den 60, 55 en 65 en slaat die dan op on­der de naam to­nen. Met to­nen[0] krijg je de eer­ste waar­de van de ring, of­te­wel 60. Op die ma­nier leidt no­ten[1] tot 55 en no­ten[2] tot 65.

Dan komt no­ten[3] weer uit bij de eer­ste waar­de van 60.

to­nen = ring 60, 55, 65 play to­nen[0] # 60 sleep 1 play to­nen[1] # 55 sleep 1 play to­nen[2] # 65 sleep 1 play to­nen[3] # 60 sleep 1 play to­nen[4] # 55 sleep 1 play to­nen[5] # 65

# en zo ver­der...

De meer­waar­de van de rings zie je pas als je een an­der hulp­mid­del ge­bruikt. De func­tie tick werkt als een tel­ler. Als het pro­gram­ma start, le­vert het aan­roe­pen van tick een 0 op. El­ke keer als je het weer aan­roept, wordt de waar­de dan met 1 ver­hoogd.

In het vol­gen­de voor­beeld wordt tick ge­bruikt om bij een li­ve-loop de waar­den in de ring op te vra­gen en aan play mee te ge­ven:

to­nen = ring 40, 45, 50, 55, 60 use_­synth :pi­a­no li­ve_loop :ring_en_­tick do play to­nen[tick] sleep 1 end

Je kunt ook meer­de­re rings te­ge­lij­ker­tijd ge­brui­ken. Het vol­gen­de voor­beeld ge­bruikt een twee­de ring voor de pau­zes tus­sen de to­nen. Om­dat door to­nen[tick] de waar­de van tick al ver­hoogd werd, wordt voor de pau­zes pau­zes[look] ge­bruikt om­dat look de waar­de van de tick-va­ri­a­be­le te­rug le­vert zon­der die te ver­ho­gen:

to­nen = ring 40, 45, 50, 55, 60 pau­zes = ring 0.25, 0.25, 0.5 use_­synth :pi­a­no li­ve_loop :ring_en_­tick do play to­nen[tick] sleep pau­zes[look] end

Ex­pe­ri­men­teer wat met het laat­ste voor­beeld door de waar­den in de bei­de rings te ver­an­de­ren of waar­den toe te voe­gen. Je kunt de li­ve-loop uit­brei­den door bij­voor­beeld een an­der in­stru­ment of een ef­fect toe te voe­gen waar­van de ei­gen­schap­pen dan door an­de­re rings aan­ge­stuurd kun­nen wor­den. Je krijgt span­nen­de re­sul­ta­ten als je met veel rings van ver­schil­len­de leng­tes ex­pe­ri­men­teert.

Ei­gen func­ties schrij­ven

Tot nu toe heb je func­ties ge­bruikt die So­nic Pi zelf heeft. Je kunt met de­fi­ne ech­ter ook zelf ei­gen func­ties ma­ken. Een func­tie moet een naam heb­ben, waar­voor in het vol­gen­de voor­beeld elec­tro_specht ge­bruikt wordt. Dan volgt een blok met de co­de die uit­ge­voerd moet wor­den als de func­tie aan­ge­roe­pen wordt:

de­fi­ne :elec­tro_specht do 8.ti­mes do sam­ple :elec_­mid_sna­re sleep 0.05 end end

Als de func­tie een­maal ge­de­fi­ni­eerd is, kun je die net zo ge­brui­ken als al­le an­de­re func­ties door de naam in te ty­pen. Veel in­ge­bouw­de func­ties die je tot nu toe ge­bruikt hebt, wer­ken met ar­gu­men­ten – bij­voor­beeld bij sleep de duur van de on­der­bre­king in tel­len en bij sam­ple de naam van een ge­luid. Ook zelf ge­schre­ven func­ties kun­nen ar­gu­men­ten heb­ben. Als je het aan­tal sla­gen van de elek­tri­sche specht met een ar­gu­ment wilt be­pa­len, dan moet je een zin­vol­le va­ri­a­be­le­naam be­den­ken (hier: aan­tal_­sla­gen) en die tus­sen twee ver­ti­ca­le stre­pen (pi­pe-te­ken) aan het be­gin van het blok zet­ten. Om de va­ri­a­be­le­naam te werk­zaam te la­ten zijn, moet je hem nog ge­brui­ken op de juis­te plek in het blok: de­fi­ne :elec­tro_specht do |aan­tal_ sla­gen| aan­tal_­sla­gen.ti­mes do sam­ple :elec_­mid_sna­re sleep 0.05 end end

Je ge­bruikt de func­tie dan op de vol­gen­de ma­nier:

elec­tro_specht 16 sleep 1 elec­tro_specht 8

Als je meer­de­re ar­gu­men­ten wilt ge­brui­ken, schrijf je die er ge­schei­den door een kom­ma ach­ter:

de­fi­ne :elec­tro_specht do |aan­tal_ sla­gen, pau­ze_­duur| aan­tal_­sla­gen.ti­mes do sam­ple :elec_­mid_sna­re sleep pau­ze_­duur end end elec­tro_specht 10, 0.1 sleep 1 elec­tro_specht 32, 0.01

Als je de smaak van het com­po­ne­ren van mu­ziek een­maal te pak­ken hebt, is het zaak veel te ex­pe­ri­men­te­ren en te ont­dek­ken. Een die­pe­re duik in de mo­ge­lijk­he­den van So­nic Pi komt in het twee­de deel van de­ze mi­ni-se­rie in een van de vol­gen­de num­mers van c't. (nkr)

De uit­vin­der van So­nic Pi Sam Aa­ron speelt met de pro­gram­meer­taal ook li­ve, hier op de Ja­va-con­fe­ren­tie GeekOUT2016 in Tal­linn.

Newspapers in Dutch

Newspapers from Netherlands

© PressReader. All rights reserved.