RE Project

p={Saw.ar(SinOsc.kr(30,0,440,440),mul:0.2)+AY.ar(SinOsc.kr(1200,0,713,713),mul:0.5);}.plot(0.01);

(
{
 var snd,cutoff;
 snd=Saw.ar(SinOsc.kr(30,0,440,440),mul:0.2)+AY.ar(SinOsc.kr(1200,0,713,713),mul:0.5);
 cutoff=Saw.kr(50,0.3,0.3)+PinkNoise.kr(0.1);
 snd=CombN.ar(snd,0.01,XLine.kr(0.00713, 1, 140),0.2);
 snd=RLPF.ar(snd,713*cutoff,0.2);
 snd!2;
}.plot(0.1);
)

il suono principale nasce dalla sovrapposizione tra un segnale a dente di sega modulato in frequenza da una sinusoide e il suono generato dal chip sonoro AY, modulato in frequenza sempre da una sinusoide;

la cutoff del Filtro Passa Basso Risonante RLPF è modulata da un segnale di controllo che è dato dalla somma tra un segnale a dente di sega e un segnale generato da un generatore di rumore rosa la cui ampiezza è moltiplicata per 0.1;

il delaytime, tempo di ritardo, della linea di ritardo del Filtro a Pettine CombN senza interpolazione è modulato da un generatore di curva esponenziale, che in 140 secondi passa dal valore 0.00713 al valore 1; il suono fatto passare in questa linea di ritardo subisce una trasformazione a livello timbrico, dovuta a cancellazione e rafforzamento di diverse armoniche; lo spettro armonico del segnale risultante assume la forma di un pettine; il passaggio attraverso questo Filtro produce un carattere metallico nel timbro finale del suono;

s.boot;

p={RLPF.ar(Pulse.ar([11, 13]), LFNoise1.ar([3, 7], 200, 300), 0.01)*0.1}.plot;
play({RLPF.ar(Pulse.ar([11, 13]), LFNoise1.ar([3, 7], 200, 300), 0.01)*0.1})




















qui abbiamo un RLPF, un filtro passa basso risonante che intercetta due Pulse a bassa frequenza, e CutOff modulato da un UGen LFNoise1 che genera valori random interpolati linearmente a un rate dato dalla frequenza; in questo caso sono due le Ugen in gioco; normalmente l'LFNoise1 genera valori random tra -1 e 1, in questo caso tra 100 e 500; l'rq del filtro è impostato a 0.01, sarebbe il reciproco di q; q è dato dal rapporto tra la CutOff e la larghezza di banda; in questo caso, minore è il valore di rq e più risonanza avra il filtro; il tutto è moltiplicato per 0.1 per attenuare l'ampiezza del segnale in uscita;

RLPF.ar(in: 0.0, freq: 440.0, rq: 1.0, mul: 1.0, add: 0.0)

RLPF.scopeResponse;
























(
{
GVerb.ar((
{
var burstEnv, att = 0, dec = 0.001;
var burst, delayTime, delayDecay = 0.1;
var midiPitch = 37; // A 440
delayTime = midiPitch.midicps.reciprocal;

burstEnv = EnvGen.kr(Env.perc(att, dec), gate: PinkNoise.kr(1/delayDecay));
burst = PinkNoise.ar(burstEnv);
CombL.ar(burst, delayTime, delayTime,delayDecay, add: burst);
}
),270,30,0.7,drylevel:0.5)
}.play
)

p={LFNoise1.kr(freq: 500.0, mul: 1.0, add: 0.0)}.plot(5);




















qui abbiamo un segnale PinkNoise che viene fatto passare attraverso una linea di ritardo a pettine, Comb Filter, con interpolazione lineare; il segnale passando attraverso questa linea di ritardo e subendo delle inversioni di fase per diverse frequenze del suo spettro, una volta sommato al segnale originale produce questo spettro a pettine dovuto alla sovrapposizione del segnale diretto e alla copia del segnale leggermente ritardata e quindi alla cancellazione e il rinforzo di diverse frequenze; la somma tra i due timbri produce quindi rinforzi e annullamenti periodici nell'ampiezza dello spettro passante; il trattamento forito dal Comb Filter aggiunge al segnale passante una severa componente metallica; l'ampiezza del segnale PinkNoise è modulata da un inviluppo percussivo attivato attraverso il gate da un altro segnale PinkNoise di controllo; il tutto è fatto passare all'interno di una Ugen di riverbero;


