Implementa¸c˜ao - Processamento de ´ audio em tempo real em Arduino

3.2 Processamento de ´ audio em tempo real em Arduino

3.2.5 Implementa¸c˜ao

Para juntar todos os elementos descritos na se¸cão anterior e obter um sistema de processamento de áudio em tempo real que inclui amostragem e emissão de sinal, basta apenas escolher os parâmetros certos para configurar as diferentes partes do microcontrolador.

Parˆametros ADC

Segundo a especifica¸cão do microcontrolador, o processo completo de conversão ADC demora cerca de 14.5 ciclos do relógio ADC. Se a frequência do relógio da CPU é de 16 MHz e o valor do pré-escalonador ADC é p, então o per´ıodo do relógio ADC é de p/16 µs e o per´ıodo de conversão é de

3.2 PROCESSAMENTO DE ´AUDIO EM TEMPO REAL EM ARDUINO 45

Figura 3.4: Evolu¸cão temporal dos valores dos registros do mecanismo PWM funcionando no modo Fast PWM. O registro TCNTn corresponde ao valor do contador, e o registro OCnx contém o valor do pino de sa´ıda. Note como mudan¸cas no valor de referência determinam o duty-cycle de cada per´ıodo de onda.

Tconv= 14.5 × p/16 µs. Os valores teóricos para o per´ıodo de conversão Tconv (para todos os valores de pré-escalonador dispon´ıveis) e os resultados ˜Tconv da medi¸cão do per´ıodo de conversão podem ser vistos na tabela abaixo. A última coluna corresponde às frequências de conversão medidas

fconv = 1/ ˜Tconv.

Pr´e-escalonador ADC Tconv (µs) T˜conv(µs) f˜conv(≈KHz)

2 1.8125 12.61 79.302 4 3.625 16.06 62.266 8 7.25 19.76 50.607 16 14.5 20.52 48.732 32 29 34.80 28.735 64 58 67.89 14.729 128 116 114.85 8.707

Estas medi¸cões foram feitas utilizando a fun¸cão micros() da API do Arduino, que tem uma resolu¸cão de cerca de 4 µs. Isto pode explicar parte da diferen¸ca entre os valores medidos e os valores esperados para os valores mais baixos de pré-escalonador. Na medi¸cão foi utilizada uma aproxima¸cão de 8 bits, e para uma aproxima¸cão de 10 bits pode-se esperar um aumento significativo (por volta de 25%) no tempo de conversão.

PWM

A partir do que foi visto na Se¸cão 3.2.3, em uma CPU operando a 16 MHz, um contador de 8 bits e valor de pré-escalonador igual a p possui uma frequência de overflow de foverflow = 106/p × 24 Hz. Abaixo podemos ver uma tabela com as frequências de incremento fincr e de interrup¸cão por overflow foverflow para todos os valores poss´ıveis de pré-escalonador de um contador de 8 bits:

TOVn Interrupt Flag Set OCnx Interrupt Flag Set

1 2 3 TCNTn Period OCnx OCnx (COMnx1:0 = 2) (COMnx1:0 = 3) OCRnx Update

Figura 3.5: Evolu¸cão temporal dos valores dos registros do mecanismo PWM funcionando no modo Phase Correct. O registro TCNTn corresponde ao valor do contador, e o registro OCnx contém o valor do pino de sa´ıda. Note como mudan¸cas no valor de referência determinam o duty-cycle de cada per´ıodo de onda.

Pr´e-escalonador PWM fincr (KHz) foverflow(Hz)

1 16.000 62500 8 2.000 7812 32 500 1953 64 250 976 128 125 488 256 62,5 244 1024 15,625 61

A escolha dos valores de pré-escalonador PWM e ADC determinam a frequência de amostragem do sistema DSP implementado. Se o pré-escalonador ADC for configurado de forma que o per´ıodo de conversão ADC seja menor do que a frequência de interrup¸cão por overflow do PWM, e se a leitura da entrada for sincronizada com a escrita na sa´ıda, então a frequência de interrup¸cão por overflow do PWM corresponde exatamente à frequência de amostragem do sistema DSP. Isto será visto com mais detalhes na próxima se¸cão.

Para o mecanismo PWM, a escolha foi utilizar o modo Fast-PWM, com um contador de 8-bits com valor de pré-escalonador igual a 1. Isto fornece uma taxa de amostragem de 62500 Hz, suficiente para representar o espectro aud´ıvel. É poss´ıvel diminuir artificialmente esta frequência executando o ciclo DSP completo (amostragem, processamento e emissão do sinal) não em todas mas apenas em uma fra¸cão das interrup¸cões. Nos testes executados, a escolha foi de cortar a frequência de amostragem pela metade, para 31250 Hz, correspondendo a um per´ıodo de amostra de 32 µs. Esta escolha privilegia a vantagem de se ter dispon´ıvel o dobro do tempo de computa¸cão, vantagem esta aparentemente maior do que a desvantagem de se perder os últimos 4,4 KHz do espectro aud´ıvel. Juntando os peda¸cos

Tendo escolhido o tamanho do contador e do pré-escalonador PWM, falta apenas escolher os valores dos parâmetros ADC. Como já foi dito, é suficiente escolher valores que garantam que o per´ıodo de conversão ADC é menor do que o per´ıodo desejado de uma amostra. Para os testes,

