• Semitone Range: la frequenza è espressa indicando il semitono corrispondente all’intonazione nominale richiesta; ciascun semitono è a sua volta diviso in cento centesimi, per consentire aggiustamenti minimali. In un sistema standard, l’estensione possibile è compresa tra C-1 e G9. L’indicazione di frequenza espressa in semitoni ha valore principalmente in un contesto applicativo musicale, dove cioè la definizione offerta dal sistema di notazione occidentale sia considerato più che sufficiente per le esigenze dell’utente.

• Frequency Range: la frequenza è espressa in valori assoluti, cioè in Hertz. In questo modo, è possibile specificare con esattezza l’intervallo o l’intonazione desiderata per ottenere un determinato risultato. L’estensione possibile, in un sistema di medie prestazioni, è compresa tra 8,1758 e 12.55 Hz; chiaramente, questi valori si riferiscono alle fondamentali e non alle armoniche superiori, che possono raggiungere frequenze ben più elevate. Il vantaggio di un sistema espresso in valori assoluti (precisione ed inequivocabilità delle intonazioni espresse) cozza comunque con la velocità di assimilazione all’interno di un determinato contesto musicale.

• Factor Range: la frequenza è espressa mediante il rapporto esistente tra la deviazione desiderata e l’intonazione nominale. Quando questa viene rispettata, l’oscillatore lavora a fattore x1.0000; l’estensione possibile varia da x0,0248 e x38,955. La modalità Factor Range è estremamente utile quando si programmano timbriche che sfruttano la Modulazione di Frequenza Lineare (Linear FM) in cui i rapporti di frequenza esistenti tra Carrier e Modulator assumono valore fondamentale per prevedere – entro certi limiti – il tipo di contenuto armonico risultante.

• Partial Range: la frequenza è espressa per assimilazione al rapporto tra oscillatore e frequenza nominale del medesimo. Un oscillatore che non sia stato fatto deviare dall’intonazione nominale avrà partial range pari a 1:1. L’estensione possibile è espressa con i valori 0 – 5,15Hz e poi 1:32 – 64:1. Il passaggio da un sistema di visualizzazione all’altro è obbligato quando – nelle tessiture più basse – i rapporti diventano troppo larghi per poter essere riportati nello spazio grafico concesso; a quel punto, risulta più conveniente esprimere il valore in Hertz. Da notare che, a 0 Hz, l’oscillatore smette di vibrare ed emette un valore DC continuo legato alla forma d’onda selezionata ed alla fase della medesima.

























#include <IRremote.h>

#define POWER         0xE0E040BF
#define UNO           0xE0E0906F
#define TVKEY         0xE0E0D827
#define ZERO          0xE0E08877
#define CHPIU         0xE0E048B7
#define CHMENO        0xE0E008F7
#define SAMSUNG_BITS  32

IRsend irsend;

void setup()
{
  pinMode (3, OUTPUT);  //output as used in library
}

void loop() {

irsend.sendSAMSUNG(REPEAT, 32); // Some receivers seem to respond a lot faster when a repeat is sent before the actual command.
delay(35); //This delay is needed for optimal response.
irsend.sendSAMSUNG(ZERO, 32); // hex value, 32 bits
delayMicroseconds(50);

}

http://lirc.sourceforge.net/remotes/samsung/BN59-00940A 




(
SynthDef("bat", {
        var sig, resfreq;    
        sig = Pan2.ar(SinOsc.ar(540,0),-1) + Pan2.ar(SinOsc.ar(547,0),1);
        Out.ar(0, sig);
}).play;
)

