Sei sulla pagina 1di 7

Bytebeats

Questo tutorial è una traduzione e rimaneggiamento di “The absolute beginner’s guide to coding
Bytebeats!” by The Tuesday Night Machines parecchie parti sono state eliminate ed altre appro-
fondite. E’ comunque consigliabile leggere l’originale, scaricabile al seguente link:

https://nightmachines.tv/bytebeats-tutorial

ByteBeats è un linguaggio di programmazione per il livecoding Audio\Grafico estremamente


limitato… e questa è la cosa più interessante!
I risultati spesso sorprendono anche chi sta programmando e fantastici suoni accidentali sono
all’ordine del giorno, quindi un consiglio: copiate spesso il codice che avete scritto e salvatelo in un
file di testo!

Video:
https://www.youtube.com/watch?v=tCRPUv8V22o
https://www.youtube.com/watch?v=V4GfkFbDojc
https://www.youtube.com/watch?v=ETR92uWVs_U

Programmi, ide, app per poter programmare con ByteBeat:


Esistono molte applicazioni via web la migliore è Greggman’s HTML 5 Bytebeat Player:
https://greggman.com/downloads/examples/html5bytebeat/html5bytebeat.html

Per Windows ed OS abbiamo:


Damien Quartz’ Evaluator: https://damikyu.itch.io/evaluator

Per App Apple;


Kymatica’s BitWiz iOS App: http://kymatica.com/Software/BitWiz

Per Android , Windows ed OS:


Single Cell’s Caustic 3: http://www.singlecellsoftware.com/caustic

Poi abbiamo una versione crossplatform attraverso la combo Atom + PureData:


Rampcode: https://github.com/gabochi/rampcode

Esempi di codice:

(t%(t>>8|t>>16))^t
((t<<1)^((t<<1)+(t>>7)&t>>12))|t>>(4-(1^7&(t>>19)))|t>>7
t/.75&t/127%96|t/35
Il suono è prodotto da una unica espressione che andiamo a modificare durante il nostro live, e
in questa espressione abbiamo una sola variabile denominata “t”.
Perché proprio “t”?
t sta per timer, la variabile è un contatore, che inizia da zero alla riproduzione iniziale ed aumenta
di 1 ogni nuovo fotogramma audio alla velocità di 8000 volte al secondo ed aumenterebbe
all’infinito se non fosse che ha a disposizione solo 8 bit quindi 256 possibili valori in uscita ...ora
ricapitoliamo: t è un contatore impostato a 8 Khz con valori che vanno da 0 a 256, cosa succede
quando cerca di superare i valore di 256? si azzera!

Quindi in uscita abbiamo un segnale che parte da 0 aumenta fino ad un suo massimo per tornare a
0 e ricominciare:

E si è proprio una rampa! Una bella forma d’onda a dente di sega!


Ecco qui come con una sola variabile è possibile tirare fuori un bel segnale audio!

La frequenza dell'onda a dente di sega è: 8000 diviso 256, uguale a 31.25 Hz. Quindi "t" è una nota
a 31.25 Hz, essendo la forma d'onda un dente di sega, lo spettro sarà molto complesso e con molte
armoniche, se il vostro sistema audio non scende fino ai 31.25 Hz, e dubito che lo faccia, sentirete
soltanto le armoniche superiori, ma non vi fate ingannare dalle orecchie! la fondamentale è a
31.25 Hz!
Ora abbiamo il nostro segnale audio ( il nostro oscillatore, per chi è abituato ai sintetizzatori
modulari) e possiamo iniziare a modificarlo per renderlo più interessante.

Abbiamo a disposizione i seguenti operatori per agire sulla variabile “t”


- Operatori matematici: () + - * /%
- Operatori bit a bit (binari): & | ^ << >>
- Operatori relazionali: <> <=> = ==! =
In più abbiamo: //
Questa doppia barra indica un "commento", che viene ignorato dal compilatore.
Quindi, qualsiasi carattere in una riga di codice dopo // non influenzerà il risultato del nostro
Bytebeat, il che significa che puoi usare // per estrarre i frammenti di codice, senza doverli
effettivamente eliminare.

Moltiplicando t con un numero (es. t * 12) si aumenta la velocità, aumentando la frequenza del
dente di sega.