p={PinkNoise.ar(10)}.plot;




















i = Image.fromWindow(p.parent, p.interactionView.bounds);
i.write("~/Desktop/pinknoise.png".standardizePath);
i.free

Reverse Engineering SCCode : «Kepler 22-b atmosphere» by vividsnow




(
fork {   
    Ndef(\ttwnd).play; //(d,2,addAction:\addToHead);
    loop {
        var seed = thisThread.randSeed = 100000000.rand.debug('seed');
        Ndef(\ttwnd, {
            var freq = [20, 7500];
            Splay.ar(
                {
                    var bands = 2.rrand(10);
                    var sig = { [BPF,RLPF,RHPF].choose.ar(
                        LFNoise2.ar(freq[0].rrand(freq[1]), LFNoise2.kr(0.1.exprand(10))),
                        Array.rand(bands, freq[0], freq[1]),
                        Array.rand(bands, 0.2, 1.8)
                    ).mean } ! 2;
                    Rotate2.ar(sig[0], sig[1], LFSaw.kr(0.1.exprand(10)));
                } ! 4.rrand(6).debug('source'), // creazione dell'array da passare a Splay
                                0.5.rrand(1) // spread dell'Splay
            );
        }).fadeTime_(1.rrand(4.0)); // fadeTime randomico
        10.0.rrand(40).debug('wait(bts)').wait;
    }
}
)

Struttura del codice, un loop interno a una Routine;
qui una versione semplificata;

(

{

loop {   
    "1*********".postln;
    1.0.wait;   
    "2*********".postln;
    1.0.wait;   
    "3*********".postln;
    1.0.wait;   
    "4*********".postln;
    1.0.wait;   
}
   

}.fork;    

)

UGen :

Ndef è una definizione di un Nodo Proxy;

Ndef registra i Synth attraverso un nome chiave. Tutti gli accessi ai Synth registrati attraverso l'Ndef avvengono tramite quel nome chiave. I Synth registrati possono essere sostituiti con altri Synth durante la riproduzione. I Synth si dissolvono e vengono sostituiti automaticamente e il tempo di sostituzione può essere quantificato.

Ndef è un riferimento in un Proxy, costituisce un'alternativa al ProxySpace. Tutti i metodi sono ereditati da NodeProxy.


thisThread.randSeed = 100000000.rand.debug('seed'); il seed, il seme della distribuzione randomica del thread;


Splay spalma sui canali stereo un array di canali,

Splay.arr(inArray, spread: 1, level: 1, center: 0.0, levelComp: true)

spread = 0, tutti i canali finiscono al centro, 1 massima diffusione, immagino parli del pan?


[BPF,RLPF,RHPF].choose sceglie ogni volta il tipo di filtro, passa band, passa basso risonante, passa alto risonante;


LFNoise2 generatore di rumore, genera valori random, interpolati quadraticamente,

Interpolazione. L'interpolazione consiste nel processo utile a determinare la "migliore" stima dei valori di una funzione f(x) quando ci sono a disposizione solo un numero finito di punti noti. L'Interpolazione lineare può introdurre notevoli errori nella stima dei valori della funzione per l'assenza di curvatura. Ma avendo a disposizione tre punti è possibile introdurre una curvatura del secondo ordine (parabola) per interpolare meglio i dati;

f2(x)=a0+a1x+a2x^2

LFNoise2.ar(freq: 500.0, mul: 1.0, add: 0.0)

Analisi Codice :

Splay.ar(
                {
                    var bands = 2.rrand(10);
                    var sig = { [BPF,RLPF,RHPF].choose.ar(
                        LFNoise2.ar(freq[0].rrand(freq[1]), LFNoise2.kr(0.1.exprand(10))),
                        Array.rand(bands, freq[0], freq[1]),
                        Array.rand(bands, 0.2, 1.8)
                    ).mean } ! 2;
                    Rotate2.ar(sig[0], sig[1], LFSaw.kr(0.1.exprand(10)));
                } ! 4.rrand(6).debug('source'), // creazione dell'array da passare a Splay
                                0.5.rrand(1) // spread dell'Splay
            )


viene prima scelto randomicamente il numero di bands;
il segnale viene creato facendo passare attraverso un filtro (BPF, RLPF o RHPF) un generatore di rumore a interpolazione quadratica