I toni binaurali sono dei battimenti che vengono generati direttamente dal cervello quando le due onde sonore vengono ascoltate separatamente tramite degli auricolari (quindi non vi è sovrapposizione fisica delle due onde sonore). I toni binaurali, (o battiti binaurali dall'inglese binaural beats), sono dei battimenti che vengono percepiti dal cervello quando due suoni con frequenza inferiore ai 1500 Hz e con differenza inferiore ai 30 Hz vengono ascoltati separatamente attraverso degli auricolari. È importante precisare che tali battimenti non sono conseguenza, come normalmente accade, di una sovrapposizione fisica delle onde sonore (cosa impossibile utilizzando degli auricolari), ma vengono generati direttamente nel cervello. Il fenomeno è stato identificato nel 1839 da Heinrich Wilhelm Dove.

Gli stadi principali dell'attività elettrica corticale del nostro cervello possono essere riassunti così:

- Beta (13 - 30 Hz)
Le onde beta, sono proprie delle normali attività di veglia o fase REM del sonno, indicano che la corteccia cerebrale è attivata;

- Alpha (8 – 13 Hz)
Le onde alpha o alfa sono associate a uno stato di veglia ma rilassata. La mente è calma e ricettiva. E’ lo stato ideale per lo studio o la meditazione;

- Theta (4 - 8 Hz)
Le onde theta sono tipiche di uno stato meditativo profondo e/o in alcuni stati di sonno. In questo intervallo di frequenze l’individuo è concentrato sugli stimoli interni e l’interazione tra i due emisferi cerebrali è elevata. Questa fase è tipica del dormi/veglia;

- Delta (0,5 - 4 Hz)
Il ritmo delta è molto lento ed è caratteristico del sonno profondo e del coma.

Le onde Gamma sono rare e relative a frequenze superiori ai 30 Hz nel range 30-90 Hz e sono tipiche degli stati di meditazione e di grande energia, sono correlate con la volontà e i profondi poteri psichici.

E' difficile stabilire in che condizione si trovi il cervello; ma, si puo' supporre che, durante il giorno, si emettano, solitamente, delle onde Beta (20Hz); quindi, potrete iniziare da quella frequenza, per poi aumentarla, verso l'alto, o diminuirla, verso il basso. Se, invece, la situazione neuro-cerebrale e' piu' rilassata, iniziate pure da 15Hz, o, meno; e viceversa.

Già nelle missioni spaziali vengono usate queste tecniche; ad esempio, quando gli astronauti devono - per emergenze, o per esigenze tecniche - lavorare, molte ore, senza pausa; oppure, restare svegli per supervisionare gli strumenti. Allora, essi si sottopongono ad un trattamento, a base di lampi ad intermittenza e suoni, che sposta il loro orologio biologico e riattiva la loro concentrazione, permettendo loro di vincere il sonno e la stanchezza.

Oltre ad avere una particolare influenza sul rilassamento, dove si e' dimostrata di particolare efficacia, essa sembra sviluppare anche capacita' immaginative e creativita'. Può essere utile per aiutare la meditazione e l’ipnosi, per alleviare emicranie e mal di testa, per la riduzione del fabbisogno di sonno e l'induzione al sonno naturale, per l'eliminazione della depressione e dell’ansia. E’ di aiuto nei disordini nella capacità di attenzione e della concentrazione, e per molto altro.

Questi battimenti furono scoperti nel 1839 dal tedesco Heinrich Wilhelm Dove, egli di accorse che applicando alle nostre orecchie due frequenze differenti, è possibile percepire i battimenti pari alla sottrazione delle due frequenze. Spiegando praticamente quanto sopra affermato, supponendo di applicare (con delle cuffie) all’orecchio destro un segnale audio pari a 400 cicli al secondo (Hz) e all’orecchio sinistro un segnale pari a 412 cicli al secondo (Hz), saremo in grado di percepire un battimento di queste frequenze pari a 12 cicli al secondo (Hz).
Il fenomeno dei battimenti dimostra che il suono che noi percepiamo è un elaborazione interna al nostro cervello di quanto percepito dalle due orecchie in modo distinto.

Il nostro apparato uditivo è comunque limitato nella percezione delle frequenze acustiche, infatti il range di frequenze percepibili dall'essere umano è compreso tra 20 cicli al secondo (Hz) e 20.000 cicli al secondo (Hz). Al di sopra (ultrasuoni) e al di sotto (infrasuoni), non siamo in grado di percepire nulla. Così nel 1973 il Dr. Gerald Oster del Mount Sinai school of Medicine New York , decise di fare alcuni esperimenti sul possibile fenomeno di risonanza che poteva venirsi a creare tra i Battimenti Binaurali e l'attività elettrica corticale. Egli considerò che le frequenze del nostro elettroencefalogramma (EEG) sono inferiori ai 20 cicli al secondo (Hz), così da non poter essere influenzate per risonanza dai normali segnali audio. Questo perché l’orecchio umano non è in grado di percepire frequenze così basse (inferiori ai 20 Hz). Con i battimenti binaurali, è invece possibile percepire le variazioni anche a frequenze molto basse, ed il Dr. Oster rilevò che il nostro elettroencefalogramma è influenzato dai battimenti binaurali, arrivando ad avere una attività elettrica con frequenza simile a quella del battimento.
una condizione di errore che si verifica a runtime quando in un buffer di una data dimensione vengono scritti dati di dimensioni maggiori; viene sovrascritta parte della zona di memoria immediatamente adiacente al buffer in questione, con diversi effetti possibili a seconda di dove è situato il buffer e di come è organizzata la memoria.

{Limiter.ar(GVerb.ar(Blip.ar(20,Line.kr(1,100,20),1),1),1)!2}.play;


Blip band limited impulse oscillator

Blip.ar(freq, numharm, mul, add)

Band Limited ImPulse generator. All harmonics have equal amplitude. This is the equivalent of 'buzz' in MusicN languages.

Line line generator

Inherits from: Object : AbstractFunction : UGen

Line.ar(start, end, dur, mul, add, doneAction)
Line.kr(start, end, dur, mul, add, doneAction)

Generates a line from the start value to the end value.
start - starting value
end - ending value
dur - duration in seconds
doneAction - a doneAction to be evaluated when the Line is completed. See UGen-doneActions for more detail.

Limiter peak limiter

Limiter.ar(in, level, dur)

Limits the input amplitude to the given level. Limiter will not overshoot
like Compander will, but it needs to look ahead in the audio. Thus there is a
delay equal to twice the lookAheadTime.
Limiter, unlike Compander, is completely transparent for an in range signal.

in - the signal to be processed.
level - the peak output amplitude level to which to normalize the input.
dur - aka lookAheadTime. The buffer delay time. Shorter times will produce smaller delays
and quicker transient response times, but may introduce amplitude modulation artifacts.

GVerb A two-channel reverb

#left, right = GVerb.ar(in, roomsize, revtime, damping, inputbw, spread, drylevel, earlyreflevel, taillevel,
maxroomsize, mul, add)

