Sonic Pi - en to pt-BR translation catalogue (488 entries)

en: 1 Welcome to Sonic Pi
pt-BR: Bem vindo ao Sonic Pi

en: Welcome friend :-)
pt-BR: Bem vindo amigo :-)

en: Welcome to Sonic Pi. Hopefully you're as excited to get started making crazy sounds as I am to show you. It's going to be a really *fun* ride where you'll learn all about music, synthesis, programming, composition, performance and more.
pt-BR: Bem vindo ao Sonic Pi. Espero que você esteja tão animado para começar a fazer sons malucos quanto eu estou para te mostrá-los. Isso vai ser um passeio realmente legal onde você irá aprender tudo sobre música, síntese, programação, composição, performance e mais.

en: If you have any thoughts, or ideas for improving Sonic Pi - please pass them on - feedback is so helpful. You never know, your idea might be the next big feature!
pt-BR: Se tiver algum plano ou ideias para melhorar o Sonic Pi - por favor nos diga - feedback sempre ajuda. Nunca se sabe, sua ideia pode se tornar uma grande nova função!

en: This tutorial is divided up into sections grouped by category. Whilst I've written it to have an easy learning progression from start to finish, feel very free just to dip in and out of sections as you see fit. If you feel that there's something missing, do let me know and I'll consider it for a future version.
pt-BR: Este tutorial é dividido em duas seções agrupadas por categorias. Escrevi isto para que se tenha uma fácil aprendizagem do início ao fim, sinta-se à vontade para acessar as seções que você se encaixa. Se sentir que algo está faltando, deixe-me saber e vou considerar isto para uma versão futura.

en: OK, let's get started...
pt-BR: OK, então vamos começar...

en: 1.1 Live Coding
pt-BR: 1.1 Programação ao vivo

en: Live Coding
pt-BR: Programação ao vivo

en: One of the most exciting aspects of Sonic Pi is that it enables you to write and *modify code live* to make music, just like you might perform live with a guitar. This means that given some practice you can take Sonic Pi on stage and gig with it.
pt-BR: Um dos aspectos mais excitantes de Sonic Pi, é a possibilidade de modificar a programação "ao vivo" para fazer música, assim como você toca uma guitarra. Isso significa, que com alguma prática você pode levar o Sonic Pi ao palco e apresentar-se.

en: Free your mind
pt-BR: Liberte sua mente

en: Before we get into the real details of how Sonic Pi works in the rest of this tutorial, I'd like to give you an experience of what it's like to live code. Don't worry if you don't understand much (or any) of this. Just try to hold onto your seats and enjoy...
pt-BR: Antes de nós entrarmos em detalhes reais de como o Sonic Pi funciona no resto desse tutorial, eu gostaria de te dar uma experiência de como é programar ao vivo. Não se preocupe se você não entender muito (ou nada) do que verá. Só aperte os cintos e curta...

en: A live loop
pt-BR: Repetição ao vivo

en: Now, press the `Run` button and you'll hear a nice fast bass drum beating away. If at any time you wish to stop the sound just hit the `Stop` button. Although don't hit it just yet... Instead, follow these steps:
pt-BR: Agora pressiona o botão `Rodar ` e você ouvirá uma rápida batida de bateria tocando. Se a qualquer momento você quiser parar o som, basta pressionar o botão `Parar`. Mas calma, não pressione o botão ainda... Ao invés disso, siga os passos a segui:

en: Make sure the bass drum sound is still running
pt-BR: Tenha certeza de que o bumbo continua rodando

en: Change the `sleep` value from `0.5` to something higher like `1`.
pt-BR: Altere o valor `dormir` para `0.5` para algo acima de `1`.

en: Press the `Run` button again
pt-BR: Pressione o botão `Rodar` novamente

en: Notice how the drum speed has changed.
pt-BR: Note como a velocidade da batida foi alterada.

en: Finally, *remember this moment*, this is the first time you've live coded with Sonic Pi and it's unlikely to be your last...
pt-BR: Finalmente, *lembre deste momento*, essa é a primeira vez que você programou ao vivo com Sonic Pi e provavelmente não será a última vez...

en: Ok, that was simple enough. Let's add something else into the mix. Above `sample :bd_haus` add the line `sample :ambi_choir, rate: 0.3`. Your code should look like this:
pt-BR: Ok, isso foi bem simples. Vamos adicionar alguma outra coisa na mistura. Sobre `sample :bd_haus` adicione a linha `sample: ambi_choir, rate: 0,3`. Seu código deve estar assim agora:

en: Now, play around. Change the rates - what happens when you use high values, or small values or negative values? See what happens when you change the `rate:` value for the `:ambi_choir` sample just slightly (say to `0.29`). What happens if you choose a really small `sleep` value? See if you can make it go so fast your computer will stop with an error because it can't keep up (if that happens, just choose a bigger `sleep` time and hit `Run` again).
pt-BR: Agora brinque um pouco. Altere os valores - o que acontece quando você usa valores maiores, ou valores menores ou negativos? Veja o que acontece quando você altera o valor `rate:` para o sample `:ambi_choir` apenas um pouco (digamos, para `0.29`). O que acontece se escolher um valor bem pequeno para `sleep`? Veja se você pode fazer isso ficar tão rápido que seu computador irá parar com um erro porque ele não consegue acompanhar (se isso acontecer, apenas selecione um tempo maior pra `sleep` e pressione `Rodar` novamente).

en: Try commenting one of the `sample` lines out by adding a `#` to the beginning:
pt-BR: Tente comentar uma das linhas de `sample` adicionando `#` no começo:

en: Notice how it tells the computer to ignore it, so we don't hear it. This is called a comment. In Sonic Pi we can use comments to remove and add things into the mix.
pt-BR: Note como ele diz ao computador para ignorar essa linha, você não consegue ouvi-lá. Isto é chamado comentário. Em Sonic Pi você pode usar comentários para remover e adicionar coisas na mixagem.

en: Finally, let me leave you something fun to play with. Take the code below, and copy it into a spare buffer. Now, don't try to understand it too much other than see that there are two loops - so two things going round at the same time. Now, do what you do best - experiment and play around. Here are some suggestions:
pt-BR: Finalmente, vou deixar você com algo divertido para brincar. Pegue o código abaixo, e copie ele num buffer disponível. Agora, não tente entender isto além de perceber que nele há dois loops - então são duas coisas rodando ao mesmo tempo. Agora, faça aquilo que você faz de melhor - experimente e comece a brincar. Aqui vão algumas sugestões:

en: Try changing the blue `rate:` values to hear the sample sound change.
pt-BR: Tente alterar os valores azuis de `rate:` para ouvir a amostra de som mudar.

en: Try changing the `sleep` times and hear that both loops can spin round at different rates.
pt-BR: Tente mudar os tempos `sleep` e escutar que ambos loops podem rodar em taxas diferentes.

en: Try uncommenting the sample line (remove the `#`) and enjoy the sound of the guitar played backwards.
pt-BR: Tente descomentar a linha de exemplo (remova o `#`) e aprecie o som da guitarra tocada ao contrário.

en: Try changing any of the blue `mix:` values to numbers between `0` (not in the mix) and `1` (fully in the mix).
pt-BR: Tente trocar qualquer valor do `mix:` azul para números entre `0` (não na mixagem) e `1` (totalmente na mixagem).

en: Remember to press `Run` and you'll hear the change next time the loop goes round. If you end up in a pickle, don't worry - hit `Stop`, delete the code in the buffer and paste a fresh copy in and you're ready to jam again. Making mistakes is how you'll learn the quickest...
pt-BR: Lembre-se de apertar `Run` e você irá ouvir a mudança na próxima vez que o loop rodar. Se você acabar num aperto, não se preocupe - aperte `Stop`, delete o código no buffer e cole uma cópia nova em folha e você estará pronto para tocar novamente. Fazer erros é a forma mais rápida de aprender...

en: Now, keep playing and experimenting until your curiosity about how this all actually works kicks in and you start wondering what else you can do with this. You're now ready to read the rest of the tutorial.
pt-BR: Agora,continue tocando e experimentando até que sua curiosidade sobre como tudo isso realmente surja e você comece a se perguntar oque mais você pode fazer com isso. Agora você está pronto para o resto do tutorial.

en: So what are you waiting for...
pt-BR: Então oque você está esperando...

en: 1.2 Exploring the Interface
pt-BR: 1.2 Explorando a Interface

en: The Sonic Pi Interface
pt-BR: A Interface de Sonic Pi

en: Sonic Pi has a very simple interface for coding music. Let's spend a little time exploring it.
pt-BR: Sonic Pi tem uma interface muito simples para codificar música. Vamos passar um tempinho explorando-a.

en: *A* - Play Controls
pt-BR: *A* - Controles de Reprodução

en: *B* - Editor Controls
pt-BR: *B* - Controles de Edição

en: *C* - Info and Help
pt-BR: *C* - Ajuda e Informação

en: *D* - Code Editor
pt-BR: *D* - Editor de Código

en: *E* - Prefs Panel
pt-BR: *E* - Painel de Preferências

en: *F* - Log Viewer
pt-BR: *F* - Visualizador de Log

en: *G* - Help System
pt-BR: *G* - Sistema de Ajuda

en: *H* - Scope Viewer
pt-BR: *H* - Visualizador de Escopo

en: A. Play Controls
pt-BR: Controles

en: These pink buttons are the main controls for starting and stopping sounds. There's the *Run* button for running the code in the editor, *Stop* for stopping all running code, *Save* for saving the code to an external file and *Record* to create a recording (a WAV file) of the sound playing.
pt-BR: Esses botões rosas são os controles principais para inciar e finalizar sons. Há um botão *Run* para executar o código no editor, *Stop* para parar todo o código que está sendo executado, *Save* para salvar todo o código para um arquivo externo e *Record* para criar uma gravação (um arquivo WAV) do som que está tocando.

en: B. Editor Controls
pt-BR: B. Controles do Editor

en: C. Info and Help
pt-BR: C. Ajuda e Informação

en: These blue buttons give you access to information, help and preferences. The *Info* button will open up the information window which contains information about Sonic Pi itself - the core team, history, contributors and community. The *Help* button toggles the help system (*G*) and the *Prefs* button toggles the preferences window which allows you to control some basic system parameters.
pt-BR: Esses botões azuis te dão acesso à informação, ajuda e preferências. O botão *Info* irá abrir a janela de informações na qual contém informação sobre o Sonic Pi - o time fonte, histórico, contribuidores e comunidade. O botão *Help* ativa o sistema de ajuda (*G*) e o botão *Prefs* ativa a janela de preferências na qual te permite controlar alguns parâmetros básicos do sistema.

en: D. Code Editor
pt-BR: D. Editor de Código

en: This is the area where you'll write your code and compose/perform music. It's a simple text editor where you can write code, delete it, cut and paste, etc. Think of it like a very basic version of Word or Google Docs. The editor will automatically colour words based on their meaning in the code. This may seem strange at first, but you'll soon find it very useful. For example, you'll know something is a number because it is blue.
pt-BR: Essa é a área em que você vai escrever seu código e compor/fazer música. É um simples editor de texto onde você pode escrever código,deleta-lo,recortar e colar, etc. Pense nele como uma versão muito básica do Word ou Google Docs. O editor vai colorir automaticamente as palavras baseado no seu significado no código. Isso parece estranho de primeira, mas logo você vai achar muito útil.Por exemplo, você saberá que algo é um número por que é azul.

en: E. Prefs Panel
pt-BR: E. Painel de Preferências

en: Sonic Pi supports a number of tweakable preferences which can be accessed by toggling the *prefs* button in the Info and Help button set. This will toggle the visibility of the Prefs Panel which includes a number of options to be changed. Examples are forcing mono mode, inverting stereo, toggling log output verbosity and also a volume slider and audio selector on the Raspberry Pi.
pt-BR: O Sonic Pi suporta várias preferências ajustáveis que podem ser acessadas alternando o botão *prefs* no conjunto de botões Informações e Ajuda. Isto irá alternara a visibilidade do Painel de Preferências que inclui várias opções que podem ser alteradas. Exemplos: forçar o modo mono, inverter stereo, alternar a verbosidade do log de saída e também um slider de volume e um seletor de áudio no Raspberry Pi.

en: F. Log Viewer
pt-BR: F. Visualizador de logs

en: When you run your code, information about what the program is doing will be displayed in the log viewer. By default, you'll see a message for every sound you create with the exact time the sound was triggered. This is very useful for debugging your code and understanding what your code is doing.
pt-BR: Quando você executa seu código, informações sobre o que o programa está fazendo serão exibidas no Visualizador do Log. Por padrão, você verá uma mensagem para cada som que você criou com o tempo exato em que o som foi disparado. Isto é muito útil para depurar seu código e entender o que seu código está fazendo.

en: G. Help System
pt-BR: G. Sistema de Ajuda

en: One of the most important parts of the Sonic Pi interface is the help system which appears at the bottom of the window. This can be toggled on and off by clicking on the blue *Help* button. The help system contains help and information about all aspects of Sonic Pi including this tutorial, a list of available synths, samples, examples, FX and a full list of all the functions Sonic Pi provides for coding music.
pt-BR: Uma das partes mais importantes da interface do Sonic Pi é o sistema de ajuda que aparece na parte de baixo da janela. Ela pode ser ligada e desligada clicando no botão azul *Help*. O sistema de ajuda contem ajuda e informações sobre todos os aspectos do Sonic Pi, incluindo este tutorial, uma lista de sintetizadores, samples, exemplos, efeitos e uma lista com todas as funções que o Sonic Pi oferece para programar música.

en: H. Scope Viewer
pt-BR: H. Visualizador de Onda