Dividendo t per un numero (es. t/2) si rallenta, diminuendo la frequenza del dente di sega. Questo
può andare molto al di sotto della velocità audio, in territorio LFO.

L'aggiunta o la sottrazione di numeri applicherà un offset a t, che di per sé non farà nulla di udibile,
ma spostando la fase della forma d'onda quando si combinano più di un onda si percepirà il loro
sfasamento.

Con -t otterrò l'inversione del nostro dente di sega che diventerà discendente.

Ora un operatore importantissimo: il MODULO %


Il modulo % restituisce il resto dopo una divisione.

Esempio:
4% 4 = 0
5% 4 = 1
6% 4 = 2
7% 4 = 3
8% 4 = 0
9% 4 = 1
10% 4 = 2
11% 4 = 3
12% 4 = 0

Il modulo di qualsiasi cosa divisa per 4, è sempre 0, 1, 2 o 3! È come una piccola onda a dente di
sega!
In generale possiamo dire che data una sequenza di numeri che crescono linearmente avremo
come risultato una sotto sequenza che si ripeterà tra 0 e il valore del risultato del modulo -1 ( x% y
è sempre compreso tra 0 e y-1)

Ad esempio t%128 obbligheremo il segnale ad uscire a metà della sua possibile escursione (128 è
la metà dei 256 valori massimo possibili, ricordate?)
ora prova a sommare due t con diversi moduli esempio:
t% 255 + t% 64
Questo aggiunge due onde t di frequenze e ampiezze diverse, producendo un suono simile al ben
noto effetto "Phaser"

Operatori Binari.

AND & confronta i valori di bit di due numeri binari e restituisce 1 solo se entrambi i bit sono 1.
È come moltiplicare entrambi i bit

esempio:
1111111100 = 1020
& 0010000000 = 128
= 0010000000 = 128
1100001110 = 782
& 0010000000 = 128
= 0000000000 = 0

1011011101 = 733
& 0010000000 = 128
= 0010000000 = 128

1001011010 = 602
& 0010000000 = 128
= 0000000000 = 0

quindi gli unici risultati possibili sono un alternanza di 0 e 128:

Un’ ONDA QUADRA!

Ora abbiamo a disposizione ben due forma d’onda base, quella a dente di sega e quella quadra,
non male per una sola variabile!

OR | confronta i valori di bit di due numeri binari e restituisce 1 se uno o entrambi i bit sono 1.
L’effetto che viene prodotto è che OR | aggiunge più onde a dente di sega di frequenze diverse se
la t successiva è moltiplicata o divisa per un numero. Quasi come con un mixer audio super-lo-fi.

XOR ^ è un "OR esclusivo" che restituisce 1 su bit non corrispondenti, spesso rompe i segnali in
modo significativo.
Gli operatori di BITSHIFT >> e <<:
Tra gli usi che si sono trovati nelle sperimentazioni è quello di poter spostare la frequenza su o giù
di un'ottava.

Operatori Relazionali

Gli operatori relazionali scoprono se una certa relazione tra due numeri è "vera" o "falsa" e
restituisce di conseguenza 1 se vera o 0 se falsa

Esempi:
2> 1 = 1 ("due è maggiore di uno è vero")
2 <1 = 0 ("Due è meno grande di uno è falso")
2 == 1 = 0 ("due è uguale a uno è falso")
2! = 1 = 0 ("due non è uguale a uno è vero ")
2> = 2 = 1 (" due è maggiore o uguale a due è vero ")
2 <= 2 = 0 (" due è maggiore o uguale a due è vero " )

Possiamo usare gli operatori relazionali per creare interruttori on / off nel nostro codice, che
portano Bytebeat ad un livello superiore.

Programmare uno Step Sequencer:

Costruiamo un sequencer tradizionale a 16 step, che esegue in loop sedici suoni o silenzi:

Per fare questo abbiamo bisogno di un contatore che indica le diverse posizioni degli step nella
nostra sequenza.
Usiamo operatore modulo%
t%16
In questo caso, il risultato genererà valori compresi tra 0 e 15, cioè 16 passi.

Ovviamente, alla frequenza di campionamento di 8 kHz quei 16 passaggi saranno troppo brevi,
quindi facciamoli più lunghi:
t% 16000