A two-channel reverb UGen, based on the "GVerb" LADSPA effect by Juhana Sadeharju (kouhia at nic.funet.fi).

in - mono input
roomsize - in squared meters
revtime - in seconds
damping - 0 to 1, high frequency rolloff, 0 damps the reverb signal completely, 1 not at all
inputbw - 0 to 1, same as damping control, but on the input signal
spread - a control on the stereo spread and diffusion of the reverb signal
drylevel - amount of dry signal
earlyreflevel - amount of early reflection level
taillevel - amount of tail level
maxroomsize - to set the size of the delay lines. Defaults to roomsize + 1
 
Haiku : Il fuco vola via. La regina è schiava. (Fight Club, Chuck Palahniuk)

(
{
var source;
var fx;
var n=10;

source= EnvGen.ar(Env([0,1,0],[0.1,1.5]),LFNoise1.kr(Rand(20,30)))*Saw.ar(170,0.5);

fx= Mix.fill(n, {
var maxdelaytime= rrand(0.01,0.03);
var half= maxdelaytime*0.5;
var quarter= maxdelaytime*0.25;

DelayC.ar(source, maxdelaytime, LFNoise1.kr(Rand(5,10),0.01,0.02) )

})!2;

fx
}.play
)


(Env([0,1,0],[0.1,1.5])).plot

DelayC simple delay line with cubic interpolation
DelayC.ar(in, maxdelaytime, delaytime, mul, add)
DelayC.kr(in, maxdelaytime, delaytime, mul, add)

Simple delay line with cubic interpolation. See also DelayN which uses no interpolation, and DelayL which uses linear interpolation. Cubic interpolation is more computationally expensive than linear, but more accurate.

See also BufDelayC.

in - the input signal.
maxdelaytime - the maximum delay time in seconds. used to initialize the delay buffer size.
delaytime - delay time in seconds.


EnvGen envelope generator

Inherits from: Object : AbstractFunction : UGen

Plays back break point envelopes. The envelopes are instances of the Env class. See the Env for more info. The arguments for levelScale, levelBias, and timeScale are polled when the EnvGen is triggered and remain constant for the duration of the envelope.

*ar(envelope, gate, levelScale, levelBias, timeScale, doneAction)
*kr(envelope, gate, levelScale, levelBias, timeScale, doneAction)