RLPF.ar(in: 0.0, freq: 440.0, rq: 1.0, mul: 1.0, add: 0.0)

in : LFNoise2.ar
freq : Array.rand(bands, freq[0], freq[1])

Array.rand(size, minVal, maxVal) // quindi qui avviene un'espansionzione multicanale a seconda del numero scelto per bands

rq : Array.rand(bands, 0.2, 1.8), la frequenza di risonanza; il reciproco di Q (bandwidth/cutoffFreq)

dopo di che interviene .mean che

collassa tutti i canali su un canale e poi il !2 che li espande su due canali;

{(SinOsc.ar(440)!2).mean}.plot  // verifica del funzionamento di .mean
{(SinOsc.ar(440)!2)}.plot
{(SinOsc.ar(440)!2).mean}.play
{(SinOsc.ar(440)!2)}.play

i due segnali sig[0] e sig[1] vengono passati a Rotate2

Rotate2 prende questi due segnali, in questo caso i due canali stereo, e li ruota spazialmente, in base a un angolo che in questo caso è fornito dall'output dell'UGen LFSaw, che è un oscillatore "dente di sega" non limitato in banda;

! 4.rrand(6).debug('source'); // creazione dell'array da passare a Splay, da 4 a 6 elementi;

che prende questo array di canali e li spalma su i due canali stereo;


0.1.exprand(10); genera valori random da 0.1 a 10 con probabilità esponenziali; dall'osservazione sembrano più probabili i valori bassi; in effetti dal grafico, sono più probabili i valori bassi;




rrand funzione che serve a generare valori random;

1.rrand(4.0) random da 1 a 4

wait(bts) è una stringa di debug

Type the following command to see IPv4 port(s), enter:
# lsof -Pnl +M -i4
Type the following command to see IPv6 listing port(s), enter:
# lsof -Pnl +M -i6

• -P : This option inhibits the conversion of port numbers to port names for network files. Inhibiting the conversion may make lsof run a little faster. It is also useful when port name lookup is not working properly.
• -n : This option inhibits the conversion of network numbers to host names for network files. Inhibiting conversion may make lsof run faster. It is also useful when host name lookup is not working properly.
• -l : This option inhibits the conversion of user ID numbers to login names. It is also useful when login name lookup is working improperly or slowly.
• +M : Enables the reporting of portmapper registrations for local TCP and UDP ports.
• -i4 : IPv4 listing only
• -i6 : IPv6 listing only

Type the command as follows:
# netstat -tulpn
OR
# netstat -npl

$ cat /etc/services
$ grep 110 /etc/services
$ less /etc/services

https://www.cyberciti.biz/faq/find-out-which-service-listening-specific-port/

// 18
// Nathaniel Virgo
(
play{
    p = PinkNoise.ar(1!2);
    BRF.ar(
        p + Blip.ar(p+2,400),
        150,
        2,
        0.1
    )
    +
    LPF.ar( FreeVerb2.ar( *LPF.ar( p + 0.2 * Dust.ar( 0.1 ), 60) ++ [ 1, 1, 0.2, 1e4 ]).tanh, 2000)
}
)





(1!2).postln -> [ 1, 1 ]
PinkNoise *ar (mul: 1.0, add: 0.0)
PinkNoise.ar([1,1])

Genera rumore rosa il cui spettro decade in potenza di 3 dB per ottava, il che fornisce uguale potenza nell'arco di ciascuna ottava. Questa versione ha un limite di banda di 8 ottave.

Al rumore rosa viene aggiunto un segnale

Blip.ar(freq: 440.0,  numharm: 200.0,  mul: 1.0,  add: 0.0)
che è un segnale di impulsi limitato in banda; il numero di armoniche nel nostro caso è settato a 400; la frequenza è data dal doppio PinkNoise; quella specie di rumore di gocce di acqua che cadono che si sente è dovuto all'UGen Blip.ar;

il segnale risultante è fatto passare in un filtro risonante rifiuta banda, BRF.ar(in: 0.0, freq: 440.0, rq: 1.0, mul: 1.0, add: 0.0)



BRF.scopeResponse

a questo segnale è aggiunto un secondo segnale :




















LPF.ar( FreeVerb2.ar( *LPF.ar( p + 0.2 * Dust.ar( 0.1 ), 60) ++ [ 1, 1, 0.2, 1e4 ]).tanh, 2000)