en: The scope viewer allows you to see the sound you're hearing. You can easily see that the saw wave looks like a saw and that the basic beep is a curvey sine wave. You can also see the difference between loud and quiet sounds by the size of the lines. There are 3 scopes to play with - the default is a combined scope for the left and right channels, there is a stereo scope which draws a separate scope for each channel. Finally there is a Lissajous curve scope which will show the phase relationship between the left and right channels and allows you to draw pretty pictures with sound (https://en.wikipedia.org/wiki/Lissajous_curve).
pt-BR: The visualizador de ondas permite que você veja o som que você está ouvindo. Você pode facilmente ver que a onda dente de serra parece com uma serra e que que o bip básico é uma curva senoidal. Você também pode ver a diferença entre sons intensos e calmos através dos tamanhos das linhas. Há 3 visualizações para trabalhar - a padrão mostra uma onda que combina os canais esquerdo e direito, há uma visualização stereo que mostra uma onda para cada canal. Finalmente há um visualizador de Curva de Lissajous que irá mostrar a relação de fase entre os canais esquerdo e direito e permite que você desenhe imagens bonitas com o som (https://pt.wikipedia.org/wiki/Curvas_de_Lissajous).

en: 1.3 Learning through Play
pt-BR: 1.3 Aprenda tocando

en: Learning through Play
pt-BR: Aprenda tocando

en: Sonic Pi encourages you to learn about both computing and music through play and experimentation. The most important thing is that you're having fun, and before you know it you'll have accidentally learned how to code, compose and perform.
pt-BR: O Sonic Pi te incentiva a aprender tanto sobre computação quanto sobre música através da ação de tocar e da experimentação. A coisa mais importante é que você esteja se divertindo e, antes que você perceba, você terá aprendido acidentalmente como programar, compor e tocar.

en: There are no mistakes
pt-BR: Não existem erros

en: Start Simple
pt-BR: Comece de forma simples

en: When you're learning, it's tempting to want to do amazing things *now*. However, just hold that thought and see it as a distant goal to reach *later*. For now, instead think of the *simplest* thing you could write which would be fun and rewarding that's a small step towards the amazing thing you have in your head. Once you have an idea about that simple step, then try and build it, play with it and then see what new ideas it gives you. Before long you'll be too busy having fun and making real progress.
pt-BR: Quando vocÊ está aprendendo, é tentador querer fazer coisas incríveis *imediatamente*. Porém, mantenha esse pensamento como um objetivo para ser alcançado *mais tarde*. Por enquanto, pense na coisa *mais simples* que você possa escrever que possa ser divertida e recompensadora. Este será o pequeno passo na direção das coisas incríveis que você tem na sua mente. Uma vez que você tenha uma ideia sobre este passo simples, tente e construa-o, brinque com ele e então veja que novas ideias isso te deu. Antes do que você perceba você estará ocupado se divertindo e fazendo progresso real.

en: Just make sure to share your work with others!
pt-BR: Certifique-se de compartilhar seu trabalho com os outros!

en: 2 Synths
pt-BR: 2 Sintetizadores

en: Synths
pt-BR: Sintetizadores

en: OK, enough of the intros - let's get into some sound.
pt-BR: OK, chega de introduções - vamos fazer alguns sons.

en: In this section we'll cover the basics of triggering and manipulating synths. Synth is short for synthesiser which is a fancy word for something which creates sounds. Typically synths are quite complicated to use - especially analog synths such as Eurorack modules connected together by a mess of wires. However, Sonic Pi gives you much of that power in a very simple and approachable manner.
pt-BR: Nesta seção cobriremos a base de disparar e manipular sintetizadores. *Synth* é uma abreviatura para sintetizador, que é uma palavra chique para algo que sintetiza (cria) sons. Tipicamente os sintetizadores são bastante complicados de usar - especialmente sintetizadores analógicos como módulos Eurorack interconectados por uma bagunça de fios. No entanto, o Sonic Pi te dá grande parte deste poder de uma forma muito simples e acessível.

en: Don't be fooled by the immediate simplicity of Sonic Pi's interface. You can get very deep into very sophisticated sound manipulation if that's your thing. Hold on to your hats...
pt-BR: Não se engane pela simplicidade imediata da interface do Sonic Pi. Você pode ir bem fundo na manipulação sofisticada de sons, se for este seu objetivo. Agora, segure-se...

en: 2.1 Your First Beeps
pt-BR: 2.1 Seus primeiros Beeps

en: Your First Beeps
pt-BR: Seus Primeiros Beeps

en: Take a look at the following code:
pt-BR: Veja o código a seguir:

en: This is where it all starts. Go ahead, copy and paste it into the code window at the top of the app (the big white space under the Run button). Now, press Run...
pt-BR: É aqui que tudo começa. Vá em frente, copie e cole este código no editor (o grande espaço em branco abaixo do botão *Run*). Agora pressione *Run*...

en: Beep!
pt-BR: Bip!

en: Intense. Press it again. And again. *And again...*
pt-BR: Intenso. Pressione outra vez. E outra vez. *E outra vez*

en: Woah, crazy, I'm sure you could keep doing that all day. But wait, before you lose yourself in an infinite stream of beeps, try changing the number:
pt-BR: Wow, doido, eu tenho certeza de que você poderia fazer isso o dia todo. Mas espere, antes de se perder em uma corrente infinita de bips, tente modificar o número:

en: Can you hear the difference? Try a lower number:
pt-BR: Consegue notar a diferença? Tente outro número:

en: *Don't worry* if this means nothing to you - it didn't to me when I first started. All that matters right now is that you know that *low numbers make lower beeps* and *high numbers make higher beeps*.
pt-BR: *Não se preocupe* se isso não significa nada pra você - Não significava para mim quando eu comecei. Tudo o que importa agora é que você saiba que *números baixos criam bips graves* e *números altos criam bips mais agudos*.

en: Chords
pt-BR: Acordes

en: Playing a note is quite fun, but playing many at the same time can be even better. Try it:
pt-BR: Tocar uma nota pode  ser divertido, mas tocar várias ao mesmo tempo pode ser ainda melhor. Tente:

en: Jazzy! So, when you write multiple `play`s, they all play at the same time. Try it for yourself - which numbers sound good together? Which sound terrible? Experiment, explore and find out for yourself.
pt-BR: *Jazzy!* Quando você escreve múltiplos `play`s, ele tocam todos ao mesmo tempo. Tente você mesmo - quais números soam bem juntos? Quais soam terríveis? Experimente, explore e encontre você mesmo.

en: Melody
pt-BR: Melodia

en: So, playing notes and chords is fun - but how about a melody? What if you wanted to play one note after another and not at the same time? Well, that's easy, you just need to `sleep` between the notes:
pt-BR: Tocar notas e acorde é divertido - mas e quanto uma melodia? E se você quiser tocar uma nota após a outra e não ao mesmo tempo? Bom, isso é fácil, você só precisa usar `sleep` (dormir/esperar) entre as notas:

en: How lovely, a little arpeggio. So what does the `1` mean in `sleep 1`? Well it means the *duration of the sleep*. It actually means sleep for one beat, but for now we can think about it as sleeping for 1 second. So, what if we wanted to make our arpeggio a little faster? Well, we need to use shorter sleep values. What about a half i.e. `0.5`:
pt-BR: Que belo arpejo. Mas o que o `1` significa em `sleep 1`? Bom, significa a *duração da espera (sleep)*. Na realidade, significa *espere durante uma batida*, mas por enquanto vamos considerar como aguardar por 1 segundo. E se nós desejarmos tocar nosso arpejo um pouco mais rápido? Nós precisamos usar valores de espera menores. Que tal a metade? Isto é: `0.5`:

en: Notice how it plays faster. Now, try for yourself, change the times - use different times and notes.
pt-BR: Note como toca mais rápido. Agora tente você mesmo, mude os valores - use tempos e notas diferentes.

en: One thing to try is in-between notes such as `play 52.3` and `play 52.63`. There's absolutely no need to stick to standard whole notes. Play around and have fun.
pt-BR: Uma coisa que você pode tentar são notas 'intermediárias', como `play 52.3` e `play 52.63`. Não há absolutamente necessidade alguma para nos fixarmos às notas padrão. Toque e divirta-se.

en: Traditional Note Names
pt-BR: Nomes tradicionais das notas

en: For those of you that already know some musical notation (don't worry if you don't - you don't need it to have fun) you might want to write a melody using note names such as C and F# rather than numbers. Sonic Pi has you covered. You can do the following:
pt-BR: Para aqueles que já conhecem um pouco de notação musical (não se preocupe se você não souber - isso não é necessário para se divertir) você pode querer escrever uma melodia usando nomes das notas como C e F# (notação inglesa) em vez de números. O Sonic Pi entende isso. Você pode fazer o seguinte:

en: play :C
    sleep 0.5
    play :D
    sleep 0.5
    play :E
pt-BR: # Notação Inglesa: C=Dó; D=Ré; E=Mi; F=Fá; G=Sol; A=Lá; B=Si  
    play :C
    sleep 0.5
    play :D
    sleep 0.5
    play :E

en: Remember to put the colon `:` in front of your note name so that it goes pink. Also, you can specify the octave by adding a number after the note name:
pt-BR: Lembre-se de colocar os dois-pontos `:` antes do nome de cada nota, para que ela fique cor-de-rosa (indicando que foi reconhecida). Você também pode especificar a oitava, adicionando um número após o nome de nota:

en: play :C3
    sleep 0.5
    play :D3
    sleep 0.5
    play :E4
pt-BR: # :C3 = Dó na terceira oitava; :E4 = Mi na quarta oitava...
    play :C3
    sleep 0.5
    play :D3
    sleep 0.5
    play :E4

en: If you want to make a note sharp, add an `s` after the note name such as `play :Fs3` and if you want to make a note flat, add a `b` such as `play :Eb3`.
pt-BR: Se quiser transformar uma nota em sustenido, adicione um `s` após o nome da nota, como em `play :Fs3`. Se você quiser transformar a nota em bemol, adicione um `b` como em `play :Eb3`.

en: Now go *crazy* and have fun making your own tunes.
pt-BR: Agora *pire* e divirta-se criando suas próprias melodias.

en: 2.2 Synth Options
pt-BR: 2.2 Opções de Sintetizador

en: Synth Options: Amp and Pan
pt-BR: Opções de Sintetizador: Amp (amplitude) and Pan (panorâmica)

en: As well as allowing you to control which note to play or which sample to trigger, Sonic Pi provides a whole range of options to craft and control the sounds. We'll be covering many of these in this tutorial and there's extensive documentation for each in the help system. However, for now we'll introduce two of the most useful: *amplitude* and *pan*. First, let's look at what options actually are.
pt-BR: Da mesma forma que te permite controlar qual nota tocar ou qual amostra disparar, o Sonic Pi fornece uma gama de opções para trabalhar e controlar os sons. Nós cobriremos muitas delas neste tutorial e há uma documentação extensa para cada um delas no sistema de ajuda. Entretanto, por hora vamos introduzir duas das mais úteis: *amplitude* e *pan*. Mas vamos ver primeiro o que realmente são 'opções'.

en: Options
pt-BR: Opções

en: Sonic Pi supports the notion of options (or opts for short) for its synths. Opts are controls you pass to `play` which modify and control aspects of the sound you hear. Each synth has its own set of opts for finely tuning its sound. However, there are common sets of opts shared by many sounds such as `amp:` and envelope opts (covered in another section).
pt-BR: O Sonic Pi suporta a notação de opções (ou opts, abreviando) para seus sintetizadores. Opções são controles você passa ao comando `play` que modificam e controlam aspectos do som que você ouve. Cada sintetizador tem seu próprio conjunto de opções para um ajuste fino do som. No entanto, existem algumas opções comuns compartilhadas por vários synths, tais como `amp:` e opções de *envelope* (cobertas em outra seção).

en: Opts have two major parts, their name (the name of the control) and their value (the value you want to set the control at). For example, you might have a opt called `cheese:` and want to set it with a value of `1`.
pt-BR: As opções possuem duas partes principais, seu nome (o nome do controle) e seu valor (o valor que você quer dar a este controle). Por exemplo, você pode ter uma opção chamada `queijo:` e quer dar a ela o valor `1`.

en: Opts are passed to calls to `play` by using a comma `,` and then the name of the opt such as `amp:` (don't forget the colon `:`) and then a space and the value of the opt. For example:
pt-BR: As opções são passadas ao comando `play` através do uso da vírgula `,` seguida do nome da opção `amp:` (não esqueça dos dois-pontos `:`) e então um espaço seguido do valor da opção. Por exemplo:

en: play 50, cheese: 1
pt-BR: play 50, queijo: 1

en: (Note that `cheese:` isn't a valid opt, we're just using it as an example).
pt-BR: (Note que `queijo:` não é uma opção válida, nós só estamos usando como exemplo).

en: You can pass multiple opts by separating them with a comma:
pt-BR: Você pode passar múltiplas opções, separando-as com vírgulas:

en: play 50, cheese: 1, beans: 0.5
pt-BR: play 50, queijo: 1, feijões: 0.5

en: The order of the opts doesn't matter, so the following is identical:
pt-BR: A ordem das opções não importa, então estes casos são idênticos:

en: play 50, beans: 0.5, cheese: 1
pt-BR: play 50, feijões: 0.5, queijo: 1

en: Opts that aren't recognised by the synth are just ignored (like `cheese` and `beans` which are clearly ridiculous opt names!)
pt-BR: Opções que não forem reconhecidas pelo sintetizador serão simplesmente ignoradas (como `queijo` e `feijões`, que são claramente nomes de opções ridículos!)

en: If you accidentally use the same opt twice with different values, the last one wins. For example, `beans:` here will have the value 2 rather than 0.5:
pt-BR: Se, por acidente, você usar a mesma opção duas vezes com valores diferentes, a segunda vence. Por exemplo, `beans:` aqui você terá o valor 2 em vez de 0.5:

en: play 50, beans: 0.5, cheese: 3, eggs: 0.1, beans: 2
pt-BR: play 50, feijões: 0.5, queijo: 3, ovos: 0.1, feijões: 2

en: Many things in Sonic Pi accept opts, so just spend a little time learning how to use them and you'll be set! Let's play with our first opt: `amp:`.
pt-BR: Muitas coisas no Sonic Pi aceitam opções, então gaste um pouco de tempo aprendendo como usá-las e você estará pronto! Vamos brincar com a nossa primeira opção: `amp:`.

en: Amplitude is a computer representation of the loudness of a sound. A *high amplitude produces a loud sound* and a *low amplitude produces a quiet sound*. Just as Sonic Pi uses numbers to represent time and notes, it uses numbers to represent amplitude. An amplitude of 0 is silent (you'll hear nothing) whereas an amplitude of 1 is normal volume. You can even crank up the amplitude higher to 2, 10, 100. However, you should note that when the overall amplitude of all the sounds gets too high, Sonic Pi uses what's called a compressor to squash them all to make sure things aren't too loud for your ears. This can often make the sound muddy and strange. So try to use low amplitudes, i.e. in the range 0 to 0.5 to avoid compression.
pt-BR: Amplitude é uma representação do volume de um som. Uma *grande amplitude produz um som barulhento* e uma *baixa amplitude produz um som quieto*. Da mesma forma que o Sonic Pi usa números para representar tempos e notas, ele usa números para representar amplitudes. Uma amplitude 0 é silêncio (você não ouvirá nada) enquanto uma amplitude igual a 1 é o volume normal. Você pode até estourar a amplitude para valores 2, 10, 100. Entretanto você deve notar que quando a amplitude geral, de todos os sons, fica muito alta, o Sonic Pi usa o que é chamado de compressor para espremer as amplitudes e garantir que as coisas não fiquem muito altas para seus ouvidos. Isto pode muitas vezes fazer o som ficar embolado e estranho. Então tente usar amplitudes baixas, isto é: na faixa entre 0 e 1 para evitar compressão.

en: Amp it up
pt-BR: Amplificando

en: To change the amplitude of a sound, you can use the `amp:` opt. For example, to play at half amplitude pass 0.5:
pt-BR: Para mudar a amplitude de um som, você pode usar a opção `amp:`. Por exemplo, para tocar com a metade da amplitude passe o valor `0.5`:

en: To play at double amplitude pass 2:
pt-BR: Para tocar com o dobro da amplitude, passe 2:

en: The `amp:` opt only modifies the call to `play` it's associated with. So, in this example, the first call to play is at half volume and the second is back to the default (1):
pt-BR: A opção `amp:` somente modifica a chamada para o `play`ao qual está associada. Então, neste exemplo, a primeira chamada toca a nota com a metade do volume e na segunda o volume volta para o padrão (1):

en: Of course, you can use different `amp:` values for each call to play:
pt-BR: Sendo assim, você pode usar valores diferentes de `amp:` em cada comando `play`:

en: Panning
pt-BR: Controlando o Pan

en: Another fun opt to use is `pan:` which controls the panning of a sound in stereo. Panning a sound to the left means that you hear it out of the left speaker, and panning it to the right means you hear it out of your right speaker. For our values, we use a -1 to represent fully left, 0 to represent center and 1 to represent fully right in the stereo field. Of course, we're free to use any value between -1 and 1 to control the exact positioning of our sound.
pt-BR: Outra opção divertida para usar é  `pan:` que controla o som estéreo de lado-a-lado. Virar o som para a esquerda (pan left), significa que você ouvirá o som no alto-falante esquerdo, e virando para a direita (pan right), significa que você ouvirá o som no alto-falante direito. Usamos -1 para representar totalmente à esquerda, 0 para representar o centro e 1 para representar totalmente à direita, no campo estéreo. Sinta-se livre para usar qualquer valor entre -1 e 1 para controlar a posição exata do seu som.

en: Let's play a beep out of the left speaker:
pt-BR: Vamos tocar um bip no alto-falante esquerdo:

en: Now, let's play it out of the right speaker:
pt-BR: Agora vamos tocá-lo no alto-falante direito:

en: Finally let's play it back out of the center of both (the default position):
pt-BR: Finalmente, vamos tocá-lo de volta no centro (a posição padrão):

en: Now, go and have fun changing the amplitude and panning of your sounds!
pt-BR: Agora, vá e divirta-se mudando a amplitude e a posição dos seus sons!

en: 2.3 Switching Synths
pt-BR: 2.3 Trocando Sintetizadores

en: Switching Synths
pt-BR: Trocando Sintetizadores

en: Buzzy saws and prophets
pt-BR: Buzzy saws (dentes de serra ruidosas) e prophets (um sintetizador da Roland)

en: A fun sound is the *saw wave* - let's give it a try:
pt-BR: Um som divertido é a *onda dentes de serra* - vamos experimentá-lo:

en: Let's try another sound - the *prophet*:
pt-BR: Vamos experimentar outro som - o *prophet*:

en: How about combining two sounds. First one after another:
pt-BR: Que tal combinarmos os dois sons. Primeiro um seguido do outro:

en: Notice that the `use_synth` command only affects the following calls to `play`. Think of it like a *big switch* - new calls to `play` will play whatever synth it's currently pointing to. You can move the switch to a new synth with `use_synth`.
pt-BR: Note que o comando `use_synth`só afeta as próximas chamadas de `play`. Pense nele como um *grande interruptor* - novas chamadas de `play` irão tocar o sintetizador que tenha esteja selecionado no momento. Você pode trocar para um novo sintetizador com `use_synth`.

en: Discovering Synths
pt-BR: Descobrindo os Sintetizadores

en: Now play around with *switching synths during your music*. Have fun combining synths to make new sounds as well as using different synths for different sections of your music.
pt-BR: Agora brinque *trocando sintetizadores durante sua música*. Divirta-se combinando sintetizadores, para criar novos sons assim como usando diferentes sintetizadores em diferentes seções da sua música.

en: 2.4 Duration with Envelopes
pt-BR: 2.4 Duração com Envelopes

en: Duration with Envelopes
pt-BR: Duração com Envelopes

en: In an earlier section, we looked at how we can use the `sleep` command to control when to trigger our sounds. However, we haven't yet been able to control the duration of our sounds.
pt-BR: Em uma seção anterior, nós vimos como podemos usar o comando `sleep` para controlar quando o som será disparado. Entretato, ainda não fomos capazes de controlar a duração dos nossos sons.

en: In order to give us a simple, yet powerful means of *controlling the duration* of our sounds, Sonic Pi provides the notion of an *ADSR amplitude envelope* (we'll cover what ADSR means later in this section). An amplitude envelope offers two useful aspects of control:
pt-BR: Para nos dar um meio simples, mas ainda assim poderoso, de *controlar a duração* de nossos sons, o Sonic Pi fornece  a noção de um *envelope de amplitude ADSR* (vamos explicar o que ADSR significa mais à frente nesta seção). Um envelope de amplitude oferece dois aspectos úteis de controle:

en: control over the duration of a sound
pt-BR: controle sobre a duração de um som

en: control over the amplitude of a sound
pt-BR: controle sobre a amplitude de um som

en: Duration
pt-BR: Duração

en: The duration is the length the sound lasts for. A longer duration means that you hear the sound for longer. Sonic Pi's sounds all have a controllable amplitude envelope, and the total duration of that envelope is the duration of the sound. Therefore, by controlling the envelope you control the duration.
pt-BR: A duração é o tempo que o som permanece tocando. Uma duração mais longa significa que você ouve o som por mais tempo. Todos os sons do Sonic Pi possuem um envelope de amplitude controlável e a duração deste envelope é a duração do som. Portanto, controlando o envelope, você controla a duração.

en: The ADSR envelope not only controls duration, it also gives you *fine control over the amplitude of the sound*. All audible sounds start and end silent and contain some non-silent part in-between. Envelopes allow you to slide and hold the amplitude of non-silent parts of the sound. It's like giving someone instructions on how to turn up and down the volume of a guitar amplifier. For example you might ask someone to "start at silence, slowly move up to full volume, hold it for a bit, then quickly fall back to silence." Sonic Pi allows you to program exactly this behaviour with envelopes.
pt-BR: O envelope ADSR não só controla a duração, ele também te dá *controle fino sobre a amplitude do som*. Todos os sons começa e terminam no silêncio e contém algumas partes não silenciosas no meio. Envelope te permitem deslizar e manter a amplitude das partes não silenciosas do som. É como dar a alguém instruções de como aumentar e diminuir o volume de um amplificador de guitarra. Por exemplo: você pode pedir para alguém para "iniciar no silêncio, aumentar o volume devagar, mantê-lo por um pouco e então voltar rapidamente para o silêncio". O Sonic Pi te permite programar exatamente este comportamento através de envelopes.

en: Just to recap, as we have seen before, an amplitude of 0 is silence and an amplitude of 1 is normal volume.
pt-BR: Recapitulando, como vimos antes, uma amplitude de 0 é silêncio e uma amplitude de 1 é volume normal.

en: Now, let us look at each of the parts of the envelopes in turn.
pt-BR: Agora, vamos ver em sequencia cada uma das partes das curvas de envelope.

en: Release Phase
pt-BR: Fase de Release (extinção)

en: The only part of the envelope that's used by default is the release time. This is the time it takes for the synth's sound to fade out. All synths have a release time of 1 which means that by default they have a duration of 1 beat (which at the default BPM of 60 is 1 second):
pt-BR: A única parte do envelope que é usada por padrão é o período de Release (extinção ou relaxamento). Este é o tempo que o som do sintetizador leva para desaparecer. Todos os sintetizadores possuem um tempo de extinção de 1, que significa que, por padrão, eles duram 1 batida (que no BPM padrão de 60 é 1 segundo):

en: The note will be audible for 1 second. Go ahead and time it :-) This is short hand for the longer more explicit version:
pt-BR: A nota será audível por 1 segundo. Vá em frente e cronometre:-) Esta é a versão curta da versão mais longa e explícita:

en: Notice how this sounds exactly the same (the sound lasts for one second). However, it's now very easy to change the duration by modifying the value of the `release:` opt:
pt-BR: Note como isso soa exatamente o mesmo (o som dura 1 segundo). Entretanto, agora é muito fácil modificar a duração modificando o valor da opção `release:`:

en: We can make the synth sound for a very short amount of time by using a very small release time:
pt-BR: Podemos fazer com que o sintetizador soe por um período muito pequeno usando um valor bem pequeno para `release:`:

en: The duration of the release of the sound is called the *release phase* and by default is a linear transition (i.e. a straight line). The following diagram illustrates this transition:
pt-BR: A duração deste esmaecimento do som é chamada de *fase de release* e por padrão é uma transição linear (isto é: uma reta). O diagrama a seguir ilustra esta transição:

en: You can therefore change the duration of your sound by changing the release time. Have a play adding release times to your music.
pt-BR: Você pode, portanto, mudar a duração do seu som mudando o tempo de release. Brinque adicionando tempos de release à sua música.

en: Attack Phase
pt-BR: Fase de Ataque

en: By default, the *attack phase* is 0 for all synths which means they move from 0 amplitude to 1 immediately. This gives the synth an initial percussive sound. However, you may wish to fade your sound in. This can be achieved with the `attack:` opt. Try fading in some sounds:
pt-BR: Por padrão, a *fase de ataque* é 0 para todos os sintetizadores, o que significa que eles vão da amplitude 0 para 1 imediatamente. Isso dá aos sintetizadores um som inicial percussivo. Entretanto, você pode querer um som com início gradual. Isso pode ser atingido com a opção `attack:`. Tente um início gradual (fade in) em alguns sons:

en: You may use multiple opts at the same time. For example for a short attack and a long release try:
pt-BR: Você pode utilizar múltiplas opções ao mesmo tempo. Por exemplo, para um ataque curto e repouso longo, tente:

en: This short attack and long release envelope is illustrated in the following diagram:
pt-BR: Este envelopamento (ataque curto e repouso longo) é ilustrado no seguinte diagrama:

en: Of course, you may switch things around. Try a long attack and a short release:
pt-BR: Claro que você pode inverter as coisas. Tente um ataque longo e repouso curto:

en: Finally, you can also have both short attack and release times for shorter sounds.
pt-BR: Finalmente, você pode ter também os tempos, tanto de ataque quanto de release, curtos para obter sons mais curtos.

en: Sustain Phase
pt-BR: Fase de Sustentação

en: In addition to specifying attack and release times, you may also specify a sustain time to control the *sustain phase*. This is the time for which the sound is maintained at full amplitude between the attack and release phases.
pt-BR: Além de especificar os tempos de ataque e release, você também pode especificar um tempo para controlar a *fase de sustain* (sustentação). Este é o tempo durante o qual o som é mantido em sua amplitude total, entre as fase de ataque e release.

en: The sustain time is useful for important sounds you wish to give full presence in the mix before entering an optional release phase. Of course, it's totally valid to set both the `attack:` and `release:` opts to 0 and just use the sustain to have absolutely no fade in or fade out to the sound. However, be warned, a release of 0 can produce clicks in the audio and it's often better to use a very small value such as 0.2.
pt-BR: O tempo de sustentação é útil para quando você deseja aumentar a presença do som, antes de entrar na fase de release opcional. Claro, é completamente válido configurar as opções de `attack:` e `release:` com valor 0 e usar somente o sustain, ficando totalmente sem *fade in* ou *fade out* no som. Porém, fique avisado, um release igual a 0 pode produzir clicks no áudio e geralmente é preferível usar um valor pequeno, como 0.2.

en: Decay Phase
pt-BR: Fase de Decaimento (Decay)

en: For an extra level of control, you can also specify a decay time. This is a phase of the envelope that fits between the attack and sustain phases and specifies a time where the amplitude will drop from the `attack_level:` to the `decay_level:` (which unless you explicitly set it will be set to the `sustain_level:`). By default, the `decay:` opt is 0 and both the attack and sustain levels are 1 so you'll need to specify them for the decay time to have any effect:
pt-BR: Para um nível extra de controle, você também pode especificar um tempo de decaimento. Esta é a fase do envelope que se encaixa entre o ataque e o sustain e especifica um tempo para que a amplitude caia de `attack_level:` até`decay_level:` (que, a não ser que você configure explicitamente, será igual ao `sustain_level:`). Por padrão, a opção `decay:` é 0 e ambos os níveis de ataque e de sustain são 1. Desta forma, você precisa especificá-los para que o tempo de decaimento faça algum efeito:

en: Decay Level
pt-BR: Nível de Decaimento

en: One last trick is that although the `decay_level:` opt defaults to be the same value as `sustain_level:` you can explicitly set them to different values for full control over the envelope. This allows you to to create envelopes such as the following:
pt-BR: Um último truque é que apesar do valor padrão da opção `decay_level:` ser o mesmo valor de `sustain_level:`, você pode configurá-los explicitamente com valores diferentes para ter controle total sobre o envelope. Isto te permite criar envolventes como o seguinte:

en: It's also possible to set the `decay_level:` to be higher than `sustain_level:`:
pt-BR: Também é possível configurar `decay_level:` para ser maior que o `sustain_level:`:

en: ADSR Envelopes
pt-BR: Curvas de Envelope ADSR

en: So to summarise, Sonic Pi's ADSR envelopes have the following phases:
pt-BR: Para resumir, os envelopes ASDR do Sonic Pi possuem as seguintes fases:

en: *attack* - time from 0 amplitude to the `attack_level`,
pt-BR: *ataque* - tempo para a amplitude ir 0 até o `attack_level:`

en: *decay* - time to move amplitude from `attack_level` to `decay_level`,
pt-BR: *decaimento (decay)* - tempo para a amplitude ir de `attack_level:` até `decay_level:`

en: *sustain* - time to move the amplitude from `decay_level` to `sustain_level`,
pt-BR: *sustentação (sustain)* - tempo para a amplitude ir de `decay_level:` até `sustain_level:`

en: *release* - time to move amplitude from `sustain_level` to 0
pt-BR: *extinção (release)* - tempo para a amplitude ir de `sustain_level:` até 0 (extinção do som)

en: It's important to note that the duration of a sound is the summation of the times of each of these phases. Therefore the following sound will have a duration of 0.5 + 1 + 2 + 0.5 = 4 beats:
pt-BR: É importante notar que a duração de um som é a somatória dos tempos de cada uma destas fases. Portanto, o seguinte som terá uma duração de 0.5 + 1 + 2 + 0.5 = 4 tempos:

en: Now go and have a play adding envelopes to your sounds...
pt-BR: Agora vá e se divirta adicionando curvas de envelope aos seus sons...

en: 3 Samples
pt-BR: 3 Amostras

en: Samples
pt-BR: Amostras

en: Another great way to develop your music is to use pre-recorded sounds. In great hip-hop tradition, we call these pre-recorded sounds *samples*. So, if you take a microphone outside, go and record the gentle sound of rain hitting canvas, you've just created a sample.
pt-BR: Outra grande maneira de desenvolver a sua música é usando sons pré-gravados. Na grande tradição hip-hop, nós chamamos estes sons pré-gravado e *samples* (ou *amostras*, em português). Então, se você levar um microfone para a rua, vá e grave o suave som da chuva caindo e você terá criado uma amostra.

en: Sonic Pi lets you do lots of fun things with samples. Not only does it ship with 130 public domain samples ready for you to jam with, it lets you play and manipulate your own. Let's get to it...
pt-BR: O Sonic Pi te permite fazer muitas coisas divertidas com amostras. Não só vem com 130 amostras de domínio público prontas para serem tocadas, assim como te deixa tocar e manipular suas próprias amostras. Vamos ver como...

en: 3.1 Triggering Samples
pt-BR: 3.1 Disparando amostras

en: Triggering Samples
pt-BR: Disparando Amostras

en: Playing beeps is only the beginning. Something that's a lot of fun is triggering pre-recorded samples. Try it:
pt-BR: Tocar bips é só o começo. Algo muito mais divertido é disparar amostras pré-programadas. Tente:

en: Sonic Pi includes many samples for you to play with. You can use them just like you use the `play` command. To play multiple samples and notes just write them one after another:
pt-BR: O Sonic Pi inclui muitas amostras para você brincar. Você pode usá-las exatamente como você usa o comando `play`. Para tocar várias amostras e notas basta escrevê-las em sequência:

en: If you want to space them out in time, use the `sleep` command:
pt-BR: Se quiser espaçá-las no tempo, use o comando `sleep`:

en: Discovering Samples
pt-BR: Descobrindo Amostras

en: Alternatively you can use the *auto-completion system*. Simply type the start of a sample group such as: `sample :ambi_` and you'll see a drop-down of sample names appear for you to select. Try the following category prefixes:
pt-BR: Alternativamente, você pode usar o *sistema de auto-completação*. Simplesmente digite o começo de um grupo de amostras como `sample :ambi_` e você verá uma lista suspensa de nomes de amostras aparecer para você selecionar. Tente os seguintes prefixos de categorias:

en: Now start mixing samples into your compositions!
pt-BR: Agora comece a mixar amostras nas suas composições!

en: 3.2 Sample Parameters
pt-BR: 3.2 Parâmetros de Amostras (Samples)

en: Sample Parameters: Amp and Pan
pt-BR: Parâmetros de Amostras: Amplitude (Amp) e Panorâmico (Pan)

en: As we saw with synths, we can easily control our sounds with parameters. Samples support exactly the same parameterisation mechanism. Let's revisit our friends `amp:` and `pan:`.
pt-BR: Assim como fazemos com os sintetizadores, podemos controlar facilmente nossas amostras através de parâmetros. Elas suportam exatamente o mesmo mecanismo de parametrização. Vamos revisitar nossos amigos `amp:` e `pan:`.

en: Amping samples
pt-BR: Amplificando amostras

en: You can change the amplitude of samples with exactly the same approach you used for synths:
pt-BR: Você pode modificar a amplitude de amostras exatamente da mesma forma que usamos com os sintetizadores:

en: Panning samples
pt-BR: Usando pan com amostras

en: We're also able to use the `pan:` parameter on samples. For example, here's how we'd play the amen break in the left ear and then half way through play it again through the right ear:
pt-BR: Também podemos usar o parâmetro `pan:` com amostras. Por exemplo, veja como nós podemos tocar o Amem Break no canal esquerdo e no meio da execução, trocamos para o canal direito:

en: Note that 0.877 is half the duration of the `:loop_amen` sample in seconds.
pt-BR: Note que 0.877 é metade da duração da amostra `:loop_amen`, em segundos.

en: Finally, note that if you set some synth defaults with `use_synth_defaults` (which we will discuss later), these will be ignored by `sample`.
pt-BR: Finalmente, note que se você configurar alguns valores padrão para sintetizadores com `use_synth_defaults` (que será discutido mais tarde), estes valores serão ignorados por `sample`.

en: 3.3 Stretching Samples
pt-BR: 3.3 Esticando Amostras (Stretching)

en: Stretching Samples
pt-BR: Esticando Amostras (Stretching)

en: Now that we can play a variety of synths and samples to create some music, it's time to learn how to modify both the synths and samples to make the music even more unique and interesting. First, let's explore the ability to *stretch* and *squash* samples.
pt-BR: Agora que podemos tocar uma variedade de sintetizadores e amostras para criar música, está na hora de aprendermos como modificar os sintetizadores e amostras para transformar a música em algo ainda mais único e interessante. Primeiro, vamos explorar a habilidade de *esticar* e *comprimir* amostras. 
    
    Now that we can play a variety of synths and samples to create some music, it's time to learn how to modify both the synths and samples to make the music even more unique and interesting. First, let's explore the ability to *stretch* and *squash* samples.

en: Sample Representation
pt-BR: Representação de Amostras

en: Samples are pre-recorded sounds stored as numbers which represent how to move the speaker cone to reproduce the sound. The speaker cone can move in and out, and so the numbers just need to represent how far in and out the cone needs to be for each moment in time. To be able to faithfully reproduce a recorded sound the sample typically needs to store many thousands of numbers per second! Sonic Pi takes this list of numbers and feeds them at the right speed to move your computer's speaker in and out in just the right way to reproduce the sound. However, it's also fun to change the speed with which the numbers are fed to the speaker to change the sound.
pt-BR: Amostras são sons pré-gravados, armazenados como números que representam como mover o diafragma do alto-falante para reproduzir o som. O diafragma do alto-falante pode mover-se para dentro e para fora, e desta forma os números apenas representam a distância destes movimentos para cada momento no tempo. Para ser capaz de de reproduzir fielmente um som gravado a amostra precisa armazenar milhares de números por segundo! O Sonic Pi pega esta lista de números e os passa para o alto-falante do computador na velocidade correta para movê-lo da forma correta e reproduzir o som. Entretanto, é possível (e divertido) mudar a velocidade que os números são passados ao alto-falante para modificar o som.

en: Changing Rate
pt-BR: Mudando a Velocidade (Rate)

en: Let's play with one of the ambient sounds: `:ambi_choir`. To play it with the default rate, you can pass a `rate:` opt to `sample`:
pt-BR: Vamos brincar com um dos sons ambientes: `:ambi_choir`. Para tocá-lo com a velocidade (rate) padrão, você pode passar a opção `rate:` para `sample` (que é a amostra):

en: This plays it at normal rate (1), so nothing special yet. However, we're free to change that number to something else. How about `0.5`:
pt-BR: Isto irá tocá-la em velocidade normal (1), nada de especial ainda. Mas estamos livres para modificar este número para qualquer outra coisa. Que tal `0.5`:

en: Woah! What's going on here? Well, two things. Firstly, the sample takes twice as long to play, secondly the sound is an octave lower. Let's explore these things in a little more detail.
pt-BR: Wow! O que está acontecendo aqui? Bem, duas coisas. Primeiro, a amostra leva o dobro do tempo para ser reproduzida. Segundo, o som está uma oitava abaixo. Vamos explorar estas coisas mais detalhadamente.

en: Let's stretch
pt-BR: Vamos esticar

en: A sample that's fun to stretch and compress is the Amen Break. At normal rate, we might imagine throwing it into a *drum 'n' bass* track:
pt-BR: Uma amostra que é divertida de esticar e comprimir é a Amem Break. Na velocidade normal, podemos imaginar inserindo-o em uma faixa de *drum 'n' bass*:

en: However by changing the rate we can switch up genres. Try half speed for *old school hip-hop*:
pt-BR: Mas ao mudar a velocidade nós podemos trocar o gênero musical. Tente meia velocidade para um *hip-hop old school*:

en: If we speed it up, we enter *jungle* territory:
pt-BR: Se acelerarmos, entramos no território do *jungle*:

en: Now for our final party trick - let's see what happens if we use a negative rate:
pt-BR: Agora o truque final - vamos ver o que acontece se usarmos um valor negativo para a velocidade (rate):

en: Woah! It plays it *backwards*! Now try playing with lots of different samples at different rates. Try very fast rates. Try crazy slow rates. See what interesting sounds you can produce.
pt-BR: Wow! Toca *ao contrário*! Agora tente com várias amostras diferentes, em velocidades diferentes. Tente velocidades muito rápidas. Tente velocidades extremamente lentas. Veja os sons interessantes que você pode produzir.

en: A Simple Explanation of Sample Rate
pt-BR: Uma Explicação Simples do Termo Sample Rate (velocidade da amostra)

en: A useful way to think of samples is as springs. Playback rate is like squashing and stretching the spring. If you play the sample at rate 2, you're *squashing the spring* to half its normal length. The sample therefore takes half the amount of time to play as it's shorter. If you play the sample at half rate, you're *stretching the spring* to double its length. The sample therefore takes twice the amount of time to play as it's longer. The more you squash (higher rate), the shorter it gets, the more you stretch (lower rate), the longer it gets.
pt-BR: Uma forma útil de se pensar em amostras é com se fossem molas. A velocidade de execução é como espremer ou esticar a mola. Se você toca uma amostra com velocidade 2, você está *comprimindo a mola* até a metade de seu comprimento. Consequentemente, a amostra leva metade do tempo para tocar, já que está menor. Se você toca a amostra com metade da velocidade, você está *esticando a mola* até o dobro de seu tamanho. A amostra leva o dobro do tempo para ser tocada, já que está mais longa. Quanto mais você comprime (rate maior), mais curto o som fica. Quanto mais você estica (rate menor), mais longo o som fica.

en: Compressing a spring increases its density (the number of coils per cm) - this is similar to the sample sounding *higher pitched*. Stretching the spring decreases its density and is similar to the sound having a *lower pitch*.
pt-BR: Comprimir uma mola aumenta sua densidade (em número de voltas por cm) - isto é similar ao som da amostra ficar *mais agudo* (tom mais alto). Esticando a mola, sua densidade diminui e, no caso da amostra, o som fica *mais grave* (com um tom mais baixo).

en: The Maths Behind Sample Rate
pt-BR: A Matemática Por Trás do Sample Rate

en: (This section is provided for those that are interested in the details. Please feel free to skip it...)
pt-BR: (Esta seção é voltada para aqueles que estão interessados nos detalhes. Sinta-se a vontade para pulá-la...)

en: As we saw above, a sample is represented by a big long list of numbers representing where the speaker should be through time. We can take this list of numbers and use it to draw a graph which would look similar to this:
pt-BR: Como vimos acima, uma amostra é representada por uma longa lista de números representando onde o alto-falante deve estar através do tempo. Podemos pegar esta lista de números e usá-la para desenhar um gráfico que ficaria similar a isto:

en: You might have seen pictures like this before. It's called the *waveform* of a sample. It's just a graph of numbers. Typically a waveform like this will have 44100 points of data per second (this is due to the Nyquist-Shannon sampling theorem). So, if the sample lasts for 2 seconds, the waveform will be represented by 88200 numbers which we would feed to the speaker at a rate of 44100 points per second. Of course, we could feed it at double rate which would be 88200 points per second. This would therefore take only 1 second to play back. We could also play it back at half rate which would be 22050 points per second taking 4 seconds to play back.
pt-BR: Você deve já ter visto gráficos com este antes. São chamados de *Waveform* (forma de onda) da amostra. É só um gráfico de números. Tipicamente uma onda terá 44100 pontos de dados por segundo (isto se deve ao Teorema de Amostragem de Nyquist-Shannon). Então, se a amostra durar 2 segundos, a onda será representada por 88200 números que deveremos passar ao alto-falente, à velocidade de 44100 pontos/s. Claro, nós passá-los com velocidade dobrada, que seria 88200 pontos/s. Isso então levaria somente 1 segundo para tocar. Nós podemos também tocá-la com metade da velocidade, que seriam 22050 pontos/s, levando 4 segundos pra tocar.

en: The duration of the sample is affected by the playback rate:
pt-BR: A duração da amostra é afetada pela velocidade (rate) que é tocada:

en: Doubling the playback rate halves the playback time,
pt-BR: Dobrando a velocidade, cortamos pela metade a duração,

en: Halving the playback rate doubles the playback time,
pt-BR: Tocando na metade da velocidade, dobramos a duração,

en: Using a playback rate of one fourth quadruples the playback time,
pt-BR: Tocando com 1/4 da velocidade, quadruplicamos a duração,

en: Using a playback rate of 1/10 makes playback last 10 times longer.
pt-BR: Tocando com 1/10 da velocidade, multiplicamos a duração por 10.

en: We can represent this with the formula:
pt-BR: Podemos representar isso através da fórmula:

en: new_sample_duration = (1 / rate) * sample_duration
pt-BR: nova_duração_da_amostra = (1 / rate) * duração_da_amostra

en: Changing the playback rate also affects the pitch of the sample. The frequency or pitch of a waveform is determined by how fast it moves up and down. Our brains somehow turn fast movement of speakers into high notes and slow movement of speakers into low notes. This is why you can sometimes even see a big bass speaker move as it pumps out super low bass - it's actually moving a lot slower in and out than a speaker producing higher notes.
pt-BR: Modificando a velocidade de execução também afeta o tom da amostra. A frequência, ou tom (pitch), de uma onda é determinada pelo quão rápido ela se move para cima e para baixo. Nossos cérebros, de alguma forma transformam movimentos rápidos do alto-falante em notas altas (agudas) e movimentos lentos do alto-falante em notas baixas (graves). Por isso que, as vezes, você pode até ver um grande alto-falante reproduzindo sons graves se movendo - na realidade, ele está se movendo bem mais lento (para dentro e para fora) do que um alto-falante reproduzindo notas altas (agudos).

en: If you take a waveform and squash it it will move up and down more times per second. This will make it sound higher pitched. It turns out that doubling the amount of up and down movements (oscillations) doubles the frequency. So, *playing your sample at double rate will double the frequency you hear it*. Also, *halving the rate will halve the frequency*. Other rates will affect the frequency accordingly.
pt-BR: Se você pegar um onda e espremê-la, ela ira se mover, para cima e para baixo, mais vezes por segundo. Isto fará o som ficar mais agudo. Acontece que dobrando a quantidade de movimentos para cima e para baixo (oscilações), dobramos a frequência. Então, *tocando nossa amostra com o dobro da velocidade, dobramos a frequência que você ouve*. Também, *dividindo ao meio a velocidade, dividimos ao meio a frequência*. Outras velocidades (rates) afetarão a frequência proporcionalmente.

en: 3.4 Enveloped Samples
pt-BR: 3.4 Curvas de Envelope de Amostras

en: Enveloped Samples
pt-BR: Curvas de Envelope de Amostras (ou simplesmente Envelopes de Amostras)

en: It is also possible to modify the *duration* and *amplitude* of a sample using an ADSR envelope. However, this works slightly differently to the ADSR envelope available on synths. Sample envelopes only allow you to reduce the amplitude and duration of a sample - and never to increase it. The sample will stop when either the sample has finished playing or the envelope has completed - whichever is first. So, if you use a very long `release:`, it won't extend the duration of the sample.
pt-BR: Também é possível modificar a *duração* e a *amplitude* de um sample usando um pacote ADSR. Entretanto, isso funciona um pouco diferente dos pacotes ADSR disponíveis em sintetizadores. Envelopes de samples permitem apenas a redução da amplitude e da duração de um sample - e nunca seu incremento. O sample irá parar de tocar quando o sample chegar ao fim ou quando o envelope se completar - O que vier primeiro. Então, se você usar um `release:`comprido, isso não irá extender a duração do sample.

en: Amen Envelopes
pt-BR: Envelopes Amen

en: Let's return to our trusty friend the Amen Break:
pt-BR: Vamos voltar ao nosso fiel amigo Amen Break:

en: With no opts, we hear the full sample at full amplitude. If we want to fade this in over 1 second we can use the `attack:` param:
pt-BR: Sem opts, nós ouvimos o sample com a amplitude máxima. Se quisermos fazer um fade com mais de 1 segundo, podemos usar o parâmetro `attack:`:

en: For a shorter fade in, choose a shorter attack value:
pt-BR: Para um fade in mais curto, escolha um valor menor de attack:

en: Auto Sustain
pt-BR: Sustain Automático

en: Where the ADSR envelope's behaviour differs from the standard synth envelope is in the *sustain* value. In the standard synth envelope, the sustain defaulted to 0 unless you set it manually. With samples, the sustain value defaults to an *automagical* value - the time left to play the rest of the sample. This is why we hear the full sample when we pass no defaults. If the attack, decay, sustain and release values were all 0 we'd never hear a peep. Sonic Pi therefore calculates how long the sample is, deducts any attack, decay and release times and uses the result as your sustain time. If the attack, decay and release values add up to more than the duration of the sample, the sustain is simply set to 0.
pt-BR: Onde o envelope ADSR tem um comportamento diferente dos sintetizadores é no valor de *sustain*. Em um envelope padrão de sintetizador, o sustain tem um valor 0 por padrão, a não ser que outro valor seja definido manualmente. Com samples, o sustain é definido com um valor  *automágico* - o tempo de duração da sample. É por isso que ouvimos toda a sample quando não passamos nenhum valor. Se os valores de attack, decay, sustain e release fossem todos 0, nós não ouviríamos nem um pio. Portanto, o Sonic Pi calcula a duração da sample, deduz qualquer tempo de attack, decay e release, e usa o resultado como tempo de sustain. Se os valores de attack, decay e release somarem mais do que a duração da sample, o sustain é definido como 0.

en: To explore this, let's consider our Amen break in more detail. If we ask Sonic Pi how long the sample is:
pt-BR: Para explorarmos isso, vamos analisar nosso Amen Break em mais detalhes. Se perguntarmos ao Sonic Pi qual é a duração do sample:

en: It will print out `1.753310657596372` which is the length of the sample in seconds. Let's just round that to `1.75` for convenience here. Now, if we set the release to `0.75`, something surprising will happen:
pt-BR: Irá exibir o valor `1.753310657596372`, que é a duração da sample em segundos. Vamos arredondar isso para `1.75` por conveniência. Agora, se definirmos o valor de release para `0.75`, algo surpreendente acontece:

en: It will play the first second of the sample at full amplitude before then fading out over a period of 0.75 seconds. This is the *auto sustain* in action. By default, the release always works from the end of the sample. If our sample was 10.75 seconds long, it would play the first 10 seconds at full amplitude before fading out over 0.75s.
pt-BR: Primeiro, ele ira tocar o primeiro segundo do sample na amplitude máxima, e depois fará um fading out por um período de 0,75 segundos. Esse é o *auto sustain* em ação. Por padrão, o release sempre trabalha com o final do sample. Se o nosso sample tiver 10,75 segundos de duração, ele ira tocar os primeiros 10 segundos na amplitude máxima antes do fading out de 0,75 segundos.

en: Remember: by default, `release:` fades out at the end of a sample.
pt-BR: Este envelopamento (ataque curto e repouso longo) é ilustrado no seguinte diagrama:

en: Fade In and Out
pt-BR: Fade In e Fade Out

en: We can use both `attack:` and `release:` together with the auto sustain behaviour to fade both in and out over the duration of the sample:
pt-BR: Nós podemos usar ambos `attack:` e `release:` em conjunto com o auto sustain  para fazer o fade-in e o fade-out na duração do sample:

en: Explicit sustain
pt-BR: Sustentação (sustain) explícito

en: We can easily get back to our normal synth ADSR behaviour by manually setting `sustain:` to a value such as 0:
pt-BR: Nós podemos facilmente voltar para o comportamento normal do nosso sintetizador ASDR, configurando manualmente o `sustain:` para um valor como 0:

en: 3.5 Partial Samples
pt-BR: 3.5 Amostras Parciais

en: Partial Samples
pt-BR: Amostras Parciais

en: What happens if we choose a start position after the finish position?
pt-BR: O que acontece se escolhermos uma posição inicial posterior a posição final?

en: 4 Randomisation
pt-BR: 4 Randomização

en: Randomisation
pt-BR: Randomização (ou Aleatorização)

en: A great way to add some interest into your music is using some random numbers. Sonic Pi has some great functionality for adding randomness to your music, but before we start we need to learn a shocking truth: in Sonic Pi *random is not truly random*. What on earth does this mean? Well, let's see.
pt-BR: Obs: randomização vem do inglês *random*, que significa aleatório, ao acaso.
    
    Uma boa forma de tornar sua música mais interessante é usando números aleatórios. O Sonic Pi possui uma excelente funcionalidade para adicionar aleatoriedade à sua musica, mas antes de começar temos que aprender uma verdade chocante: no Sonic Pi *aleatório não é verdadeiramente aleatório*. O que raio quer isto dizer? Bem, vamos ver.

en: Repeatability
pt-BR: Repetibilidade

en: A really useful random function is `rrand` which will give you a random value between two numbers - a *min* and a *max*. (`rrand` is short for ranged random). Let's try playing a random note:
pt-BR: Uma função muito útil para gerar números aleatórios é `rrand` que retorna um valor aleatório entre dois números - um *min* e um *max* (`rrand` é abreviatura de ranged random, *aleatório no intervalo*). Vamos tentar tocar uma nota aleatória:

en: Ooh, it played a random note. It played note `83.7527`. A nice random note between 50 and 95. Woah, wait, did I just predict the exact random note you got too? Something fishy is going on here. Try running the code again. What? It chose `83.7527` again? That can't be random!
pt-BR: Oh, uma nota aleatória foi tocada. Foi a nota `83.7527`. Uma bela nota aleatória entre 50 and 95. Opa, espera, eu previ exatamente a nota aleatória que você obteve? Algo estranho está acontecendo aqui. Tente executar o programa novamente. O quê? Escolheu `83.7527` de novo? Isso não pode ser aleatório!

en: The answer is that it is not truly random, it's pseudo-random. Sonic Pi will give you random-like numbers in a repeatable manner. This is very useful for ensuring that the music you create on your machine sounds identical on everybody else's machine - even if you use some randomness in your composition.
pt-BR: A resposta é que isso não é realmente aleatório, é pseudo-aleatório. O Sonic Pi te dará números que parecem aleatórios de forma repetível. Isto é muito útil para garantir que a música que você criou em uma máquina soe idêntica nas máquinas de qualquer outra pessoa - mesmo que você use aleatoriedade na sua composição.

en: Of course, in a given piece of music, if it 'randomly' chose `83.7527` every time, then it wouldn't be very interesting. However, it doesn't. Try the following:
pt-BR: Claro que, em uma certa composição musical, se toda vez for 'aleatoriamente' escolhido o `83.7527`, não seria nada interessante. Mas não acontece assim. Tente o seguinte:

en: Yes! It finally sounds random. Within a given *run* subsequent calls to random functions will return random values. However, the next run will produce exactly the same sequence of random values and sound exactly the same. It's as if all Sonic Pi code went back in time to exactly the same point every time the Run button was pressed. It's the Groundhog Day of music synthesis!
pt-BR: Sim! Finalmente soa a aleatório. Dentro de uma dada *execução*, chamadas subsequentes à função random retornarão valores aleatórios. No entanto, a próxima execução irá produzir exatamente a mesma sequência de valores aleatórios e soará exatamente da mesma forma. É como se todo o código do Sonic Pi voltasse para exatamente o mesmo ponto no tempo, cada vez que o botão Run for pressionado. É o Dia da Marmota (filme: Feitiço do Tempo) da síntese musical!

en: Haunted Bells
pt-BR: Sinos assombrados

en: A lovely illustration of randomisation in action is the haunted bells example which loops the `:perc_bell` sample with a random rate and sleep time between bell sounds:
pt-BR: Uma linda ilustração de aleatorização em ação é o exemplo 'haunted bells' (sinos assombrados), que faz um loop com a amostra `:perc_bell` com velocidades e tempos de pausa aleatórios entre os sons de sino:

en: Random cutoff
pt-BR: Corte aleatório

en: Another fun example of randomisation is to modify the cutoff of a synth randomly. A great synth to try this out on is the `:tb303` emulator:
pt-BR: Outro exemplo divertido e randomização é modificar o corte de sintetizadores aleatoriamente. Um bom sintetizador para tentar isto é o emulador `:tb303`:

en: Random seeds
pt-BR: Sementes de números aleatórios

en: So, what if you don't like this particular sequence of random numbers Sonic Pi provides? Well it's totally possible to choose a different starting point via `use_random_seed`. The default seed happens to be 0, so choose a different seed for a different random experience!
pt-BR: E se você não gostar desta sequência particular de números aleatórios que o Sonic Pi forneceu? Bom, é totalmente possível escolher um ponto inicial diferente, escolhendo uma semente diferente via `use_random_seed`. A semente padrão é 0, então escolha uma semente para ter uma experiência aleatória diferente!

en: Consider the following:
pt-BR: Considere o seguinte:

en: Every time you run this code, you'll hear the same sequence of 5 notes. To get a different sequence simply change the seed:
pt-BR: Cada vez que você executar este código, você ouvirá a mesma sequência de 5 notas. Para obter uma sequência diferente simplesmente mude a semente:

en: This will produce a different sequence of 5 notes. By changing the seed and listening to the results you can find something that you like - and when you share it with others, they will hear exactly what you heard too.
pt-BR: Isto produzirá uma sequência diferente de 5 notas. Mudando a semente e ouvindo o resultado você pode encontrar algo que goste - e quando você compartilhá-lo com outros, eles ouvirão exatamente o que você ouviu também.

en: Let's have a look at some other useful random functions.
pt-BR: Veja algumas outras funções aleatórias úteis.

en: A very common thing to do is to choose an item randomly from a list of known items. For example, I may want to play one note from the following: 60, 65 or 72. I can achieve this with `choose` which lets me choose an item from a list. First, I need to put my numbers in a list which is done by wrapping them in square brackets and separating them with commas: `[60, 65, 72]`. Next I just need to pass them to `choose`:
pt-BR: Uma atividade muito comum é escolher um item aleatório em uma lista de itens previamente conhecidos. Por exemplo, eu poso querer tocar uma dessas nota: 60, 65 ou 72. Eu posso atingir esse objetivo com `choose` que me deixa escolher um item de uma lista. Primeiro, eu preciso colocar meus números em uma lista, isso é feito envolvendo eles entre colchetes e separando eles com vírgulas  `[60, 65, 72]`. Feito isso basta passá-los para o `choose`:

en: Let's hear what that sounds like:
pt-BR: Vamos ouvir com o que este som se parece:

en: We've already seen `rrand`, but let's run over it again. It returns a random number between two values exclusively. That means it will never return either the top or bottom number - always something in between the two. The number will always be a float - meaning it's not a whole number but a fraction of a number. Examples of floats returned by `rrand(20, 110)`:
pt-BR: Nós já vimos `rrand`, mas vamos recapitular. Ela retorna um número aleatório entre dois valores exclusivamente (ela exclui os limites acima e abaixo). Isso significa que nunca retornará o máximo nem o mínimo - sempre retornará algo entre os dois. O número sempre será um float - número de ponto flutuante, significando que não é um inteiro e sim uma fração. Exemplos de floats retornados por `rrand(20, 110)`:

en: Occasionally you'll want a whole random number, not a float. This is where `rrand_i` comes to the rescue. It works similarly to `rrand` except it may return the min and max values as potential random values (which means it's inclusive rather than exclusive of the range). Examples of numbers returned by `rrand_i(20, 110)` are:
pt-BR: Ocasionalmente você desejará um número inteiro, não um float. É ai que entra a `rrand_i`. Ela trabalha de forma similar a ´rrand` exceto que pode retornar os valores mínimo e máximo como potenciais números aleatórios (o que significa que é inclusivo e não exclusivo, em relação aos limites). Exemplos de números retornados por `rrand_i(20,100)` são:

en: This will return a random float between 0 (inclusive) and the max value you specify (exclusive). By default it will return a value between 0 and one. It's therefore useful for choosing random `amp:` values:
pt-BR: Isto retornará um número float aleatório, entre 0 (inclusive) e o valor máximo (exclusivo) especificado por você. Por padrão, retornará um valor entre 0 e 1. Portanto é útil para selecionar aleatoriamente valores para `amp:`:

en: Similar to the relationship between `rrand_i` and `rrand`, `rand_i` will return a random whole number between 0 and the max value you specify.
pt-BR: De forma similar à relação entre `rrand_i` e `rrand`, `rand_i` retornará um número inteiro aleatório entre 0 e o valor máximo que você especificou.

en: dice
pt-BR: dice (dado)

en: Sometimes you want to emulate a dice throw - this is a special case of `rrand_i` where the lower value is always 1. A call to `dice` requires you to specify the number of sides on the dice. A standard dice has 6 sides, so `dice(6)` will act very similarly - returning values of either 1, 2, 3, 4, 5, or 6. However, just like fantasy role-play games, you might find value in a 4 sided dice, or a 12 sided dice, or a 20 sided dice - perhaps even a 120 sided dice!
pt-BR: As vezes você quer simular um laçamento de dados - este é um caso especial de `rrand_i` onde o menor valor é sempre 1. Uma chamada para `dice` requer que você especifique o número de lados do dado. Um dado padrão possui 6 lados, então `dice(6)` agirá de forma muito similar - retornando valores 1, 2, 3, 4, 5 ou 6. No entanto, como nos jogos de RPG, você poderá encontrar um dado de 4 lados, ou um dados de 12 lados ou de 20 lados - talvez até um dado de 120 lados!

en: Finally you may wish to emulate throwing the top score of a dice such as a 6 in a standard dice. `one_in` therefore returns true with a probability of one in the number of sides on the dice. Therefore `one_in(6)` will return true with a probability of 1 in 6 or false otherwise. True and false values are very useful for `if` statements which we will cover in a subsequent section of this tutorial.
pt-BR: Por fim, você pode quer simular o lançamento da pontuação máxima de um dado, por exemplo em um dado padrão de 6 lados. `one_in` (um em...) retorna verdadeiro com a probabilidade de um sobre o número de lados do dados. Desta forma, `one_in(6)` retornará verdadeiro com a probabilidade de 1 em 6, ou falso nos outros caso. Valores verdadeiro e falso (true/false) são muito úteis para instruções `if`, que iremos cobrir na próxima seção deste tutorial.

en: Now, go and jumble up your code with some randomness!
pt-BR: Agora vá e bagunce seu código com alguma aleatoriedade!

en: 5 Programming Structures
pt-BR: 5 Estruturas de Programação

en: Programming Structures
pt-BR: Estruturas de Programação

en: Now that you've learned the basics of creating sounds with `play` and `sample` and creating simple melodies and rhythms by `sleep`ing between sounds, you might be wondering what else the world of code can offer you...
pt-BR: Agora que você aprendeu o básico da criação de sons com `play` e `sample` e da criação de melodias simples e ritmos com `sleep` entre sons, você deve estar perguntando o que mais o mundo do código pode te oferecer...

en: Well, you're in for an exciting treat! It turns out that basic programming structures such as looping, conditionals, functions and threads give you amazingly powerful tools to express your musical ideas.
pt-BR: Prepare-se para uma surpresa excitante! Acontece que estruturas básicas de programação como loops, condicionais, funções e threads te dão ferramentas incrivelmente poderosas para expressar suas ideias musicais.

en: Let's get stuck in with the basics...
pt-BR: Vamos nos ater ao básico...

en: 5.1 Blocks
pt-BR: 5.1 Blocos

en: Blocks
pt-BR: Blocos

en: A structure you'll see a lot in Sonic Pi is the block. Blocks allow us to do useful things with large chunks of code. For example, with synth and sample parameters we were able to change something that happened on a single line. However, sometimes we want to do something meaningful to a number of lines of code. For example, we may wish to loop it, to add reverb to it, to only run it 1 time out of 5, etc. Consider the following code:
pt-BR: Uma estrutura que você verá muito no Sonic Pi são os blocos. Blocos nos permitem fazer coisas úteis com pedaços grandes de código. Por exemplo, com os parâmetros de Synth e Sample somos capazes de mudar algo em uma única linha. Entretanto, as vezes nós queremos fazer algo significativo a um número grande de linhas de código. Por exemplo, nós podemos querer fazer um loop com o bloco, para adicionar reverberação (reverb) a ele, executá-lo somente uma vez em 5, etc. Considere o seguinte código:

en: To do something with a chunk of code, we need to tell Sonic Pi where the code block *starts* and where it *ends*. We use `do` for start and `end` for end. For example:
pt-BR: Para fazermos algo com um bloco de código, precisamos dizer ao Sonic Pi onde o bloco *começa* e onde ele *termina*. Nós usamos `do` for iniciar e `end` para terminar. Por exemplo:

en: However, this isn't yet complete and won't work (try it and you'll get an error) as we haven't told Sonic Pi what we want to do with this *do/end block*. We tell Sonic Pi this by writing some special code before the `do`. We'll see a number of these special pieces of code later on in this tutorial. For now, it's important to know that wrapping your code within `do` and `end` tells Sonic Pi you wish to do something special with that chunk of code.
pt-BR: Entretanto, isso não está completo ainda e não irá funcionar (tente e você receberá um erro) já que não dissemos ao Sonic Pi o que queremos fazer com este *bloco do/end*. Dizemos isto ao Sonic Pi escrevendo comandos especiais antes do `do`. Veremos vários destas partes especiais de código mais tarde neste tutorial. Por enquanto é importante saber que envolvendo seu código com `do` e `end` você diz ao Sonic Pi que deseja fazer algo especial com este pedaço de código.

en: 5.2 Iteration and Loops
pt-BR: 5.2 Iteração e Loops

en: Iteration and Loops
pt-BR: Iteração e Loops

en: So far we've spent a lot of time looking at the different sounds you can make with `play` and `sample` blocks. We've also learned how to trigger these sounds through time using `sleep`.
pt-BR: Até agora passamos um bom tempo olhando para diferentes sons que podemos fazer com blocos `play` e `sample`. Também aprendemos como disparar estes sons através do tempo usando `sleep`.

en: As you've probably found out, there's a *lot* of fun you can have with these basic building blocks. However, a whole new dimension of fun opens up when you start using the power of code to structure your music and compositions. In the next few sections we'll explore some of these powerful new tools. First up is iteration and loops.
pt-BR: Como você provavelmente descobriu, você pode ter muita diversão com estes blocos básicos de construção. Entretanto, uma nova dimensão de diversão se abre quando você começa a usar o poder do código para estruturar suas músicas e composições. Nas próximas seções nós exploraremos algumas destas novas ferramentas poderosas. Primeiro, iteração e loops.

en: Repetition
pt-BR: Repetição

en: Have you written some code you'd like to repeat a few times? For example, you might have something like this:
pt-BR: Já escreveu algum código que você gostaria de repetir algumas vezes? Por exemplo, você pode ter algo assim:

en: What if we wished to repeat this 3 times? Well, we could do something simple and just copy and paste it three times:
pt-BR: Mas e se nós quisermos repeti-lo 3 vezes? Bem, podemos fazer algo simples e só copiá-lo e colá-lo 3 vezes:

en: Now that's a lot of code! What happens if you want to change the sample to `:elec_plip`? You're going to have to find all the places with the original `:elec_blup` and switch them over. More importantly, what if you wanted to repeat the original piece of code 50 times or 1000? Now that would be a lot of code, and a lot of lines of code to alter if you wanted to make a change.
pt-BR: Isso é muito código! O que acontece se você quiser mudar a amostra para `:elec_plip`? Você terá que encontrar todos os lugares com a amostra original `:elec_blup` e trocá-las. Mais importante, e se você quiser repetir o código original 50 ou 1000 vezes? Agora sim, isso será muito código e muitas linhas de código para alterar se você quiser fazer uma mudança.

en: Iteration
pt-BR: Iteração

en: In fact, repeating the code should be as easy as saying *do this three times*. Well, it pretty much is. Remember our old friend the code block? We can use it to mark the start and end of the code we'd like to repeat three times. We then use the special code `3.times`. So, instead of writing *do this three times*, we write `3.times do` - that's not too hard. Just remember to write `end` at the end of the code you'd like to repeat:
pt-BR: De fato, repetir código deveria ser tão simples quanto dizer *faça isso 3 vezes*. Bom, basicamente é. Lembra do nosso velho amigo, o bloco de código? Nós podemos usá-lo para marcar o início e o fim do código que queremos repetir três vezes. Então usamos o código especial `3.times`. Então, em vez de escrever *faça isso três vezes*, escrevemos `3.times do` - não é tão difícil. Só lembre-se de escrever `end` no final do código que você quer repetir:

en: Now isn't that much neater than cutting and pasting! We can use this to create lots of nice repeating structures:
pt-BR: Não fica muito mais bonito que copiar e colar? Podemos usar isso para criar muitas estruturas repetitivas elegantes:

en: Nesting Iterations
pt-BR: Iterações aninhadas

en: We can put iterations inside other iterations to create interesting patterns. For example:
pt-BR: Podemos colocar iterações dentro de outras iterações para criarmos padrões interessantes. Por exemplo:

en: Looping
pt-BR: Criando Loops

en: If you want something to repeat a lot of times, you might find yourself using really large numbers such as `1000.times do`. In this case, you're probably better off asking Sonic Pi to repeat forever (at least until you press the stop button!). Let's loop the amen break forever:
pt-BR: Se você quiser que algo se repita muitas vezes, você se encontrar usando números de repetições realmente grandes como `1000.times do`. Neste caso, você provavelmente ficaria melhor que pedisse para o Sonic Pi repetir  para sempre (pelo menos até pressionar o botão stop).  Vamos repetir o amen break para sempre:

en: The important thing to know about loops is that they act like black holes for code. Once the code enters a loop it can never leave until you press stop - it will just go round and round the loop forever. This means if you have code after the loop you will *never* hear it. For example, the cymbal after this loop will never play:
pt-BR: O mais importante a se aprender sobre loops é que eles funcionam como buracos negros para o código. Uma vez que o código entre em um loop, nunca mais sairá, até que você pressione Stop - irá só repetir e repetir o loop para sempre. Isto significa que se você tiver código após o Loop, você *nunca* irá ouvi-lo. Por exemplo, o chimbal após este loop nunca tocará:

en: Now, get structuring your code with iteration and loops!
pt-BR: Agora estruture seu código com iterações e loops!

en: 5.3 Conditionals
pt-BR: 5.3 Condicionais

en: Conditionals
pt-BR: Condicionais

en: There are many FX to choose from. How about some echo?
pt-BR: Existem muitos FX (efeitos especiais) para escolher. Que tal um pouco de eco?

en: Both the `reps: 16` and `16.times do` examples will behave identically. The `reps: 16` essentially repeats the code in the `do/end` block 16 times so you can use them both interchangeably and choose the one that feels best for you.
pt-BR: Tanto o exemplo `reps: 16` quanto o exemplo `16.times do` irão se comportar de forma idêntica. Em essência `reps: 16` repete o código entre o  bloco `do/end` 16 vezes. Então você pode utilizar alternadamente cada um e depois escolher aquele que te parecer mais cômodo.

en: 8 Data Structures
pt-BR: 8. Estruturas de dados

en: Data Structures
pt-BR: Estruturas de dados

en: A very useful tool in a programmer's toolkit is a data structure.
pt-BR: Uma ferramenta muito útil na caixa de ferramentas de um programador é uma estrutura de dados.

en: Sometimes you may wish to represent and use more than one thing. For example, you may find it useful to have a series of notes to play one after another. Programming languages have data structures to allow you do exactly this.
pt-BR: As Vezes você pode querer representar e usar mais de uma coisa. Por exemplo, você pode achar útil ter uma série de notas para tocar uma após a outra. Linguagens de programação possuem estruturas de dados que te possibilitam fazer exatamente isso.

en: There are many exciting and exotic data structures available to programmers - and people are always inventing new ones. However, for now we only really need to consider a very simple data structure - the list.
pt-BR: Existem muitas estruturas de dados excitantes e exóticas disponíveis para programadores - e as pessoas estão sempre inventando novas. No entanto, por enquanto nós só precisamos considerar uma estrutura de dados bem simples - a lista.

en: Let's look at it in more detail. We'll cover its basic form and then also how lists can be used to represent scales and chords.
pt-BR: Vamos olhá-la mais de perto. Vamos explicar sua forma básica e também como as listas podem ser usadas para representar escalas e acordes.

en: 8.1 Lists
pt-BR: 8.1 Listas

en: Lists
pt-BR: Listas

en: In this section we'll take a look at a data structure which is very useful - the list. We met it very briefly before in the section on randomisation when we randomly chose from a list of notes to play:
pt-BR: Nesta seção nós vamos ver uma estrutura de dados que é muito útil - a Lista. Nós a encontramos antes, muito rapidamente, na seção sobre aleatorização quando nós, aleatoriamente, escolhemos notas para serem todas de uma lista:

en: In this section we'll explore using lists to also represent chords and scales. First let's recap how we might play a chord. Remember that if we don't use `sleep`, sounds all happen at the same time:
pt-BR: Nesta seção nós vamos explorar o uso de listas para representação de acordes e escalas. Primeiro vamos recapitular como nós podemos tocar um acorde. Lembre-se que se não usarmos o `sleep`, todos os sons acontecem ao mesmo tempo:

en: Let's look at other ways to represent this code.
pt-BR: Vamos ver outras formas de representar este código.

en: Playing a List
pt-BR: Tocando uma lista

en: One option is to place all the notes in a list: `[52, 55, 59]`. Our friendly `play` function is smart enough to know how to play a list of notes. Try it:
pt-BR: Uma das opções é colocar todas as notas em uma lista: `[52, 55, 59]`. A nossa conhecida função `play` é suficientemente inteligente para saber como tocar uma lista de notas. Tente:

en: Ooh, that's already nicer to read. Playing a list of notes doesn't stop you from using any of the parameters as normal:
pt-BR: Ooh, isso já fica bem melhor para ler. Tocar uma lista de notas não te impede de usar qualquer outro dos parâmetros normais:

en: Of course, you can also use the traditional note names instead of the MIDI numbers:
pt-BR: Claro, que você também pode usar os nomes tradicionais das notas em vez do seu número MIDI:

en: Now those of you lucky enough to have studied some music theory might recognise that chord as *E Minor* played in the 3rd octave.
pt-BR: Agora aqueles de vocês que tiveram sorte de ter estudado teoria musical podem reconhecer este acorde como *Mi Menor* tocado na terceira oitava.

en: Accessing a List
pt-BR: Acessando uma lista

en: Another very useful feature of a list is the ability to get information out of it. This may sound a bit strange, but it's no more complicated than someone asking you to turn a book to page 23. With a list, you'd say, what's the element at index 23? The only strange thing is that in programming indexes usually start at 0 not 1.
pt-BR: Uma outra característica muito útil de uma lista é a habilidade de receber informações dela. Isso pode parecer estranho, mas não é mais complicado do que alguém pedindo para você abrir um livro na página 23. Com uma lista, você pode dizer, qual é o elemento no índice 23? A única coisa estranha é que na programação os índices geralmente começam em 0 e não em 1.

en: With list indexes we don't count 1, 2, 3... Instead we count 0, 1, 2...
pt-BR: Nos índices de listas nós não contamos 1, 2, 3... Nós contamos 0, 1, 2...

en: Let's look at this in a little more detail. Take a look at this list:
pt-BR: Vamos ver isto com um pouco mais de detalhe. Dê uma olhada nesta lista:

en: There's nothing especially scary about this. Now, what's the second element in that list? Yes, of course, it's `55`. That was easy. Let's see if we can get the computer to answer it for us too:
pt-BR: Não há nada especialmente assustador nisso. Agora, qual é o segundo elemento da lista? Sim, claro, é o `55`. Isso foi fácil. Vamos ver se conseguimos fazer o computador responder isso por nós, também:

en: OK, that looks a bit weird if you've never seen anything like it before. Trust me though, it's not too hard. There are three parts to the line above: the word `puts` , our list `52, 55, 59` and our index `[1]`. Firstly we're saying `puts` because we want Sonic Pi to print the answer out for us in the log. Next, we're giving it our list, and finally our index is asking for the second element. We need to surround our index with square brackets and because counting starts at `0`, the index for the second element is `1`. Look:
pt-BR: OK, isso pode parecer um pouco estranho se você nunca tinha visto nada com isso antes. Acredite em mim, não e nada difícil. Existem 3 partes na linha acima: a palavra `puts`, a nossa lista `52, 55, 59` e o nosso índice`[1]`. Inicialmente estamos dizendo `puts` porque queremos que o Sonic Pi imprima a resposta para nós, no registro. Em seguida, nós estamos fornecendo nossa lista, e finalmente nosso índice está pedindo o segundo elemento. A contagem começa em `0`, o índice do segundo elemento é `1` (0=primeiro; 1=segundo; 2=terceiro; ...). Devemos colocar nosso índice dentro de colchetes. Veja:

en: # indexes:  0   1   2
               [52, 55, 59]
pt-BR: # índices:  0   1   2
               [52, 55, 59]

en: Try running the code `puts [52, 55, 59][1]` and you'll see `55` pop up in the log. Change the index `1` to other indexes, try longer lists and think about how you might use a list in your next code jam. For example, what musical structures might be represented as a series of numbers...
pt-BR: Tente executar o código `puts [52, 55, 59][1]` e você verá `55` aparecer no log. Mude o índice `1` para outros índices, tente com listas maiores e pense em como você pode usar listas na sua próxima apresentação. Por exemplo, que estruturas musicais podem ser representadas como uma série de números...

en: 8.2 Chords
pt-BR: 8.2 Acordes

en: Sonic Pi has built-in support for chord names which will return lists. Try it for yourself:
pt-BR: O Sonic Pi possui suporte para nomes de acordes que devolverão listas. Tente você mesmo:

en: Now, we're really getting somewhere. That looks a lot more pretty than the raw lists (and is easier to read for other people). So what other chords does Sonic Pi support? Well, a *lot*. Try some of these:
pt-BR: Agora estamos chegando em algum lugar. Isso parece muito mais bonito que listas brutas (e são mais fáceis de ler para outras pessoas). Então quais outros acordes o Sonic Pi suporta? Bem, *muitos*. Tente alguns destes:

en: Arpeggios
pt-BR: Arpejos

en: We can easily turn chords into arpeggios with the function `play_pattern`:
pt-BR: Podemos facilmente transformar acordes em arpejos com a função `play_pattern`:

en: Ok, that's not so fun - it played it really slowly. `play_pattern` will play each note in the list separated with a call to `sleep 1` between each call to `play`. We can use another function `play_pattern_timed` to specify our own timings and speed things up:
pt-BR: Ok, isto não é muito divertido - tocou muito devagar. `play_pattern` irá tocar cada nota na lista separada por uma chamada a `sleep 1` entre cada chamada a `play`. Podemos usar outra função `play_pattern_timed` para especificar o nosso próprio tempo e acelerar as coisas:

en: We can even pass a list of times which it will treat as a circle of times:
pt-BR: Podemos até passar uma lista de tempos que serão tratados como um circulo de tempos:

en: This is the equivalent to:
pt-BR: Isto é equivalente a:

en: Which would you prefer to write?
pt-BR: Qual você prefere escrever?

en: 8.3 Scales
pt-BR: 8.3 Escalas

en: Scales
pt-BR: Escalas

en: Sonic Pi has support for a wide range of scales. How about playing a C3 major scale?
pt-BR: O Sonic Pi suporta uma grande variedade de escalas. Que tal tocar uma escala de Dó Maior na 3 oitava?

en: We can even ask for more octaves:
pt-BR: Podemos até pedir mais oitavas:

en: How about all the notes in a pentatonic scale?
pt-BR: Que tal todas as notas de uma escala pentatônica?

en: Random notes
pt-BR: Notas aleatórias

en: Chords and scales are great ways of constraining a random choice to something meaningful. Have a play with this example which picks random notes from the chord E3 minor:
pt-BR: Acordes e escalas são ótimas formas para restringir as escolhas aleatórias para algo significativo. Divirta-se com este exemplo que pega notas aleatórias do acorde Mi3 menor:

en: Try switching in different chord names and cutoff ranges.
pt-BR: Tente mudar para nomes de acordes diferentes e amplitudes de corte.

en: Discovering Chords and Scales
pt-BR: Descobrindo Acordes e Escalas

en: To find out which scales and chords are supported by Sonic Pi simply click the Lang button on the far left of this tutorial and then choose either chord or scale in the API list. In the information in the main panel, scroll down until you see a long list of chords or scales (depending on which you're looking at).
pt-BR: Para saber quais escalas e acordes são suportados pelo Sonic Pi simplesmente clique no botão Lang, na esquerda extrema deste tutorial e escolha acorde ou escala na lista de API. Na informação do painel principal, role para baixo até ver uma longa lista de acordes ou escalas (dependendo de qual página você estiver vendo).

en: Have fun and remember: there are no mistakes, only opportunities.
pt-BR: Divirta-se e lembre-se, não existem erros, apenas oportunidades.

en: 9 Live Coding
pt-BR: 9. Live Coding (Programação ao vivo)

en: One of the most exciting aspects of Sonic Pi is that it enables you to write and modify code live to make music, just like you might perform live with a guitar. One advantage of this approach is to give you more feedback whilst composing (get a simple loop running and keep tweaking it till it sounds just perfect). However, the main advantage is that you can take Sonic Pi on stage and gig with it.
pt-BR: Um dos aspectos mais empolgantes do Sonic Pi é que ele te permite escrever e modificar código ao vivo para criar música, da mesma forma que você pode se apresentar ao vivo com uma guitarra. Uma vantagem desta abordagem é te dar mais feedback durante a composição (deixar um loop simples executando e continuar ajustando-o até que ele soe perfeitamente). Entretanto, a maior vantagem é que você pode levar o Sonic Pi para o palco e tocar com ele.

en: In this section we'll cover the fundamentals of turning your static code compositions into dynamic performances.
pt-BR: Nesta seção cobriremos os fundamentos para tornar suas composições de código estático em performances dinâmicas.

en: Hold on to your seats...
pt-BR: Segurem-se em seus assentos...

en: 9.1 Live Coding Fundamentals
pt-BR: 9.1 Fundamentos do Live coding

en: Now we've learned enough to really start having some fun. In this section we'll draw from all the previous sections and show you how you can start making your music compositions live and turning them into a performance. For that we'll need 3 main ingredients:
pt-BR: Agora nós já aprendemos o suficiente para realmente começar a ter alguma diversão. Nesta seção nós iremos buscar itens de todas as seções anteriores e te mostrar como você pode começar a criar suas composições musicais ao vivo e transformá-las em uma performance. Para isso precisamos de 3 ingredientes principais:

en: An ability to write code that makes sounds - CHECK!
pt-BR: Habilidade para escrever código que gere som - CHECK!

en: An ability to write functions - CHECK!
pt-BR: Habilidade para escrever funções - CHECK!

en: An ability to use (named) threads - CHECK!
pt-BR: Habilidade para usar threads (nomeados) - CHECK!

en: Alrighty, let's get started. Let's live code our first sounds. We first need a function containing the code we want to play. Let's start simple. We also want to loop calls to that function in a thread:
pt-BR: Tudo bem, vamos começar. Vamos programar ao vivo nossos primeiros sons. Primeiro precisamos de uma função contendo o código que desejamos tocar. Vamos começar de forma simples. Nós também queremos chamar esta função em Loop, dentro de uma thread:

en: If that looks a little too complicated to you, go back and re-read the sections on functions and threads. It's not too complicated if you've already wrapped your head around these things.
pt-BR: Se isto está parecendo muito complicado para você, volte e releia as seções sobre funções e threads. Não será complicado se você já tiver estudado estes itens.

en: If you run this code, you'll hear note 50 repeating again and again...
pt-BR: Se você executar este código, você ouvirá a nota 50 repetindo e repetindo e repetindo...

en: Changing it up
pt-BR: Modificando

en: Now, this is where the fun starts. Whilst the code is *still running* change 50 to another number, say 55, then press the Run button again. Woah! It changed! Live!
pt-BR: Agora é que a diversão começa. Com o código *ainda executando*, modifique o 50 para um outro número, 55 por exemplo, e então pressione o botão Run outra vez. WOW! Mudou! Ao vivo!

en: Try changing it again, change the note, change the sleep time. How about adding a `use_synth` statement? For example, change it to:
pt-BR: Tente modificar novamente, mude a nota, mude o tempo de descanso. Que tal adicionar um comando `use_synth`? Por exemplo, mude-o para:

en: Now it sounds pretty interesting, but we can spice it up further. Instead of playing the same note again and again, try playing a chord:
pt-BR: Agora isso soa bem interessante, mas nós podemos apimentar um pouco mais as coisas. Em vez de tocar sempre a mesma nota, tente tocar um acorde:

en: How about playing random notes from the chord:
pt-BR: Que tal tocar notas aleatórias do acorde:

en: Or using a random cutoff value:
pt-BR: Ou usar um valor aleatório para cutoff:

en: Finally, add some drums:
pt-BR: Finalmente, adicione alguma bateria:

en: Now things are getting exciting!
pt-BR: Agora as coisas estão ficando excitantes!

en: However, before you jump up and start live coding with functions and threads, stop what you're doing and read the next section on `live_loop` which will change the way you code in Sonic Pi forever...
pt-BR: Entretanto, antes de pular e começar a programar ao vivo com funções e threads, pare o que você está fazendo e leia a próxima seção sobre `live_loop` que irá mudar a forma como programa no Sonic Pi para sempre...

en: 9.2 Live Loops
pt-BR: 9.2 Live Loops (loops ao vivo)

en: Live Loops
pt-BR: Live Loops (loops ao vivo)

en: Ok, so this section of the tutorial is the real gem. If you only read one section, it should be this one. If you read the previous section on Live Coding Fundamentals, `live_loop` is a simple way of doing exactly that but without having to write so much.
pt-BR: Ok, esta seção do tutorial é joia verdadeira. Se você tiver que ler somente uma seção, que seja esta. Se você leu a seção anterior sobre os Fundamentos do Live Coding, `live_loop` é uma forma simples de fazer exatamente isso, mas sem ter que escrever tanto.

en: If you didn't read the previous section, `live_loop` is the best way to jam with Sonic Pi.
pt-BR: Se você não leu a seção anterior, `live_loop`é a melhor maneira de improvisar com o Sonic Pi.

en: Let's play. Write the following in a new buffer:
pt-BR: Vamos tocar. Escreva o seguinte em um buffer novo:

en: live_loop :foo do
      play 60
      sleep 1
    end
pt-BR: live_loop :foo do
      play 60
      sleep 1
    end
    #

en: Now press the Run button. You hear a basic beep every beat. Nothing fun there. However, don't press Stop just yet. Change the `60` to `65` and press Run again.
pt-BR: Agora pressione o botão Run. Você irá ouvir um beep básico a cada batida. Nada divertido isso. Entretanto, não pressione Stop ainda. Mude o `60` para `65` e clique no Run outra vez.

en: Woah! It changed *automatically* without missing a beat. This is live coding.
pt-BR: WOW! Mudou *automaticamente* sem perder a batida. Isto é Live coding.

en: Why not change it to be more bass like? Just update your code whilst it's playing:
pt-BR: Por que não mudar para algo mais parecido com um baixo? Somente atualize seu código enquanto ele está tocando:

en: Then hit Run.
pt-BR: Então pressione Run.

en: Let's make the cutoff move around:
pt-BR: Vamos fazer o 'cutoff' variar aleatoriamente:

en: Hit Run again.
pt-BR: Pressione o botão Run outra vez.

en: Add some drums:
pt-BR: Adicione alguma bateria:

en: live_loop :foo do
      sample :loop_garzul
      use_synth :prophet
      play :e1, release: 8, cutoff: rrand(70, 130)
      sleep 8
    end
pt-BR: live_loop :foo do
      sample :loop_garzul
      use_synth :prophet
      play :e1, release: 8, cutoff: rrand(70, 130)
      sleep 8
    end
    #

en: Change the note from `e1` to `c1`:
pt-BR: Mude a nota de `e1` para `c1`:

en: live_loop :foo do
      sample :loop_garzul
      use_synth :prophet
      play :c1, release: 8, cutoff: rrand(70, 130)
      sleep 8
    end
pt-BR: live_loop :foo do
      sample :loop_garzul
      use_synth :prophet
      play :c1, release: 8, cutoff: rrand(70, 130)
      sleep 8
    end
    #

en: Now stop listening to me and play around yourself! Have fun!
pt-BR: Agora pare de me ouvir e vá tocar você mesmo! Divirta-se!

en: 9.3 Multiple Live Loops
pt-BR: 9.3 Múltiplos Live Loops

en: Multiple Live Loops
pt-BR: Múltiplos Live Loops

en: Consider the following live loop:
pt-BR: Considere o seguinte live loop:

en: You may have wondered why it needs the name `:foo`. This name is important because it signifies that this live loop is different from all other live loops.
pt-BR: Você pode estar se perguntando por que precisa do nome `:foo`. Este nome é importante porque significa que este live loop é diferente de todos os outros live loops.

en: *There can never be two live loops running with the same name*.
pt-BR: *Nunca pode haver dois live loops sendo executados com o mesmo nome*.

en: This means that if we want multiple concurrently running live loops, we just need to give them different names:
pt-BR: Isso quer dizer que se quisermos múltiplos live loops concorrentes, teremos que dar nomes diferentes a eles:

en: You can now update and change each live loop independently and it all just works.
pt-BR: Agora você pode atualizar e modificar cada live loop independentemente e tudo simplesmente funciona.

en: Syncing Live Loops
pt-BR: Sincronizando live loops

en: One thing you might have already noticed is that live loops work automatically with the thread cue mechanism we explored previously. Every time the live loop loops, it generates a new `cue` event with the name of the live loop. We can therefore `sync` on these cues to ensure our loops are in sync without having to stop anything.
pt-BR: Uma coisa que você já deve ter notado é que live loops funcionam automaticamente com o mecanismo de cue do thread que exploramos anteriormente.

en: Consider this badly synced code:
pt-BR: Considere este código mal sincronizado:

en: Let's see if we can fix the timing and sync without stopping it. First, let's fix the `:foo` loop to make the sleep a factor of 1 - something like `0.5` will do:
pt-BR: Vejamos se conseguimos corrigir o tempo e sincronismo sem pará-lo. Primeiro vamos consertar o loop `:foo` para fazê-lo soar em um fator múltiplo do tempo do outro loop - algo como `0.5` servirá:

en: We're not quite finished yet though - you'll notice that the beats don't quite line up correctly. This is because the loops are *out of phase*. Let's fix that by syncing one to the other:
pt-BR: Ainda não terminamos - você irá notar que as batidas não se alinham corretamente. Isso acontece porque os loops estão *fora de fase*. Vamos corrigir isso sincronizando um com o outro:

en: Wow, everything is now perfectly in time - all without stopping.
pt-BR: Wow, agora tudo está perfeitamente no tempo - tudo sem parar.

en: Now, go forth and live code with live loops!
pt-BR: Agora vá em frente e programe ao vivo com live loops!

en: 10.1 Set and Get
pt-BR: 10.1 Set e Get

en: Set and Get
pt-BR: Set e Get

en: ## An Example of Non-Deterministic Behaviour
    ## (due to race conditions caused by multiple
    ## live loops manipulating the same variable
    ## at the same time).
    ##  
    ## If you run this code you'll notice
    ## that the list that's printed is
    ## not always sorted!
    a = (ring 6, 5, 4, 3, 2, 1)
    live_loop :shuffled do
      a = a.shuffle
      sleep 0.5
    end
    live_loop :sorted do
      a = a.sort
      sleep 0.5
      puts "sorted: ", a
    end
pt-BR: ## Um exemplo de comportamento não-determinístico
    ## (devido a race conditions causadas por múltiplos
    ## loops manipulando a mesma variárvel ao mesmo tempo).
    ##  
    ## Se você executar este código você notará
    ## que a lista que é impressa
    ## nem sempre sai ordenada!
    a = (ring 6, 5, 4, 3, 2, 1)
    live_loop :shuffled do
      a = a.shuffle
      sleep 0.5
    end
    live_loop :sorted do
      a = a.sort
      sleep 0.5
      puts "sorted: ", a
    end

en: ## An Example of Deterministic Behaviour
    ## (despite concurrent access of shared state)
    ## using Sonic Pi's new Time State system.
    ##
    ## When this code is executed, the list that's
    ## printed is always sorted!
    set :a, (ring 6, 5, 4, 3, 2, 1)
    live_loop :shuffled do
      set :a, get[:a].shuffle
      sleep 0.5
    end
    live_loop :sorted do
      set :a, get[:a].sort
      sleep 0.5
      puts "sorted: ", get[:a]
    end
pt-BR: ## Um exemplo de comportamento determinístico
    ## (apesar do acesso simultâneo ao estado compartilhado)
    ## usando o novo sistema Time State do Sonic Pi.
    ##
    ## Quando este código é executado, a lista
    ## sempre é impressa de forma ordenada!
    set :a, (ring 6, 5, 4, 3, 2, 1)
    live_loop :shuffled do
      set :a, get[:a].shuffle
      sleep 0.5
    end
    live_loop :sorted do
      set :a, get[:a].sort
      sleep 0.5
      puts "sorted: ", get[:a]
    end

en: 10.2 Sync
pt-BR: 10.2 Sincronização (Sync)

en: Sync
pt-BR: Sincronização (Sync)

en: Section 5.7 introduced the functions `cue` and `sync` when dealing with the issue of synchronising threads. What it didn't explain was that it is the Time State system which provides this functionality. It just so happens that `set` is actually a variation of `cue` and is built on top of the same core functionality which is to insert information into the Time State system. Additionally, `sync` is also designed in such a way that it works seamlessly with Time State - any information that we plan to store in Time State we can sync on. In other words - *we `sync` on events yet to be inserted into Time State*.
pt-BR: A seção 5.7 introduziu as funções `cue` e `sync` para lidar com problemas de sincronização de threads. O que não foi explicado é que é o sistema de Time State que fornece esta funcionalidade. É de tal forma que `set` is na realidade uma variação de `cue`e foi construído de forma que que possa trabalhar perfeitamente com o Time State - qualquer informaçãoque nós planejamos armazenar no Time State nós podemos sincronizar. Em outras palavras - *nós sincronizamos `sync`eventos que ainda serão inseridos no Time State*.

en: Waiting for Events
pt-BR: Aguardando por eventos

en: Let's take a quick look at how to use `sync` to wait for new events to be added to Time State:
pt-BR: Vamos dar uma olhada em como usar `sync` para esperar por novos eventos que serão inseridos ao Time State:

en: In this example first we create a thread which waits for a `:foo` event to be added to the Time State. After this thread declaration we sleep for 2 beats and then `set` `:foo` to be `1`. This then releases the `sync` which then moves to the next line which is to trigger the `:ambi_lunar_land` sample.
pt-BR: Neste exemplo nós primeiro criamos uma thread que espera um evento `:foo` ser adicionado ao Time State. Após a declaração desta thread, nós esperamos por 2 batidas e então setamos (`set`) `:foo` para ser `1`. Isso libera a sincronização (`sync`) que então segue para a próxima linha que dispara a amostra `:ambi_lunar_land`.

en: Note that `sync` always waits for *future events* and that it will block the current thread waiting for a new event. Also, it will inherit the logical time of the thread which triggered it via `set` or `cue` so it may also be used to sync time.
pt-BR: Note que `sync` sempre espera por *eventos futuros* e isso irá bloquear a a thread atual esperando por um novo evento. Também, irá herdar o tempo lógico da thread que chamou a sincronização através de `set` ou `cue` então pode também ser usado para sincronizar tempo.

en: Passing values into the Future
pt-BR: Passando valores para o Futuro

en: In the example above we set `:foo` to `1` which we did nothing with. We can actually get this value from the thread calling `sync`:
pt-BR: No exemplo acima nós configuramos `:foo` igual a `1` e não fizemos nada com isso. Nós podemos, na verdade, recuperar este valor na thread chamando `sync`:

en: in_thread do
      amp = sync :foo
      sample :ambi_lunar_land, amp: amp
    end
    sleep 2
    set :foo, 0.5
pt-BR: in_thread do
      amp = sync :foo 
      sample :ambi_lunar_land, amp: amp
    end
    sleep 2
    set :foo, 0.5

en: Note that values that are passed through `set` and `cue` must be thread safe - i.e. immutable rings, numbers, symbols or frozen strings. Sonic Pi will throw an error if the value you are attempting to store in the Time State is not valid.
pt-BR: Note que valores que são passados através de `set` e `cue` devem ser seguros - i.e. Rings imutáveis, números, símbolos ou strings congeladas. O Sonic Pi irá gerar um erro se o valor que você está tentando armazenar no Time State não for válido.

en: 10.3 Pattern Matching
pt-BR: 10.3 Correspondência de Padrões

en: Pattern Matching
pt-BR: Correspondência de Padrões

en: When getting and setting information into the Time State, it's possible to use more complex keys than basic symbols such as `:foo` and `:bar`. You can also use URL style strings called paths such as `"/foo/bar/baz"`. Once we start working with paths, we can then start taking advantage of Sonic Pi's sophisticated pattern matching system to `get` and `sync` with 'similar' rather than 'identical' paths. Let's take a look.
pt-BR: Para passar e recuperar informações para o Time State, é possível usar chaves mais complexas que símbolos básicos como `:foo` e `:bar`. Você também pode usar strings no formato URL, chamadas de Paths (caminhos) como `"/foo/bar/baz"`. Depois que começãmos a usar paths, nós podemos começar a aproveitar o sofisticado sistema de correspondência de Padrões do Sonic Pi para usar `get` e `sync` com paths 'similares' em vez de 'idênticos'. Vamos dar uma olhada.

en: Match any path segment
pt-BR: Correspondência com qualquer parte do caminho (path)

en: Let's assume we want to wait for the next event that has three path segments:
pt-BR: Vamos assumir que nós queiramos esperar pelo próximo evento que tem três segmentos no path:

en: This will match any Time State event with exactly three path segments, regardless of their names. For example:
pt-BR: Isto irá corresponder a qualquer evento Time State com exatamente três segmento, independente de seus nomes. Por exemplo:

en: However, it will *not* match paths with fewer or more path segments. The following will not match:
pt-BR: Entretanto, *não* irá corresponder a paths com menos ou mais segmentos. Os seguintes paths não serão localizados:

en: Each `*` means *any content*. So we could match paths with just one segment with `/*` or paths with five segments with `/*/*/*/*/*`
pt-BR: Cada `*` (asterisco) significa *qualquer conteúdo*. Então nós podemos encontrar paths com somente um segmento com `/*` ou paths com cinco segmentos com `/*/*/*/*/*`

en: Matching partial segments
pt-BR: Encontrando segmentos parciais

en: If we know what the segment is going to start or finish with, we can use a `*` in addition to a partial segment name. For example: `"/foo/b*/baz"` will match any path that has three segments, the first of which is `foo`, the last `baz` and the middle segment can be anything that starts with `b`. So, it would match:
pt-BR: Se soubermos como o segmento irá começar ou terminar, nós podemos usar um asterisco `*` junto com o nome parcial do segmento. Por exemplo: `"/foo/b*/baz"` irá corresponder a qualquer path com três segmentos, onde o primeiro é `foo`, o último é `baz` e o segmento do meio pode ser qualquer coisa que comece com `b`. Então irá corresponder a:

en: However, it wouldn't match the following:
pt-BR: Mas não irá corresponder a:

en: You can also place the `*` at the start of the segment to specify the last characters of a segment: `"/foo/*zz/baz"` which will match any 3 segment `cue` or `set` where the first segment is `foo`, the last is `baz` and the middle segment ends with `zz` such as `"cue "/foo/whizz/baz"`.
pt-BR: Você pode colocar o `*` no início do segmento para especificar os últimos caracteres de um segmento: `"/foo/*zz/baz"` que iráo corresponder a quaisquer 3 segmentos `cue` ou `set` onde o primeiro segmento for `foo`, o último for `baz` e o segmento do meio termine com `zz`, como `"cue "/foo/whizz/baz"`.

en: Matching Nested Path Segments
pt-BR: Encontrando correspondências em segmentos de paths aninhados

en: Sometimes you don't know how many path segments you want to match. In these cases you can use the powerful double star: `**` such as `"/foo/**/baz"` which will match:
pt-BR: As vezes você não sabe quantos segmentos do path você quer achar a correspondência. Nestes casos, você pode usar os poderosos duplos asteriscos: `**` como em `"/foo/**/baz"` que irão corresponder a:

en: Matching Single Letters
pt-BR: Correspondendo a Letras Sozinhas

en: You can use the `?` character to match against a single char such as `"/?oo/bar/baz"` which will match:
pt-BR: Você pode usar o caracter `?` para comparar com um caracter apenas, como em `"/?oo/bar/baz"` que irá corresponder a:

en: Matching Multiple Words
pt-BR: Correspondendo a Múltiplas Palavras

en: If you know that a segment may be one of a select number of words, you can use the `{` and `}` matchers to specify a list of choices such as `"/foo/{bar,beans,eggs}/quux"` which will only match the following:
pt-BR: Se você sabe que um segmento pode ser uma palavra de um certo conjunto de palavras, você pode usar `{` e `}` para especificar uma lista de opções como em `"/foo/{bar,beans,eggs}/quux"` que irão corresponder aos seguintes padrões:

en: Matching Multiple Letters
pt-BR: Correspondendo a Múltiplas Letras

en: Finally, you can match against a selection of letters if you use the `[` and `]` matchers to specify a list of choices such as `"/foo/[abc]ux/baz"` which will match only:
pt-BR: Por fim, você pode comparar com uma seleção de letras se você usar `[` e `]` para especificar uma lista de possibilidades como em `"/foo/[abc]ux/baz"` que irá corresponder somente a:

en: You can also use the `-` character to specify ranges of letters. For example `"/foo/[a-e]ux/baz"` which will match only:
pt-BR: Você também pode utilizar o caracter `-` para especificar sequências de letras. Por exemplo`"/foo/[a-e]ux/baz"` que irá corresponder somente a:

en: Combining Matchers
pt-BR: Combinando Correspondências

en: When calling `sync` or `get` you are free to combine matchers in any order you see fit to powerfully match any Time State event created by `cue` or `set`. Let's look at a crazy example:
pt-BR: Ao chamar `sync` ou `get` você está livre para combinar localizadores de correspondência em qualquer ordem que você achar necessário para 
    encontrar qualquer evento Time State criado por `cue` ou `set`. Vamos ver um exemplo doido:

en: OSC Pattern Matching
pt-BR: Correspondência de Padrões OSC

en: For those curious, these matching rules are based on the Open Sound Control pattern matching specification which is explained in detail here: http://opensoundcontrol.org/spec-1_0
pt-BR: Para os curiosos, estas regras de correspondência são baseados na especificação de correspondência de padrões do Open Sound Control (controle de som aberto), que é explicado com detalhes em: http://opensoundcontrol.org/spec-1_0

en: 11 MIDI
pt-BR: 11. MIDI

en: Once you've mastered converting code to music, you might wonder - what's next? Sometimes the constraints of working purely within Sonic Pi's syntax and sound system can be exciting and put you into a new creative position. However, sometimes it is essential to break out of the code into the real world. We want two extra things:
pt-BR: Uma vez que você tiver dominado a conversão de código em música, você pode pensar - o que vem depois? As vezes, as limitações de trabalhar puramente dentro da sintaxe e do sistema de som do Sonic Pi podem ser excitantes e te colocar em uma nova posição criativa. Entretanto, as vezes é essencial libertar o código para o mundo real. Não queremos duas coisas extras:

en: To be able to convert actions in the real world into Sonic Pi events to code with
pt-BR: Sermos capazes de converter ações do mundo real em eventos codificáveis do Sonic Pi

en: To be able to use Sonic Pi's strong timing model and semantics to control and manipulate objects in the real world
pt-BR: Sermos capazes de usar o forte modelo de temporização e semântica do Sonic Pi para controlar e manipular objetos no mundo real

en: Luckily there's a protocol that's been around since the 80s that enables exactly this kind of interaction - MIDI. There's an incredible number of external devices including keyboards, controllers, sequencers, and pro audio software that all support MIDI. We can use MIDI to receive data and also use it to send data.
pt-BR: Por sorte, existe um protocolo que está por aí desde os anos 80, que permite este tipo de interação - MIDI. Existe um número incrível de aparelhos externos, incluindo teclados, controladores, sequenciadores e software profissional que suportam MIDI. Nós podemos usar o MIDI para receber dados e também para enviar dados.

en: Sonic Pi provides full support for the MIDI protocol enabling you to connect your live code to the real world. Let's explore it further...
pt-BR: O Sonic Pi fornece suporte completo para o protocolo MIDI possibilitando que você conecte seu Código Ao Vivo com o mundo real. Vamos explorá-lo um pouco mais...

en: 11.1 MIDI In
pt-BR: 11.1 Entrada MIDI

en: MIDI In
pt-BR: Entrada MIDI

en: In this section we will learn how to connect a MIDI controller to send events into Sonic Pi to control our synths and sounds. Go and grab a MIDI controller such as a keyboard or control surface and let's get physical!
pt-BR: Nesta seção vamos aprender como conectar um controlador MIDI para enviar eventos para o Sonic Pi, para controlar nossos sintetizadores e sons. Vá e pegue um controlador MIDI, como um teclado ou tablet de controle e vamos começar!

en: Connecting a MIDI Controller
pt-BR: Conectando um controlador MIDI

en: Receiving MIDI Events
pt-BR: Recebendo eventos MIDI

en: Once your device is connected, Sonic Pi will automatically receive events. You can see for yourself by manipulating your MIDI device and looking at the cue logger in the bottom right of the application window below the log (if this isn't visible go to Preferences->Editor->Show & Hide and enable the 'Show cue log' tickbox). You'll see a stream of events such as:
pt-BR: Assim que seu aperelho esteja conectado, o Sonic Pi irá receber eventos automaticamente. Você mesmo pode confirmar manipulando seu aparelho MIDI e olhando no registro de Deixas (cue logger), na janela do app em baixo à direita, abaixo do registro (se isso não estiver visível, vá em Preferências > Editor > Mostrar & Ocultar e habilite a caixa 'Mostrar o registro de deixas'). Você verá um fluxo de eventos como:

en: Once you can see a stream of messages like this, you've successfully connected your MIDI device. Congratulations, let's see what we can do with it!
pt-BR: Quando você ver um fluxo de mensagens desta forma, você terá conectado com sucesso seu aparelho MIDI. Parabéns, vamos ver o que você consegue fazer com ele!

en: Controlling Code
pt-BR: Controlando o Código

en: Now we've connected a MIDI device, seen its events in the cue log and discovered that our knowledge of Time State is all we need to work with the events, we can now start having fun. Let's build a simple MIDI piano:
pt-BR: Agora que você conectou seu aparelho MIDI, viu seus eventos no registro e descobriu que nosso conhecimento do Estado de Tempo (Time State) é tudo o que precisamos para trabalhar com eventos, podemos começar a nos divertir. Vamos construir um piano MIDI simples:

en: There's a few things going on in the code above including some issues. Firstly, we have a simple `live_loop` which will repeat forever running the code between the `do`/`end` block. This was introduced in Section 9.2. Secondly, we're calling `sync` to wait for the next matching Time State event. We use a string representing the MIDI message we're looking for (which is the same as was displayed in the cue logger). Notice that this long string is provided to you by Sonic Pi's autocompletion system, so you don't have to type it all out by hand. In the log we saw that there were two values for each MIDI note on event, so we assign the result to two separate variables `note` and `velocity`. Finally we trigger the `:piano` synth passing our note.
pt-BR: Temos algumas coisas acontecendo no código acima, incluindo alguns problemas. Primeiro, temos um `live_loop` simples, que irá se repetir para sempre, executando o código entre os blocos `do`/`end`. Isto foi apresentado na seção 9.2. Segundo, estamos chamando o comando `sync` para esperar pelo próximo evento  Time State correspondente. Usamos uma string representando a mensagem MIDI que estamos procurando (que é a mesma que foi exibida no registro). Note que esta string longa é fornecida pela função autocompletar do Sonic Pi, desta forma você não precisa digitar tudo a mão. No registro nós vemos que haviam dois valorespara cada nota MIDI no evento, então nós atribuímos o resultado a duas variáveis `note` e `velocity`. Por fim, nós disparamos o sintetizador `:piano` passando nossa nota.

en: Now, you try it. Type in the code above, replace the sync key with a string matching your specific MIDI device and hit Run. Hey presto, you have a working piano! However, you'll probably notice a couple of problems: firstly all the notes are the same volume regardless of how hard you hit the keyboard. This can be easily fixed by using the velocity MIDI value and converting it to an amplitude. Given that MIDI has a range of 0->127, to convert this number to a value between 0->1 we just need to divide it by 127:
pt-BR: Agora tente você. Digite o código acima, substitua a chave de sincronização com uma string correspondente ao seu aparelho MIDI e clique em Executar. Pronto, você tem um piano funcionando! Entretanto, você provavelmente notará alguns problemas: primeiro, todas as notas possuem o mesmo volume, independente da força que você usa no teclado. Isso pode ser consertado facilmente usando o valor velocity do MIDI e convertendo-o para amplitude. Dado que MIDI possui uma variação entre 0 e 127, para converter este número para um valor entre 0 e 1 nós só precisamos dividi-lo por 127:

en: Update the code and hit Run again. Now the velocity of the keyboard is honoured. Next, let's get rid of that pesky pause.
pt-BR: Atualize o código e clique em Executar novamente. Agora a força aplicada ao teclado é respeitada. Em seguida, vamos nos livrar desta pausa irritante.

en: Removing Latency
pt-BR: Removendo a Latência

en: Before we can remove the pause, we need to know why it's there. In order to keep all the synths and FX well-timed across a variety of differently capable CPUs, Sonic Pi schedules the audio *in advance* by 0.5s by default. (Note that this added latency can be configured via the fns `set_sched_ahead_time!` and `use_sched_ahead_time`). This 0.5s latency is being added to our `:piano` synth triggers as it is added to all synths triggered by Sonic Pi. Typically we really want this added latency as it means all synths will be well timed. However, this only makes sense for synths triggered by code using `play` and `sleep`. In this case, we're actually triggering the `:piano` synth with our external MIDI device and therefore don't want Sonic Pi to control the timing for us. We can turn off this latency with the command `use_real_time` which disables the latency for the current thread. This means you can use real time mode for live loops that have their timing controlled by `sync`ing with external devices, and keep the default latency for all other live loops. Let's see:
pt-BR: Antes de remover a pausa, nós precisamos entender porque ela acontece. Para manter todos os sintetizadores e Efeitos sincronizados através de uma variedade de CPUs com capacidades diferentes, o Sonic Pi agenda o áudio *antecipadamente* em 0.5s por padrão.  (Note que esta latência adicional pode ser configurada pelas funções `set_sched_ahead_time!` e `use_sched_ahead_time`). Estes 0.5s de latência estão sendo adicionados ao disparador do nosso sintetizador `:piano` assim como está sendo adicionado a todos os sintetizadores disparados pelo Sonic Pi. Tipicamente nós realmente queremos manter esta latência, já que isso significa que todos os sintetizadores estarão sincronizados. Entretanto, isso só faz sentindo para sintetizadores disparados por código, usando `play` e `sleep`. No nosso caso, na realidade estamos disparando o sintetizador `:piano` pelo nosso aparelho MIDI e portanto não queremos que o Sonic Pi controle o tempo por nós. Podemos desligar esta latência com o comando `use_real_time`, que desabilita a latência para a thread atual. Isto significa que você pode usar o modo Real Time para loops ao vivo controlado por `sync` com aparelhos externos, e manter a latência padrâo para todos os outros loops. Vejamos:

en: Update your code to match the code above and hit Run again. Now we have a low latency piano with variable velocity coded in just 5 lines. Wasn't that easy!
pt-BR: Atualize seu código para que ele corresponda ao código acima e clique em 'Executar' novamente. Agora nós temos um piano com baixa latência e sensibilidade variável, programado em apenas 5 linhas.

en: Getting Values
pt-BR: Recuperando valores

en: Finally, as our MIDI events are going straight into the Time State, we can also use the `get` fn to retrieve the last seen value. This doesn't block the current thread and returns `nil` if there's no value to be found (which you can override by passing a default value - see the docs for `get`). Remember that you can call `get` in any thread at any time to see the latest matching Time State value. You can even use `time_warp` to jump back in time and call `get` to see past events...
pt-BR: Finalmente, como nossos eventos MIDI estão indo diretamente para o Time State, nós também podemos usar a função `get` para recuperar o último valor recebido. Isso não bloqueia a thread atual e retorna `nil` se não houver valor para ser recuperado (o que você pode sobrescrever passando um valor padrão - veja a ajuda para `get`). Lembre-se que você pode chamar `get` em qualquer thread a qualquer momento para ver o valor mais recente correspondente ao Time State. Você pode até usar `time_warp` para voltar no tempo e chamar `get` para ver eventos passados...

en: Now You are in Control
pt-BR: Agora Você Está no Controle

en: The exciting thing now is that you can now use the same code structures to `sync` and `get` MIDI information from any MIDI device and do whatever you want with the values. You can now choose what your MIDI device will do!
pt-BR: O mais importante é que agora você pode usar as mesmas estruturas de código para sincronizar e recuperar (`sync` e `get`) informações MIDI de qualquer aparelho MIDI e fazer o que você quiser com os valores. Você pode agora escolher o que seu aparelho MIDI irá fazer!

en: 11.2 MIDI Out
pt-BR: 11.2 Saída MIDI

en: MIDI Out
pt-BR: Saída MIDI

en: In addition to receiving MIDI events we can also send out MIDI events to trigger and control external hardware synths, keyboards and other devices. Sonic Pi provides a full set of fns for sending various MIDI messages such as:
pt-BR: Além de receber eventos MIDI nõs podemos também enviar eventos MIDI para disparar e controlar hardware de sintetizadores externos, teclados e outros aparelho. O Sonic Pi fornece um conjunto completo de funções para enviar várias mensagens MIDI como:

en: Note on - `midi_note_on`
pt-BR: Ligar nota - `midi_note_on`

en: Note off - `midi_note_off`
pt-BR: Desligar nota - `midi_note_off`

en: Control change - `midi_cc`
pt-BR: Mudança de controle - `midi_cc`

en: Pitch bend - `midi_pitch_bend`
pt-BR: Pitch bend  - `midi_pitch_bend`

en: Clock ticks - `midi_clock_tick`
pt-BR: Tiques do relógio - `midi_clock_tick`

en: There are many other supported MIDI messages too - check out the API documentation for all the other fns that start with `midi_`.
pt-BR: Também existem muitas outras mensagens MIDI suportadas - verifique a documentação da API para todas as outras funções que começam com `midi_`.

en: Connecting to a MIDI Device
pt-BR: Conectando um aparelho MIDI

en: Sending MIDI events
pt-BR: Enviando eventos MIDI

en: Selecting a MIDI device
pt-BR: Selecionando um aparelho MIDI

en: A Live Loop Arpeggiator
pt-BR: Um Live Loop Arpegiador

en: The real power comes when you mix `tick` with rings and `live_loop`s. When combined we have all the tools we need to both build and understand a simple arpegiator. We need just four things:
pt-BR: O poder real surge quando você mistura `tick` com anéis (rings) e `live_loop`s. Quando combinados nós temos todas as ferramentas que nós precisamos para tanto construir quanto entender um arpejador simples. Precisamos somente de 4 coisas:

en: A ring containing the notes we want to loop over.
pt-BR: Um anel (ring) contendo as notas que queremos arpejar.

en: A means of incrementing and obtaining the beat.
pt-BR: Uma forma de incrementar e obter a batida.

en: The ability to play a note based on the current beat.
pt-BR: A habilidade de tocar uma nota baseada na batida atual.

en: A loop structure to keep the arpegiator repeating.
pt-BR: Uma estrutura de loop para manter o arpejador repetindo.

en: These concepts can all be found in the following code:
pt-BR: Todos estes conceitos podem ser encontrados no seguinte código:

en: notes = (ring 57, 62, 55, 59, 64)
    live_loop :arp do
      use_synth :dpulse
      play notes.tick, release: 0.2
      sleep 0.125
    end
pt-BR: notes = (ring 57, 62, 55, 59, 64) 
    live_loop :arp do
      use_synth :dpulse
      play notes.tick, release: 0.2
      sleep 0.125
    end

en: notes = (ring 57, 62, 55, 59, 64)
    with_fx :reverb do
      live_loop :arp do
        use_synth :dpulse
        play notes.tick + 12, release: 0.1
        sleep 0.125
      end
    end
    live_loop :arp2 do
      use_synth :dsaw
      play notes.tick - 12, release: 0.2
      sleep 0.75
    end
pt-BR: notes = (ring 57, 62, 55, 59, 64) 
    with_fx :reverb do
      live_loop :arp do
        use_synth :dpulse
        play notes.tick + 12, release: 0.1
        sleep 0.125
      end
    end
    live_loop :arp2 do
      use_synth :dsaw
      play notes.tick - 12, release: 0.2
      sleep 0.75
    end

en: use_bpm 240
    notes = (scale :e3, :minor_pentatonic).shuffle
    live_loop :foo do
      use_synth :blade
      with_fx :reverb, reps: 8, room: 1 do
        tick
        co = (line 70, 130, steps: 32).tick(:cutoff)
        play (octs :e3, 3).look, cutoff: co, amp: 2
        play notes.look, amp: 4
        sleep 1
      end
    end
    live_loop :bar do
      tick
      sample :bd_ada if (spread 1, 4).look
      use_synth :tb303
      co = (line 70, 130, steps: 16).look
      r = (line 0.1, 0.5, steps: 64).mirror.look
      play notes.look, release: r, cutoff: co
      sleep 0.5
    end
pt-BR: use_bpm 240
    notes = (scale :e3, :minor_pentatonic).shuffle
    live_loop :foo do
      use_synth :blade
      with_fx :reverb, reps: 8, room: 1 do
        tick
        co = (line 70, 130, steps: 32).tick(:cutoff)
        play (octs :e3, 3).look, cutoff: co, amp: 2
        play notes.look, amp: 4
        sleep 1
      end
    end 
    live_loop :bar do
      tick
      sample :bd_ada if (spread 1, 4).look
      use_synth :tb303
      co = (line 70, 130, steps: 16).look
      r = (line 0.1, 0.5, steps: 64).mirror.look
      play notes.look, release: r, cutoff: co
      sleep 0.5
    end

en: A.12 Sample Slicing
pt-BR: A.12 Cortando Amostras

en: Sample Slicing
pt-BR: Cortando Amostras

en: Looking at blocks
pt-BR: Olhando os blocos
