Out of memory (OOM) is an often undesired state of computer operation where no additional memory can be allocated for use by programs or the operating system. Such a system will be unable to load any additional programs, and since many programs may load additional data into memory during execution, these will cease to function correctly. This usually occurs because all available memory, including disk swap space, has been allocated.





















Con Circuit Bending si indica l'arte di modificare in maniera creativa, attraverso semplici cortocircuiti, apparecchi elettronici a bassa tensione o strumenti elettronici alimentati a pile, come giocattoli (il più famoso tra questi è lo Speak & Spell della Texas Instruments, commercializzato in Italia come Grillo Parlante dalla Clementoni), tastiere, batterie elettroniche e effetti per chitarra, allo scopo di generare suoni inediti e curiosi, creare nuovi strumenti musicali e generici generatori di suono.

Generalmente il Circuit Bending viene associato alla musica elettronica sperimentale, al noise e a musicisti alla ricerca di nuovi suoni e di nuove strumentazioni "aleatorie". I suoni generati da tali apparecchiature sono, infatti, per lo più casuali, caotici o comunque non canonicamente collegabili all'idea di suono emesso da uno strumento musicale.

Articolo Punto Informatico





Il delirium tremens (DTS) è uno stato confusionale di rapida insorgenza che di solito è causato dall'astinenza da alcool in soggetti affetti da alcolismo cronico. Se si verifica, avviene circa dopo tre giorni dall'inizio dell'astinenza e si protrae per due o tre giorni. Le persone colpite possono anche essere vittime di allucinazioni.[1] Gli effetti fisici possono includere tremore, brividi, battito cardiaco irregolare e sudorazione.In casi più rari si può verificare una ipertermia o un attacco epilettico, che possono portare alla morte. L'astinenza da alcol è una delle condizioni più pericolose tra le astinenze dalle varie droghe.





It's got:
Glitch button
Glitch button with variable depth knob
Glitch body contacts
Heavy distortion/feedback knob
Distortion opto theremin (w/ on/off switch)
2 hidden sounds selection buttons
1/8" output jack
Speaker on/off switch
Green LEDs that pulse to the sound








2 Timer 555
1 Condesatore ceramico 0.1 uF
1 Condesatore ceramico 0.01 uF
1 Condesantore elettrolitico 100 uF
1 Resistenza 1K Ohm
• 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.


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

(
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




1 OPAMP UA741
2 Resistor 1MΩ
1 Resistor 2k2
1 NPN Transistor 2N2222A
1 47n Capacitor

------------------------------



C1 Ceramic Capacitor capacitance 10nF;
J1 Piezo Speaker;
R1 Rotary Potentiometer resistance 10kΩ;
R2 Resistor resistance 100Ω;
R3 Resistor resistance 470Ω;
R4 Resistor resistance 1kΩ;
U1 555 Timer package DIP8
VCC1 Battery & Connector voltage 9V
 
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;







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 < 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 < 8; i++) {

    if (names[i] == note) {

      playTone(tones[i], duration);

    }

  }

}



void setup() {

  pinMode(speakerPin, OUTPUT);

}



void loop() {

  for (int i = 0; i < length; i++) {

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

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

    } else {

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

    }



    // pause between notes

    delay(tempo / 2);

  }

}