Un "*" prima di un array all'interno di una funzione divide gli elementi dell'array e li passa agli args, nel nostro caso alla UGen FreeVerb2.ar. Diventa più chiaro facendo questo con il metodo Array.with che genera un nuovo array e prevede elementi separati.

Array.with(*LPF.ar (PinkNoise.ar (1! 2) + 0.2 * Dust.ar (0.1), 60) ++ [1, 1, 0.2, 1e4])
-> [ a LPF, a LPF, 1, 1, 0.2, 10000.0 ]

quindi la UGen avra questi args : FreeVerb2.ar(in: LPF,  in2: LPF,  mix: 1,  room: 1,  damp: 0.2,  mul: 10000.0,  add: 0.0)

questo segnale genera un forte boato, 1 volta ogni 10 secondi circa, dovuto all'impulso creato dal Dust moltiplicato per il Rumore Rosa;

La precedenza sinistra-destra di SC provoca l'aggiunta di un offset di 0,2 (al Rumore Rosa stereo) prima della moltiplicazione con l'impulso Dust.
La funzione sigmoide tanh mantiene il segnale tra -1 e + 1;

Per quanto riguarda l'offset di 0,2. Ho solo un presupposto: il file di aiuto di PinkNoise dice:

NOTA: è stato osservato che i valori prodotti da questa UGen sono molto probabilmente tra -0,65 e +0,81 circa (prima di essere moltiplicati per mul).

Quindi potrebbe essere che l'intenzione fosse quella di mantenere il segnale all'incirca al di sotto di 1, con probabilità molto alta.

// Modo per attivare e esplorare le Eccezioni con la GUI

Exception.debug = true;

// Metodo per salvare l'immagine del Plot

p= {BRF.ar( PinkNoise.ar(1!2) + Blip.ar(PinkNoise.ar(1!2)+2,400), 150, 2, 0.1) }.plot(10);
i = Image.fromWindow(p.parent, p.interactionView.bounds);
i.write("~/concat.png".standardizePath);
i.free

// Metodo per tracciare una Synth

(
SynthDef(\resonz, { |out, freq = 440|
    var    sig, ffreq;
    sig = PinkNoise.ar(1!2);
    Out.ar(out, FreeVerb2.ar( *LPF.ar( sig + 0.2 * Dust.ar( 0.1 ), 60) ++ [ 1, 1, 0.2, 1e4 ]).tanh, 0.1)
}).send(s);

)

a = Synth(\resonz);
a.trace;

// Metodo per capire come è composto un segnale

sig = PinkNoise.ar(1 ! 2).postln;
sig = LPF.ar (sig + 0.2 * Dust.ar(0.1), 60).postln;
sig = (sig ++ [1, 1, 0.2, 1e4]).postln;
sig = FreeVerb2.ar(*sig).postln;

Reverse Engineering di un sc-tweet di Rukano

play{a[1,1.01,2,2.02,3.5,4.01,5.501];SinOsc.ar(Duty.kr(0.2,0,Dseq([10,11,0,12.2,0,0,10,0]+39,inf).midicps)*(a++(a*2))).sum!2/10}//DAF #sc

Un Oscillatore Sinusoidale, SinOsc.ar, la cui frequenza è estratta dalla lista di Dseq dall'UGen Duty ogni 0.2 secondi; il tutto è moltiplicato per 14 valori ottenuti concatendando l'array di 7 valori "a" al doppio di se stesso; quindi per ogni elemento estratto ogni 0.2 secondi da Duty.kr abbiamo 14 Sinusoidi che poi vengono sommate in un unico segnale; il segnale ottenuto viene poi duplicato sul canale sinistro e destro dell'uscita; l'ampiezza è divisa per 10;





















SinOsc.ar(freq: 440,  phase: 0.0,  mul: 1.0,  add: 0.0)

Duty.kr(dur: 1.0,  reset: 0.0,  level: 1.0,  doneAction: 0)

ogni "dur" secondi, viene richiesto un valore da ogni Ugen nella lista; nel nostro caso ogni 0.2 secondi, viene richiesto un elemento della lista ([10,11,0,12.2,0,0,10,0]+39).midicps che viene generato dalla Ugen Dseq;





















Dseq.new(list, repeats: 1)

