APS 1 - Musical - Firmware

A seguir iremos explicar os conceitos e dicas de como vocês deverem prosseguir para executarem esta APS.

Músicas monofonica

Músicas monofonicas¹ são aquelas que só possuem uma única nota tocada por vez, como indicado na partitura a seguir:

ref: wikipidia

A música monofonica tem o som como a seguir:

Esse tipo de música foi muito utilizada nos primeiros videogames, quando a sintetização de músicas ainda estava no começo. Veja como era feito nos Nintendo, aqui já era possível gerar mais de um tom por vez:

Buzzer

Para gerarmos o som é necessário termos algum dispositivo capaz de gerar movimentação no ar, o buzzer é um dispositivo simples que a partir de uma bobina (controlada por um terminal) conseguimos movimentar um disco que por sua vez movimentar o ar. Os buzzers podem ser de duas categorias (piezoelétricos):

• Ativo: basta energizar o terminal que o dispositivo vibra automaticamente em uma determinada frequência, muito usado para alarmes.
• Passivo: Um circuito externo (ou microcontrolador) deve gerar a frequência de vibração, usado para gerar som.

Buzzers são diferentes de altofalantes² em vários aspectos (mecânico, eletromecânico): não necessitam de tensão negativa; possuem um espectro de operação menor; baixa resistência; baixa potência ... .

A conexão do buzzer com um microcontrolador se da por dois pinos: Um conectado no terra (gnd) e outro conectado em um pino que o microcontrolador possui controle, conforme ilustração a seguir:

Gerando som

Podemos fazer com que o buzzer oscile em uma determinada frequência, para isso basta gerarmos um sinal de onda quadrada no terminal positivo do dispositivo, isso irá fazer com que o piezo movimente na mesma frequência, gerando o tom desejado.

Existem diversas maneiras de gerarmos uma onda quadrada em um pino do microcontrolador, a que estamos sugerindo aqui não envolve nenhum periférico específico do microcontrolador, logo iremos fazer tudo por código.

Por exemplo, para gerar uma onda quadrada de 1000 Hz:

while(1){
    pio_set(...);
    delay_us(500);
    pio_clear(...);
    delay_us(500);
}

Música

Eu fiz por anos aula de sax alto e meu professor falava que para começar a tocar uma música bastava: tocar a nota certa no momento certo e não tocar quando não for para tocar, para quem tem prática é fácil, mas para mim não era. Trouxe este assunto para explicar um pouco como iremos reproduzir uma música. Cada música será formada por notas (frequências), pela duração da nota e por um silêncio entre notas (que também tem duração ). Toda essa informação está presente na partitura:

ref: https://www.musicnotes.com/now/tips/how-to-read-sheet-music/

Portanto para reproduzirmos uma música teremos que para cada intervalo de tempo:

1. Reproduzir uma nota (gerar a frequência da nota no pino do buzzer) ou não tocar nada (pausa)
2. Manter a nota/pausa pelo tempo determinado
3. Ir para o próximo intervalo de tempo

Referência

Nesta APS é para utilizarem as músicas fornecidas no repositório a seguir:

• https://github.com/robsoncouto/arduino-songs

Fornecido por: Robson Couto, 2019

Analisando firmware

O desenvolvedor disponibiliza diversas músicas de vários temas diferentes: Filmes, Jogos, Clássicas, ... . Vamos analisar como as músicas são disponibilizadas. Para isso iremos pegar como exemplo a música tema do Mário:

• https://github.com/robsoncouto/arduino-songs/blob/master/supermariobros/supermariobros.ino

Notas

No comece do arquivo temos as definições das notas:

#define NOTE_B0  31
#define NOTE_C1  33
#define NOTE_CS1 35
#define NOTE_D1  37
#define NOTE_DS1 39
#define NOTE_E1  41
#define NOTE_F1  44
#define NOTE_FS1 46
#define NOTE_G1  49
#define NOTE_GS1 52
#define NOTE_A1  55

Música

No arquivo disponível um vetor chamado melody que possui nos index pares (0, 2, ...) as notas e nos index ímpares ( 1, 3, ... ) o tempo de furacão da nota (com base em uma referência).