Ora ognuno dei nostri 16 passi è composto da 1.000 "fotogrammi" audio lunghi 1/8 di secondo.

Successivamente, dobbiamo definire i passaggi effettivi:


Il passaggio 1 dovrebbe durare da 0 a 999
Passaggio 2 da 1.000 a 1.999
Passaggio 3 da 2.000 a 2.999
...
Passaggio 15 da 14.000 a 14.999
Passaggio 16 da 15.000 a 15.999
Aggiungiamo gli operatori relazionali:
(t% 16000> = 0 & t% 16000 <1000)

Il codice sopra restituirà 1 (vero) purché ...


... il contatore di passi t% 16000 è maggiore (>) o uguale (=) a 0
e (AND)
... il contatore di passi è inferiore (<) a 1000

Quindi da 0 a 999, questo produrrà 1 (vero).


Naturalmente, questo di per sé non farà un suono, ma possiamo moltiplicare il risultato (vero o
falso, 1 o 0) con il vecchio e fidato t:
(t% 16000> = 0 & t% 16000 <1000) * t

Prova la riga sopra nel tuo lettore Bytebeat e poi aggiungi una seconda linea con OR | per lo step
2, dal 1000 al 1999, ad esempio una nota, come t * 3:
| (t% 16000> = 1000 & t% 16000 <2000) * t * 3

... e quindi aggiungere più linee, per i restanti 14 passaggi nella nostra sequenza (un bel t*0 per la
pausa)

Modulazione di larghezza di impulso (o PWM, pulse-width modulation), è un tipo di modulazione


digitale che permette di ottenere una tensione media variabile dipendente dal rapporto tra la du-
rata dell'impulso positivo e di quello negativo (duty cycle) [Wikipedia]

Vediamo come possiamo implementare questa forma d’onda nel nostro Bytebeat. Per prima cosa,
dobbiamo scrivere un’espressione che ci restituisce una forma d’onda quadrata con il controllo sul
tempo in cui l'onda è alta o bassa.
(t%100 >= 50)*255

C'è un contatore t% 100, che conta da 0 a 99. Controlliamo quindi se il suo output è uguale o mag-
giore di 50. Se questo è vero, otteniamo 1, che moltiplichiamo per l'ampiezza (o "volume") che vo-
gliamo che l'onda quadra abbia, qualcosa tra 0 (silenzio) e 255 (volume massimo). Il codice sopra ci
fornisce un'onda quadrata a larghezza di impulso del 50%, a volume pieno. Per modificare la lar-
ghezza dell'impulso, dobbiamo cambiare il 50 in qualcos'altro, tra 0 e 100. Provalo!

Se vogliamo una variazione nel tempo del duty cycle:


(t%100 >= t/200%100 )*255
In questo caso invece id dare un valore fisso si è inserito un altro contatore che lavora ad una
velocità non dello spettro audio ma molto più lento usato solamente come segnale di controllo.

Forma d’onda TRIANGOLARE:

Sappiamo che t fornisce un dente di sega ascendente e –t un'inversione della stessa, cioè un dente
di sega discendente. Se passassimo da t a -t dopo ogni ciclo, otterremmo un'onda triangolare!
Quanto è lungo un ciclo della nostra forma d’onda a dente di sega? 256, perché dopo, l'output si
azzera ed inizia un nuovo dente di sega. Quindi abbiamo bisogno di passare tra le due forme
d'onda ogni 256 frame audio.

t * (t%512 >= 256)


|
-t * (t%512 < 256)

Finché t% 512 è uguale o maggiore di 256, la forma d’onda è data da t quando t% 512 è minore di
256, la forma d’onda è data da -t. Questo si alternerà tra il dente di sega ascendente e discendente.

Purtroppo la forma d’onda così creata ha un problema: nel momento in cui si passa da una forma
d’onda all’altra (da ascendente a discendente) la seconda dente di sega parte sempre e comunque
da 0 anche se passa subito dopo al suo valore massimo. Aggiungendo un -1 a – t si ottiene un
piccolo spostamento, o sfasamento tra le onde, così che, nel passaggio, –t assume 255 e non 0.

Traduzione, adattamento, campionamento by RudeCode

http://rudecode.altervista.org
27.06.19

Potrebbero piacerti anche