Generatore di sequenze; genera un valore appartenente alla lista, ogni volta che viene interrogato da Ugen tipo Demand, Duty, Drand, ecc.

{a[1,1.01,2,2.02,3.5,4.01,5.501];SinOsc.ar(Duty.kr(0.2,0,Dseq([10,11,0,12.2,0,0,10,0]+39,inf).midicps)*(a++(a*2)))}.plot(10)





















(a++(a*2))
[ 1, 1.01, 2, 2.02, 3.5, 4.01, 5.501, 2, 2.02, 4, 4.04, 7.0, 8.02, 11.002 ]

play{AY.ar((Hasher.ar(Latch.ar(AY.ar((1..3)!2),Impulse.ar([7/3,1])))*337+317).round(73),0,LFNoise2.ar(3,1/3,1/3))/7}//#supercollider

AY.ar(tonea: 1777,  toneb: 1666,  tonec: 1555,  noise: 1,  control: 7,  vola: 15,  volb: 15,  volc: 15,  envfreq: 4,  envstyle: 1,  chiptype: 0,  mul: 1,  add: 0)

Emula lo strumento AY-3-8910 (a.k.a. the Yamaha YM2149) a tre voci, tre suoni chip.

i tre suoni chip :

tonea : (Hasher.ar(Latch.ar(AY.ar((1..3)!2),Impulse.ar([7/3,1])))*337+317).round(73)
toneb : 0
tonec : LFNoise2.ar(3,1/3,1/3)

Latch.ar(in: 0.0,  trig: 0.0)

Il Latch mantiene l'input quando viene triggherato e genera zero all'inizio fino a quando non viene triggherato; nel nostro caso è triggherato da un doppio generatore di impulsi; quindi probabilmente il Latch campiona due valori secondo frequenze diverse;

questo è il segnale che viene campionato sui due canali stereo secondo il trig dei due impulsi;

{AY.ar((1..3))}.plot





































{Latch.ar(AY.ar((1..3)!2),Impulse.ar([7/3,1]))}.plot





















{(Hasher.ar(Latch.ar(AY.ar((1..3)!2),Impulse.ar([7/3,1])))*337+317).round(73)}.plot(10)





















Hasher.ar(in: 0.0,  mul: 1.0,  add: 0.0)

L'Hasher è un generatore Hash, che genera valori tra -1 e 1 a seconda dell'input che riceve secondo una funzione Hash; lo stesso valore di input genererà lo stesso valore hash in output; il segnale di input non ha bisogno di essere nel range di -1 e 1.


Impulse.ar(freq: 440.0,  phase: 0.0,  mul: 1.0,  add: 0.0)

Genera in output impulsi non limitati in banda; in teoria quindi se si superano i 22050 Herz di frequenza avremo un mirror nello spettro in frequenza?

round

round(a, b)
a round: b
a.round(b)

Arrotonda al più vicino multiplo di b;

LFNoise2.ar(freq: 500.0, mul: 1.0, add: 0.0)

{LFNoise2.ar(3,1/3,1/3)}.plot(10)





















Genera valori casuali interpolati quadraticamente ad una velocità data dalla divisione intera più vicina della frequenza di campionamento freq.

Un ragionamento viene detto deduttivo, quando si conoscono le premesse e le regole (o leggi) e si intende ricavare il risultato o l’esito.Questo tipo di logica (vedi i sillogismi di Aristotele) si applica quando si vuole sapere quali risultati si ottengono applicando delle leggi conosciute. Se tutte le operazioni previste sono state svolte correttamente, le risposte che si ottengono sono sempre certe e sicure e per questo motivo molti sostengono che la logica deduttiva non porta mai a delle novità in quanto i risultati ottenuti sono già impliciti nelle premesse

Premessa, Regola --> Risultato

Premessa: i fagioli provengono dal sacco
Regola: tutti i fagioli del sacco sono bianchi
Risultato:i fagioli sono bianchi (sicuramente)

Il ragionamento deduttivo non aumenta la conoscenza; d'altro canto però le conclusioni sono vere.

Un ragionamento viene detto induttivo quando si conoscono le premesse e i risultati e si intende ricostruire le regole. Questo tipo di logica è tipica di chi, come ad esempio gli scienziati, vuole risalire a una legge naturale osservando quale risultato è stato ottenuto a partire da certe situazioni o premesse iniziali conosciute. La legge che si ottiene non è sicura in assoluto, ma solo probabile (vedi anche Bayes).