// notes of the moledy followed by the duration.
// a 4 means a quarter note, 8 an eighteenth , 16 sixteenth, so on
// !!negative numbers are used to represent dotted notes,
// so -4 means a dotted quarter note, that is, a quarter plus an eighteenth!!
int melody[] = {

  // Super Mario Bros theme
  // Score available at https://musescore.com/user/2123/scores/2145
  // Theme by Koji Kondo


  NOTE_E5,8, NOTE_E5,8, REST,8, NOTE_E5,8, REST,8, NOTE_C5,8, NOTE_E5,8, //1
  NOTE_G5,4, REST,4, NOTE_G4,8, REST,4, 
  NOTE_C5,-4, NOTE_G4,8, REST,4, NOTE_E4,-4, // 3
  NOTE_A4,4, NOTE_B4,4, NOTE_AS4,8, NOTE_A4,4,

Tempo

Os tempos são definidos em partes de uma Semibreve/wholenote³ (que é a nota de maior duração), ou seja, o valor 4 refere-se a $¼$ da semibreve, 8 a $⅛$ do tempo total... .

O valor da semibreve/wholenote é definida no próprio código:

// change this to make the song slower or faster
int tempo = 200;

// hide code
// ....

// this calculates the duration of a whole note in ms
int wholenote = (60000 * 4) / tempo;

Valores negativos de tempo (-4, -8, ... ) representam que a nota tem a duração dela mais meio tempo.

No código do repositório, ele implementa o cálculo da duracão da nota da seguinte maneira:

// calculates the duration of each note
divider = melody[thisNote + 1];
if (divider > 0) {
    // regular note, just proceed
    noteDuration = (wholenote) / divider;
} else if (divider < 0) {
    // dotted notes are represented with negative durations!!
    noteDuration = (wholenote) / abs(divider);
    noteDuration *= 1.5; // increases the duration in half for dotted notes
}

• thisNote é o index da nota atual.

// calculates the duration of each note
divider = melody[thisNote + 1];
noteDuration = (wholenote) / abs(divider);
if (divider < 0) {
  noteDuration *= 1.5; // increases the duration in half for dotted notes
}

Reproduzindo

Agora já temos tudo para reproduzir a música, precisamos varrer o vetor melody e para cada nota (index par) gerar a onda quadrada no pino pelo tempo determinado em: noteDuration, para isso definem o tamanho do vetor:

// sizeof gives the number of bytes, each int value is composed of two bytes (16 bits)
// there are two values per note (pitch and duration), so for each note there are four bytes
int notes = sizeof(melody) / sizeof(melody[0]) / 2;

uint32_t foo;
printf("Tamanho foo em bytes: %d \n", sizeof(foo));
// $ Tamanho foo em bytes: 4

uint32_t bar[2];
printf("Tamanho bar em bytes: %d \n", sizeof(bar))
// $ Tamanho bar em bytes: 8

// não podemos fazer isso!
int *foo = malloc(32);
printf("Tamanho bar em bytes: %d \n", sizeof(foo))

E então interage no vetor e reproduz a nota usando a função tone

  // iterate over the notes of the melody.
  // Remember, the array is twice the number of notes (notes + durations)
  for (int thisNote = 0; thisNote < notes * 2; thisNote = thisNote + 2) {

    // calculates the duration of each note
    // ...
    // ... hide

    // we only play the note for 90% of the duration, leaving 10% as a pause
    tone(buzzer, melody[thisNote], noteDuration * 0.9);

    // Wait for the specief duration before playing the next note.
    delay(noteDuration);

    // stop the waveform generation before the next note.
    noTone(buzzer);
  }

A função tone do Arduino gera uma onda quadrada em um pino (buzzer), de frequência melody[thisNote] e duração noteDuration * 0.9.

tone

Sugerimos implementarem uma função que receba como parâmetro uma frequência e um tempo (em milissegundos) e que reproduza uma onda quadrada em um pino do microcontrolador, na frequência e tempo passado como argumento para a função.

/**
 * freq: Frequecia em Hz
 * time: Tempo em ms que o tom deve ser gerado
 */
void tone(int freq, int time){
    ....
    ....
}