3.2 PROCESSAMENTO DE ÁUDIO EM TEMPO REAL EM ARDUINO 47 foi escolhido utilizar a conversão de 8 bits para obter uma resolu¸cão igual à da sa´ıda PWM e um per´ıodo menor de conversão (comparado com o per´ıodo da conversão de 10 bits). Também foi escolhido um valor de pré-escalonador ADC igual a 8, correspondendo a um per´ıodo de conversão medido de 19, 76µs que, quando comparado com o per´ıodo de amostra igual a 32 µs garante que a conversão terminará antes que o mecanismo ADC tenha que iniciar uma nova conversão, deixando tempo livre para outros processamentos.

Abaixo, pode-se ver uma reprodu¸cão do peda¸co de código correspondente à fun¸cão de interrup¸cão por overflow, executada sempre que o contador é reiniciado, que corresponde ao mecanismo controlador do ciclo DSP no sistema implementado. O vetor x é o buffer de entrada, ADCH é uma variável que aponta para o registro ADC que contém a amostra de entrada, OCR2A aponta para o registro de sa´ıda PWM e y é o vetor de sa´ıda. Note que boa parte do código corresponde a cálculos de ´ındices dos vetores.

1 /***************************************************************************** 2 _{* Funcao de interrupcao por overflow do Timer 2.}

3 *

4 _{* As variaveis ‘writeind‘ e ‘readind‘ sao inteiros de 8 bits, portanto seu} 5 * valor maximo e’ 255. Essa propriedade e’ utilizada para fazer a leitura e 6 _{* escrita circular dos vetores de entrada e saida, ‘x‘ e ‘y‘, cujo tamanho e’} 7 * exatamente 256. 8 _* 9 _{****************************************************************************/} 10 ISR(TIMER2_OVF_vect) 11 { 12 /*

13 _{* Divisao da frequencia de amostragem por 2.}

14 */

15 static boolean div = false;

16 div = !div;

17 if (div){

19 /*

20 _{* Leitura da entrada com conversao de tipo. ADCH e’ o registrador que}

21 * contem o resultado da ultima conversao ADC.

22 _*/

23 x[writeind] = (int16_t) 127 - ADCH; 24

25 _/*

26 _{* Escrita da amostra de saida no registrador PWM, com ajuste de}

27 _{* offset e conversao de tipo.}

28 */

29 OCR2A = (uint8_t) 127 + y[(writeind-BLOCK_SIZE)]; 30

31 /*

32 _{* Verifica se um novo bloco de amostras esta cheio, calculando a}

33 _{* seguinte condicao: (writeind mod BLOCK_SIZE) == 0.}

34 _*/

35 if ((writeind & (BLOCK_SIZE - 1)) == 0) {

36 readind = writeind - BLOCK_SIZE;

37 dsp_block = true;

38 }

40 /*

41 _{* Incremento do indice de escrita.}

42 _*/

43 writeind++;

45 /*

46 * Inicia a proxima conversao.

47 _*/

49 } 50 }

Note que no passo 3 (linhas 11-14) é feito um teste para determinar se o valor do ´ındice de entrada é um múltiplo do tamanho do bloco e, em caso positivo, o valor do ´ındice de leitura rind e da variável dsp block são atualizados para sinalizar que existe um novo bloco de amostras dispon´ıvel para processamento. Enquanto isso, a fun¸cão loop() é executada concorrentemente e eventualmente iniciará o trabalho nas amostras. Ao final, o ´ındice dos buffers é incrementado (linhas 16 e 17) e um registro é alterado para iniciar uma nova conversão ADC (linha 19).

O código a seguir mostra uma implementa¸cão de algoritmo simples de convolu¸cão no dom´ınio do tempo dentro da fun¸cão loop(). Cada implementa¸cão substitui somente o peda¸co de código referente ao processamento do bloco de amostras.

1 _/** 2 _{* LIMIT(x)} 3 _{* Limita ‘x‘ ao intervalo [-127,127].} 4 */ 5 #define LIMIT(x) \ 6 if (x < -127) \ 7 x = -127; \ 8 if (x > 127) \ 9 x = 127; 10 11 /**

12 _{* TMOD(x, index, len)}

13 * Leitura circular do indice ‘index‘ de um vetor ‘x‘ de tamanho ‘len‘, 14 _{* potencia de 2.}

15 */

16 #define TMOD(x, index, len) x[(index)&(len-1)] 17

18 void loop() 19 {

20 /* aguarda um novo bloco de amostras */ 21 while (!dsp_block);

23 /* variaveis para contagem de tempo */ 24 static unsigned long elapsed_time = 0; 25 unsigned long start_time = micros(); 26

27 /* processamento do bloco */

28 uint16_t maxind = readind+BLOCK_SIZE;

29 for (uint8_t n = readind; n < maxind; n++) { 30

31 int16_t yn = 0; 32 uint8_t order = 0;

33 for (uint8_t i = 0; i <= order; i++) { 34 yn += TMOD(x, n, BUFFER_SIZE) * 0.33;

35 }

37 LIMIT(yn);

38 TMOD(y, n, BUFFER_SIZE) = yn;

39 }

40 elapsed_time += micros() - start_time; 41 count++;

43 dsp_block = false; 44 }

No documento Processamento de áudio em tempo real em dispositivos computacionais de alta disponibilidade... (páginas 58-63)