Premessa, Risultato --> Regola 

Premessa: i fagioli provengono dal sacco
Risultato verificato: i fagioli sono bianchi
Regola ipotizzata:tutti i fagioli del sacco sono bianchi (probabilmente)

Il ragionamento induttivo permette di allargare la nostra conoscenza mediante un processo di generalizzazione: l'induzione però può essere soggetta ad errori.

Un ragionamento viene detto abduttivo, quando si conoscono regole e risultati e si intende ricostruire le premesse. Questo tipo di logica è propria di chi cerca, come ad esempio un medico o un investigatore, di ricostruire una situazione iniziale, conoscendo il risultato che è stato ottenuto per effetto di una legge nota. Anche in questo caso la situazione iniziale che si ricostruisce non è mai certa ma valida solo con un dato livello di probabilità.

Regola, Risultato --> Premessa

Regola: tutti i fagioli del sacco sono bianchi
Risultato verificato: i fagioli sono bianchi
Fatto ipotizzato:i fagioli provengono dal sacco (forse)

Il ragionamento abduttivo tende a fornire ipotesi esplicative. Ovviamente anche l'abduzione non è esente da errori.

l'abduzione coincide con il metodo ipotetico sperimentale che caratterizza la scienza moderna da Galilei in poi. Le conclusioni a cui arriva l'abduzione non sono mai definitive, ma aprono la strada a nuove ricerche e a nuove conclusioni secondo il modello di approssimazione progressiva alla realtà che caratterizza il metodo scientifico.

La chiave concettuale del reverse engineering si chiama abduzione, uno schema di ragionamento teorizzato dal logico Charles Peirce: partire da un dato risultato, alla luce di leggi note, per ricostruire le cause di quel risultato. È il modo di procedere tipico degli investigatori o della medicina diagnostica.

L'abduzione è il processo di formazione d'ipotesi esplicative. È l'unica operazione logica che introduce una nuova idea, in quanto l'induzione non fa che determinare un valore e la deduzione sviluppa semplicemente le conseguenze necessarie di una pura ipotesi. La deduzione trova che qualcosa deve essere; l'induzione mostra che qualcosa è realmente operativa; l'abduzione meramente suggerisce che qualcosa può essere;

Nella risoluzione di problemi complessi non si ricorre mai ad un solo tipo di logica. In particolare per considerare se determinate ipotesi scaturite da ragionamenti induttivi o abduttivi possono essere considerate attendibili, è necessario sottoporle a dei controlli di tipo deduttivo e a corroborarle mediante seri tentativi di falsificazione;

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

2 Timer 555
1 Condesatore ceramico 0.1 uF
1 Condesatore ceramico 0.01 uF
1 Condesantore elettrolitico 100 uF
1 Resistenza 1K Ohm

Il chip CD4093 è composto da quattro porte NAND identiche. Ci sono due porte su ciascun lato del chip, ma a differenza del 74C14, sono disposte in modo simmetrico, specularmente : l'uscita di ciascuna porta fronteggia l'uscita della successiva, piuttosto che essere nella stessa direzione.

Ho giocato con le fotoresistenze, una tra l'uscita e l'ingresso verso il condensatore e la massa della prima porta NAND va a modulare il Gate della seconda porta NAND da cui viene perlevata l'uscita audio; poi ho fatto un po di cambiamenti a caso per arrivare a effetti audio particolari modulando le fotoresistenze con delle luci intermittenti;

L'interferenza dei fili sul sensore ad ultrasuoni ha prodotto questa melodia impazzita di suoni, dovuta alla presenza dei fili e al mio corpo che si avvicinava e allontanava dal sensore;

I sensori ad ultrasuoni non forniscono direttamente la misura della distanza dell’oggetto più vicino, ma misurano il tempo impiegato da un segnale sonoro a raggiungere l’oggetto e ritornare al sensore. L’impulso ad ultrasuoni inviato dal HC-SR04 è di circa 40KHz il tempo viene misurato in microsecondi, la tensione di funzionamento è di 5V