envelope - an instance of Env, or an Array of Controls. (See Control and the example below for how to use this.)
gate - this triggers the envelope and holds it open while > 0. If the Env is fixed-length (e.g. Env.linen, Env.perc), the gate argument is used as a simple trigger. If it is an sustaining envelope (e.g. Env.adsr, Env.asr), the envelope is held open until the gate becomes 0, at which point is released.
levelScale - scales the levels of the breakpoints.
levelBias - offsets the levels of the breakpoints.
timeScale - scales the durations of the segments.
doneAction - an integer representing an action to be executed when the env is finished playing. This can be used to free the enclosing synth, etc. See UGen-doneActions for more detail.


Env envelope

superclass: Object

An Env is a specification for a segmented envelope. Envs can be used both server-side, by an EnvGen within a SynthDef, and clientside, with methods such as at and asStream, below. An Env can have any number of segments which can stop at a particular value or loop several segments when sustaining. It can have several shapes for its segment


LFNoise1 ramp noise

LFNoise1.ar(freq, mul, add)
LFNoise1.kr(freq, mul, add)

Generates linearly interpolated random values at a rate.
freq - approximate rate at which to generate random values.


















(
SynthDef(\test, {arg roomsize, revtime, damping, inputbw, spread = 15, drylevel, earlylevel,
        taillevel;
    var a = Resonz.ar(
        Array.fill(4, {SinOsc.ar(170)}), 1760 * [1, 2, 4, 8], 0.01).sum * 10;
   // var a = SoundIn.ar(0);
   // var a = PlayBuf.ar(1, 0);
    Out.ar(0, GVerb.ar(
        a,
        roomsize,
        revtime,
        damping,
        inputbw,
        spread,
        drylevel.dbamp,
        earlylevel.dbamp,
        taillevel.dbamp,
        roomsize, 0.3) + a)}).load(s)
)

s = Server.internal.boot;
s.scope(2);

// bathroom
a = Synth(\test, [\roomsize, 150, \revtime, 0.6, \damping, 0.62, \inputbw, 0.48, \drylevel -6, \earlylevel, -11, \taillevel, -13]);
a.free






(
{
    Mix.fill(37,
        {
        var freq;
        freq = exprand(100, 3000);
        Pan2.ar(
            SinOsc.ar(
                        freq * LFNoise1.kr(1/6, 0.4, 1),
                        mul: EnvGen.kr(Env.perc(0, (freq**(-0.7))*100), Dust.kr(1/5))
                    ), LFNoise1.kr(1/8)
                )
        })*0.3
}.play

)

vediamo un pò, questo è un esempio che ho preso dal libro di David Cottle, la variabile freq è un valore random in una distribuzione esponenziale da 100 a 3000 hz, quindi avremo più probabilità di sentire valori bassi(?) o alti, mi sembra valori bassi; abbiamo un Mix di 37 Sinusoidi ogniuna con una freq diversa moltiplicata per un LFNoise tra 1 e 1.4 e una frequenza molto bassa 0.16~; il mul delle sinusoidi è dato da un Envelope di tipo percussivo attacco 0, release dipendente dalla frequenza; l'envelope è triggerato da un Dust.kr; il posizionamento spaziale della Sinusoide è definito da LFNoise1.kr(1/8);

per LFNoise, Ugens with a default range of 0 to 1:
-The add is the low end of the range
-The mul is the amount of deviation above the low.
-The mul + add is the high end of the range
-The mul is the range


Dust                        random impulses

Dust.ar(density, mul, add)

Generates random impulses from 0 to +1.
density - average number of impulses per second



exprand

Generates a single random float value in an exponential distributions from lo to hi.


Mix         sum an array of channels

Mix.new(array)

Mix will mix an array of channels down to a single channel or an array of arrays of channels down to a single array of channels. More information can be found under MultiChannel.


Pan2            two channel equal power pan

Pan2.ar(in, pos, level)


LFNoise1                ramp noise