Il sensore HC-SR04 dispone di 4 pin: Vcc (+5V), Trigger, Echo, GND. Si invia un impulso alto sul pin Trigger per almeno 10 microsecondi, a questo punto il sensore invierà il ping sonoro e aspetterà il ritorno delle onde riflesse, il sensore risponderà sul pin Echo con un impulso alto della durata corrispondente a quella di viaggio delle onde sonore, dopo 38 millisecondi si considera che non sia stato incontrato alcun ostacolo. Per sicurezza si aspettano in genere 50-60 millisec per far si che non vi siano interferenze con la misura successiva.

Progetto originale : link

Hardware

330Ω Resistor
470Ω Resistor
Solderless Breadboard
Ultrasonic Distance Sensor
3 x Male to Male Jumper Leads
4 x Male to Female Jumper Leads

Software

sudo apt update && sudo apt upgrade -y
sudo pip3 install python-osc

Python :

from gpiozero import DistanceSensor
from time import sleep

from pythonosc import osc_message_builder
from pythonosc import udp_client

sensor = DistanceSensor(echo=17, trigger=4)
sender = udp_client.SimpleUDPClient('127.0.0.1', 4559)

while True:
        pitch = round(sensor.distance * 100 + 30)
        sender.send_message('/play_this', pitch)
        sleep(0.1)


------

Sonic Pi :


live_loop :listen do
       message = sync "/play_this"
       note = message[:args][0]
       play note
end

Il CD4049 Hex Inverter.
Il resistore di ingresso, RI, generalmente di 10kOhm.
Il resistore di retroazione, RF, generalmente più grande di RI.
Il condensatore di ingresso, CI, generalmente intorno a 0.1uf.
Il condensatore di uscita, CO, generalmente intorno a 10uf.

Il guadagno, ovvero quanto il circuito amplifica il segnale in ingresso, è determinato dal rapporto RF/RI. Quindi, se RF = 100kOhms e RI = 10kOhms, il guadagno è di 10, il che significa che qualsiasi segnale in input al circuito viene amplificato di 10 volte. Se RF = 10mOhms e RI = 10kOhms il guadagno è di 1000, il che rende il segnale MOLTO più forte. Sostituendo i resistori fissi con un potenziometro (tipo da 1 megOhm) possiamo variare il guadagno del circuito. Per un tipico preamplificatore (come quello che si potrebbe usare per un microfono) si potrebbe desiderare di collegare una resistenza da 10k in serie al potenziometro da 1 megOhm: ciò consente di regolare l'amplificazione in modo fluido dal guadagno unitario (segnale in uscita uguale al segnale in ingresso) a un guadagno di 100 (output = 100 volte l'ingresso).

I condensatori all'ingresso e all'uscita (CI e CO) bloccano le tensioni continue presente nel circuito.  Sono necessari per la stabilità del circuito, e di solito non influenzano molto il suono.

Inserisci un chiodo o una graffetta in un limone. Poi un pezzo di filo di rame. Assicurati che il filo e il chiodo siano vicini, ma che si non tocchino. Il chiodo è diventato l'elettrodo negativo della batteria e il filo di rame l'elettrodo positivo. Il succo di limone, che è acido, agisce come l'elettrolita. È possibile utilizzare altre cose oltre alla graffetta, al chiodo e al filo di rame, purché costituite da metalli diversi. La batteria al limone fornirà circa un quarto a un terzo di un Volt. Per utilizzare una batteria al limone per alimentare un piccolo dispositivo elettrico, come un LED, è necessario collegarne diverse in serie;

al posto del Fotoresistore nel simulatore ho messo uno Switch, quando è buio la resistenza è altissima, il valore del Fotoresistore in assenza di luce tende a pochi Ohm, ed è come se lo Switch fosse aperto e quindi il LED si accende; quando invece è giorno, la resistenza è praticamente nulla ed è come se lo Switch fosse chiuso; quando lo Switch è chiuso la base del BJT è a 0 Volt quindi il Transistor è interdetto; quando è aperto la base di trova a circa 0.7 Volt e quindi il Transistor conduce;

Nel multivibratore astabile nessuno dei due stati è stabile ed il circuito passa continuamente da uno stato all'altro. Il circuito si comporta pertanto come un particolare oscillatore a rilassamento, in grado di produrre onde quadre.

L'interpretazione dei comportamento elettronico del multivibratore è stata confortata con l'ausilio di altri due semplici schemi, quelli riportati nelle figure 4b e 4c. I quali illustrano, separatamente, le due fasi in cui evolvono i comportamenti elettrici. Ma cominciamo col segnalare il fatto che, qualora i due condensatori elettrolitici C1 e C2 non fossero inseriti nel circuito, i due transistor TR1 e TR2, nell'ipotesi che le resistenze siano ben calcolate, rimarrebbero entrambi accesi, perché le loro basi avrebbero una regolare e precisa polarizzazione, necessaria per la condizione di saturazione dei due semiconduttori. Anche i due diodi led, ovviamente in presenza di alimentazione a 9 V, rimarrebbero sempre accesi. Ma se i due condensatori sono presenti, una tale condizione cessa di esistere. Perché ciascuno di essi trasmette il fronte dell'impulso presente sul collettore di un transistor alla base dell'altro, creando una situazione dinamica. Infatti, il fronte negativo dell'entrata in conduzione di un transistor, valutato dall'alto al basso, essendo applicato alla base dell'altro transistor, non può far altro che costringere questo all'interdizione; si tenga presente che i transistor sono di tipo NPN, montati in circuito ad emettitore comune. Quando si alimenta il circuito del multivibratore per la prima volta, il transistor che va in conduzione per primo esclude contemporaneamente l'altro dal funzionamento e prende così avvio il ciclo. Ma quale dei due transistor è più veloce dell'altro nel cominciare a condurre? La risposta a tale domanda è semplice ed immediata. Quello che beneficia delle inevitabili dissimmetrie circuitali, divenendo più rapido nel funzionamento. Dissimmetrie che possono essere appositamente introdotte nel circuito, per esempio diversificando leggermente i valori capacitivi dei due condensatori elettrolitici.

Esempio Componenti: 2 R da 470 ohm
2 R da 47K
2 C da 22uF
2 T tipo 2n3904
2 Led

quando l'uscita è 0 il condensatore si scarica attraverso la resistenza, l'input diventa 0 e l'Inverter genera 1 sull' uscita, e l'1 va a caricare il condensatore attraverso la resistenza che quindi porta a 1 l'ingresso e si ripete l'oscillazione;

if a binary “1,” represented by 9 volts, is applied to the input, then a “0” (0 volts) is sent to the output. Th at 0 fl ows through the resistor back to the input. When the 0 appears at the input the output goes to 1, which fl ows back to the input and the whole process begins again, causing the circuit to fl ip back and forth between two states, generating a square wave. Th e speed of the fl ip-fl opping (the pitch we hear) depends on the values of the resistor and capacitor—just like in our earlier clock experiments, the smaller the values the higher the pitch. It’s like the Monty Python argument sketch, or a dispute in a bar: I disagree with everything you say, so our output keeps fl ipping between yes and no according to how fast each of us can reply. Th e resistor and capacitor act like booze—the more you add the slower the argument goes, ergo the lower the pitch. Having brushed you off earlier, I will now confi de that the Schmitt Trigger part of the Inverter prevents indecisiveness in the argument: the inverter snaps completely from one state to the other, from 0 to 1 and back, and never vacillates in between.

Il connettore jack, noto anche come spinotto jack o semplicemente jack, è un connettore elettrico usato per trasportare segnali (per lo più audio in forma analogica) in bassissima tensione. È stato inventato nel XIX secolo (1878) per l'uso in centralini telefonici, ed è uno degli standard più vecchi di connettore elettrico ancora in uso





TS mono (Tip, Sleeve = punta e manicotto): per il collegamento audio sbilanciato mono si usano prese, cavi e spine con collegamento TS. Il cablaggio TS è il seguente :

Punta del connettore (Tip): terminale per il canale mono.
Manicotto del connettore (Sleeve): massa.

Diametri standard:
6,3 mm (1/4 di pollice);
3,5 mm (1/8 di pollice);
2,5 mm (3/32 di pollice).

TRS stereo (Tip, Ring, Sleeve = punta, anello e manicotto): per il collegamento audio stereo sbilanciato o bilanciato si usano prese, cavi e spine con collegamento TRS. Il cablaggio del connettore TRS è il seguente :

Punta del connettore (Tip): terminale per il canale sinistro.
Anello del connettore (Ring): terminale per il canale destro.
Manica del connettore (Sleeve): massa.

Diametri standard:
6,3 mm (1/4 di pollice);
3,5 mm (1/8 di pollice);
2,5 mm (3/32 di pollice);

#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