LFNoise1.ar(freq, mul, add)
LFNoise1.kr(freq, mul, add


EnvGen              envelope generator

Inherits from: Object : AbstractFunction : UGen

Plays back break point envelopes. The envelopes are instances of the Env class. See the Env for more info. The arguments for levelScale, levelBias, and timeScale are polled when the EnvGen is triggered and remain constant for the duration of the envelope.

*ar(envelope, gate, levelScale, levelBias, timeScale, doneAction)
*kr(envelope, gate, levelScale, levelBias, timeScale, doneAction)


*perc(attackTime, releaseTime, peakLevel, curve)

    Creates a new envelope specification which (usually) has a percussive shape.
    attackTime - the duration of the attack portion.
    releaseTime - the duration of the release portion.
    peakLevel - the peak level of the envelope.
    curve - the curvature of the envelope.



"The signal is the truth. The noise is what distracts us from the truth. Hack Noise."

(
SynthDef(\help_InFeedback, { arg out=0, in=0;
var input, sound;
input = InFeedback.ar(in, 1);
sound = SinOsc.ar(input * 1300 + 100, 0, 0.4)!2;
Out.ar(out, sound + Pluck.ar(ar(n=LFNoise1,400),a=SinOsc.kr(1),1,1/a.abs/200,99, mul: 0.1));

}).play;
)

InFeedback read signal from a bus with a current or one cycle old timestamp

Inherits from: Object : AbstractFunction : UGen : MultiOutUGen : AbstractIn

*ar(bus, numChannels)

bus - the index of the bus to read in from.
numChannels - the number of channels (i.e. adjacent buses) to read in. The default is 1. You cannot modulate this number by assigning it to an argument in a SynthDef


LFNoise1 ramp noise

LFNoise1.ar(freq, mul, add)
LFNoise1.kr(freq, mul, add)

Generates linearly interpolated random values at a rate.
freq - approximate rate at which to generate random values.

- Ah, l'ho capito, l'ho già capito... ho capito che lei è una macchina difettosa ed è per questo che la fabbrica l'ha messa qui. Vuole che le dica come mai lo so? Lo so perché io ci lavoro in quella fabbrica, le faccio io le macchine. 

(
Ndef(\happyalone, { arg amp=0.5;
var source, local, lfo;

lfo = LFNoise1.kr(0.32).abs*50+[70,0.01];
#source=SinOsc.ar(lfo,amp);
source=Decay.ar(LFSaw.ar(lfo), 0.1) * WhiteNoise.ar(0.2);
local = LocalIn.ar(2) + source;
local = LPF.ar(local, 400 + LFNoise1.kr(0.1,300,100)) * 1.5;
Splay.ar(local, LFNoise1.kr(0.21).range(0,1)) * amp;

}).play
)


Splay


*ar(inArray, spread,level, center,
levelComp)

*arFill(n, function, spread,level,
center, levelComp)

Splay spreads an array of channels across
the stereo field.

Optional spread and center controls, and
levelComp(ensation) (equal power).


LocalIn define and read from buses local to a synth

Inherits from: Object : AbstractFunction : UGen : MultiOutUGen : AbstractIn

*ar(numChannels) - define and read from an audio bus local to the enclosing synth.
*kr(numChannels) - define and read from a control bus local to the enclosing synth.

numChannels - the number of channels (i.e. adjacent buses) to read in. The default is 1. You cannot modulate this number by assigning it to an argument in a SynthDef.

LocalIn defines buses that are local to the enclosing synth. These are like the global buses, but are more convenient if you want to implement a self contained effect that uses a feedback processing loop.
There can only be one audio rate and one control rate LocalIn per SynthDef.
The audio can be written to the bus using LocalOut.


LPF 2nd order Butterworth lowpass filter

Inherits from: Object : AbstractFunction : UGen : Filter

LPF.ar(in, freq, mul, add)
LPF.kr(in, freq, mul, add)


A second order low pass filter.
in - input signal to be processed
freq - cutoff frequency.


abs absolute value

a.abs
abs(a)


SimpleNumber

abs(-5);
-5.abs;




Arduino;
TvOut;
Speaker;




Arduino;
Arduino-TVout library; invece della resistenza 470 Ohm ne ho usata una da 330 Ohm



Il Trigger di Schmitt è usato talvolta per realizzare un semplice tipo di oscillatore a rilassamento o di multivibratore. Si ottiene collegando ad una porta invertente una semplice rete RC, il condensatore si connette tra l'ingresso e la massa e il resistore tra l'ingresso e l'uscita. L'uscita sarà un'onda quadra continua la cui frequenza dipende dal valore di R e di C, e dai valori di soglia del Trigger medesimo. Poiché i circuiti di Trigger di Schmitt possono essere provveduti da un singolo circuito integrato (p.es., la serie 4000 dei dispositivi CMOS tipo 40106 ne contengono 6), una sezione libera del circuito integrato può venire utilizzata come semplice ed affidabile oscillatore con due soli componenti esterni. Si deve tuttavia rendere evidente che la stabilità di frequenza non è molto elevata.



1 CMOS Hex Schmitt Trigger CD40106BE
1 fotoresistore
1 Condensatore 1 uF

Schmitt Trigger Oscillator
Spiegazione
Talking Electronics










#include <IRremote.h>



int RECV_PIN = 7;

int LED = 13;

int speakerPin = 3;





IRrecv irrecv(RECV_PIN);



decode_results results;



void setup()

{

  Serial.begin(9600);

  irrecv.enableIRIn(); // Start the receiver

  pinMode(LED, OUTPUT);

}



void loop() {

  if (irrecv.decode(&results)) {

    Serial.println(results.value, HEX);

    tone(speakerPin,1000,300);

   

    switch(results.value)



  {



  case 0xC0B92:

    Serial.println("fanculo");

    break;



  case 0xFF629D:

    Serial.println(" CH             ");

    break;

  }

    digitalWrite(LED, HIGH);

    delay(100);

    digitalWrite(LED, LOW);

    delay(100);

   

    irrecv.resume(); // Receive the next value

  }

}

























































int LEDGreen=9;

int LEDBlue=10;

int LEDRed=11;





int sensorPin=0;

int val;



void setup(){

  Serial.begin(9600);

  pinMode(LEDRed,OUTPUT);

  pinMode(LEDGreen,OUTPUT);

  pinMode(LEDBlue,OUTPUT);

}



void loop(){



  val=map(analogRead(sensorPin),0,1024,0,900);

  Serial.println(val);

  if (val<150) {

    analogWrite(LEDRed,0);

    analogWrite(LEDBlue,255);

    analogWrite(LEDGreen,255);

  } else if (val<300) {

    analogWrite(LEDRed,map(val,150,300,0,255));

    analogWrite(LEDBlue,map(val,150,300,255,0));

    analogWrite(LEDGreen,255);

  } else if (val<450) {

    analogWrite(LEDRed,255);

    analogWrite(LEDBlue,0);

    analogWrite(LEDGreen,255);

  } else if (val<600) {

    analogWrite(LEDRed,255);

    analogWrite(LEDBlue,map(val,450,600,0,255));

    analogWrite(LEDGreen,map(val,450,600,255,0));

  } else if (val<750) {

    analogWrite(LEDRed,255);

    analogWrite(LEDBlue,255);

    analogWrite(LEDGreen,0);

  } else if (val<900) {

    analogWrite(LEDRed,map(val,750,900,255,0));

    analogWrite(LEDBlue,255);

    analogWrite(LEDGreen,map(val,750,900,0,255));

  }

  delay(10);

}







int speakerPin = 9;



int length = 15; // the number of notes

char notes[] = "ccggaagffeeddc "; // a space represents a rest

int beats[] = { 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 2, 4 };

int tempo = 300;



void playTone(int tone, int duration) {

  for (long i = 0; i &lt; duration * 1000L; i += tone * 2) {

    digitalWrite(speakerPin, HIGH);

    delayMicroseconds(tone);

    digitalWrite(speakerPin, LOW);

    delayMicroseconds(tone);

  }

}



void playNote(char note, int duration) {

  char names[] = { 'c', 'd', 'e', 'f', 'g', 'a', 'b', 'C' };

  int tones[] = { 1915, 1700, 1519, 1432, 1275, 1136, 1014, 956 };



  // play the tone corresponding to the note name

  for (int i = 0; i &lt; 8; i++) {

    if (names[i] == note) {

      playTone(tones[i], duration);

    }

  }

}



void setup() {

  pinMode(speakerPin, OUTPUT);

}



void loop() {

  for (int i = 0; i &lt; length; i++) {

    if (notes[i] == ' ') {

      delay(beats[i] * tempo); // rest

    } else {

      playNote(notes[i], beats[i] * tempo);

    }



    // pause between notes

    delay(tempo / 2);

  }

}