INTEGRAÇÃO ENTRE ARDUINO E MATLAB SIMULINK PARA ... · de um Servo Motor para atuação direta na...
91
PEDRO CATUNDA MARQUES INTEGRAÇÃO ENTRE ARDUINO E MATLAB SIMULINK PARA DESENVOLVIMENTO E IMPLEMENTAÇÃO DE UM AFINADOR AUTOMÁTICO DE GUITARRA Sorocaba 2018
Transcript of INTEGRAÇÃO ENTRE ARDUINO E MATLAB SIMULINK PARA ... · de um Servo Motor para atuação direta na...
PEDRO CATUNDA MARQUES
INTEGRAÇÃO ENTRE ARDUINO E MATLAB SIMULINK PARA
DESENVOLVIMENTO E IMPLEMENTAÇÃO DE UM AFINADOR
AUTOMÁTICO DE GUITARRA
Sorocaba
2018
PEDRO CATUNDA MARQUES
INTEGRAÇÃO ENTRE ARDUINO E MATLAB SIMULINK PARA
DESENVOLVIMENTO E IMPLEMENTAÇÃO DE UM AFINADOR
AUTOMÁTICO DE GUITARRA
Trabalho de Conclusão de Curso apresentado ao
Instituto de Ciência e Tecnologia do Campus de
Sorocaba, Universidade Estadual Paulista
(UNESP), como parte dos requisitos para obtenção
do grau de Bacharel em Engenharia de Controle e
Automação.
Orientador: Prof. Dr. Galdenoro Botura Jr.
Sorocaba
2018
INTEGRAÇÃO ENTRE ARDUINO E MATLAB SIMULINK PARA
DESENVOLVIMENTO E IMPLEMENTAÇÃO DE UM AFINADOR
AUTOMÁTICO DE GUITARRA
PEDRO CATUNDA MARQUES
BANCA EXAMINADORA:
Prof. Dr. GALDENORO BOTURA JR
Orientador/UNESP–ICTS - Engenharia de Controle e Automação
Prof. Dr. EVERSON MARTINS
UNESP–ICTS - Engenharia de Controle e Automação
Prof. Dr. MÁRCIO ALEXANDRE MARQUES
UNESP–ICTS - Engenharia de Controle e Automação
Maio de 2018
ESTE TRABALHO DE GRADUAÇÃO FOI JULGADO ADEQUADO COMO PARTE DO
REQUISITO PARA A OBTENÇÃO DO GRAU DE BACHAREL EM ENGENHARIA DE
CONTROLE E AUTOMAÇÃO
Prof. Dr. Eduardo Paciência Godoy
Coordenador do Curso de Engenharia de Controle e Automação
Ao Edilson, meu gato e fiel companheiro, que fez sua
passagem durante a elaboração deste trabalho. Que o Criador
que nos deu você o receba novamente. Nos reencontramos na
Eternidade. Até logo.
AGRADECIMENTOS
A Deus, pelo sustento, proteção e graça, e por ter me conduzido até aqui.
Ao Professor Dr. Galdenoro Botura Jr. pela oportunidade de desenvolvimento deste
trabalho, pela atenção e pela orientação.
Aos Professores Dr. Everson Martins, Dr. Márcio Alexandre Marques e Dra.
Marilza Antunes de Lemos por aceitarem compor a banca examinadora desta monografia.
À minha mãe, Denise por seu carinho e dedicação incessantes. Por sempre se
colocar à minha disposição e pelas tantas ajudas durante toda minha vida.
Ao meu pai, Paulo, por seus ensinamentos e companheirismo. Pelo seu espírito leve
e amigo e por acreditar em mim.
Aos meus irmãos, Mateus e Luiza, cada um com seu próprio jeito de enriquecer a
minha vida.
À minha amada Fernanda, parceira, amiga e companheira. Pela maneira como
formamos um time que, ao longo do tempo, soube enfrentar as dificuldades e ampliar as
alegrias dos bons momentos. Por me dar o apoio para a realização deste trabalho.
A cada um daqueles estiveram presentes durante a minha jornada na graduação,
desde os amigos de moradia aos colegas de classe, pela amizade.
À UNESP, por proporcionar um ambiente de aprendizado e desenvolvimento de
seus alunos e a cada professor que busca fazer a diferença na educação deste país.
“Depois do silêncio, o que mais se aproxima
de expressar o inexprimível é a música. ”
Aldous Huxley
RESUMO
Este trabalho tem como objetivo realizar a aquisição e o processamento de sinais
de áudio, através do uso integrado entre Arduino e o software MATLAB Simulink, para
construção de um Afinador Automático de Guitarra. A metodologia empregada envolveu
a pesquisa de conhecimentos necessários para a efetuação do projeto, para posterior
aplicação dos mesmos. Realizou-se a construção de um circuito de adequação do sinal da
guitarra, a construção de circuitos de interação entre o usuário e o afinador, a adaptação
de um Servo Motor para atuação direta na guitarra e a codificação de um programa no
ambiente Simulink. Optou-se pelo uso da Função de Diferença da Magnitude Média como
método de estimação de frequência da corda tocada, devido às suas características
adequadas ao uso com o Arduino. Os resultados obtidos mostram que a resposta do
afinador foi adequada para as diversas situações de afinação da guitarra, sendo que o
mesmo foi capaz de atuar no instrumento de modo a afiná-lo quando necessário. Por fim,
notou-se que a Engenharia de Controle e Automação pode relacionar-se de maneira
eficiente com outros campos do conhecimento, tal como a Música.
Palavras-chave: Afinador automático de guitarra. Aquisição e processamento de
sinais. Arduino. MATLAB Simulink
ABSTRACT
The purpose of this work is to acquire and process audio signals, using Arduino and
the MATLAB Simulink software, in order to build an Automatic Guitar Tuner. The
methodology involves the research and posterior application of the necessary knowledge
to implement the project. Some of the steps taken were the implementation of a circuit to
adequate the guitar signal, the construction of circuits for the integration between the user
and the tuner, the adaptation of a Servo Motor to directly actuate on the guitar and the
coding of a program using the Simulink interface. The Average Magnitude Difference
Function was used as the pitch detection method due to its suitable characteristics for use
with Arduino. The obtained results show that the tuner’s response was adequate for
different guitar tuning situations, and that the tuner was able to act on the instrument in
order to tune it when necessary. Finally, it was noted that Control and Automation
Engineering can relate efficiently to other fields of knowledge, such as Music.
Keywords: Automatic Guitar Tuner. Signals acquisition and processing. Arduino.
MATLAB Simulink
LISTA DE FIGURAS
Figura 1 – Afinador Analógico BOSS ...................................................................................... 15
Figura 2 - Afinador Digital BOSS ............................................................................................ 15
Figura 3 - Diagrama do funcionamento básico de Afinadores ................................................. 16
Figura 4 - Diagrama do funcionamento básico de Afinadores modificado .............................. 16
Figura 5 - Afinador G Force Gibson ........................................................................................ 17
Figura 6 - Afinador Roadie 2 .................................................................................................... 18
Figura 7 - Arduino UNO, LilyPad e DUE ................................................................................ 21
Figura 8 - Interface de programação do Arduino ..................................................................... 22
Figura 9 - Sinal não amplificado .............................................................................................. 24
Figura 10 - Simbologia do Amplificador Operacional ............................................................. 25
Figura 11 – Configuração não inversora .................................................................................. 26
Figura 12 - Composição de um Servo Motor ........................................................................... 27
Figura 13 - Servo Motor Futaba S3003 .................................................................................... 28
Figura 14 - Pulsos de acionamento de um Servo Motor .......................................................... 29
Figura 15 - Acesso ao código "Blink" ...................................................................................... 32
Figura 16 - Circuito esquemático "Blink" ................................................................................ 33
Figura 17 - Circuito amplificador de sinais .............................................................................. 36
Figura 18 - Ponta de cabo de guitarra ....................................................................................... 36
Figura 19 - Jack de guitarra adaptado ....................................................................................... 37
Figura 20 - Encordoador de guitarra......................................................................................... 39
Figura 21 - Adaptação de parte do encordoador....................................................................... 40
Figura 22 - Servo Motor adaptado ............................................................................................ 40
Figura 23 - Circuito seletor de corda ........................................................................................ 41
Figura 24 - Circuito indicador de afinação ............................................................................... 42
Figura 25 - Conexões do Display de sete segmentos ............................................................... 43
Figura 26 - Acesso aos Addons do MATLAB ......................................................................... 44
Figura 27 - Instalação do pacote Simulink Support Package for Arduino ............................... 45
Figura 28 – Biblioteca do Simulink Support Package for Arduino .......................................... 45
Figura 29 - Blocos do Simulink Support Package for Arduino ................................................ 46
Figura 30 - Acesso ao menu de configurações do Arduino no Simulink ................................. 47
Figura 31 - Menu de configurações do Arduino no Simulink .................................................. 47
Figura 32 - Máquina de Estados ............................................................................................... 51
Figura 33 - Parte da programação - Seleção de Cordas ............................................................ 52
Figura 34 - Configuração do bloco de entrada do sinal de guitarra ......................................... 53
Figura 35 - Parte da programação - Determinação de frequência ............................................ 54
Figura 36 - Aplicação da Função de Diferença de Magnitude Média ...................................... 57
Figura 37 - Código para determinação do período da forma de onda ...................................... 58
Figura 38 - Código para tratamento de períodos de forma de onda abaixo do esperado ......... 59
Figura 39 - Implementação final do projeto ............................................................................. 61
Figura 40 - Gerador de função .................................................................................................. 63
Figura 41 - Resultado da amplificação ..................................................................................... 63
Figura 42 - Sinal de áudio adquirido para a guitarra em silêncio ............................................. 65
Figura 43 - Sinal de áudio adquirido ao se tocar uma corda .................................................... 65
Figura 44 - Pulso do botão seletor de corda ............................................................................. 66
Figura 45 - Display de sete segmentos - Exibição de cada corda............................................. 67
Figura 46 - LED RGB - Exibição de cada estado de afinação ................................................. 67
Figura 47 - Motor acoplado à tarraxa da guitarra ..................................................................... 69
LISTA DE TABELAS
Tabela 1 - Características gerais de modelos de Arduino ........................................................ 21
Tabela 2 - Conexões entre o Display de sete segmentos e o Arduino ...................................... 43
Tabela 3 - Frequências e limites alvo para cada corda ............................................................. 50
Tabela 4 - Sinais lógicos para o Display de sete segmentos .................................................... 51
SUMÁRIO
1. INTRODUÇÃO ...................................................................................................... 14
1.1. HISTÓRICO DA TECNOLOGIA ....................................................................................... 14
1.2. OBJETIVOS E JUSTIFICATIVA ........................................................................................ 18
2. CONCEITUAÇÃO ................................................................................................ 20
2.1. O ARDUINO .................................................................................................................. 20
2.2. O SOFTWARE MATLAB SIMULINK ................................................................................ 22
2.3. AMPLIFICAÇÃO E DC OFFSET ...................................................................................... 23
2.3.1. Amplificador Operacional .......................................................................................... 24
2.3.1.1. Simbologia.................................................................................................................. 25
2.3.1.2. Circuito Amplificador Não-Inversor .......................................................................... 25
2.3.2. DC Offset .................................................................................................................... 26
2.4. O SERVO MOTOR ........................................................................................................ 27
2.4.1. Composição ................................................................................................................ 27
2.4.2. Controle ...................................................................................................................... 28
3. DESENVOLVIMENTO ........................................................................................ 31
3.1. AQUISIÇÃO DE MATERIAIS E FAMILIARIZAÇÃO ........................................................... 31
3.2. A ESCOLHA DO ARDUINO DUE ................................................................................... 33
3.3. LISTA FINAL DE MATERIAIS ......................................................................................... 34
3.4. CONSTRUÇÃO DO CIRCUITO AMPLIFICADOR NÃO-INVERSOR ..................................... 35
3.5. ADAPTAÇÃO DO SERVO MOTOR .................................................................................. 38
3.6. CONSTRUÇÃO DO CIRCUITO SELETOR DE CORDA ........................................................ 40
3.7. CONSTRUÇÃO DO CIRCUITO INDICADOR DE AFINAÇÃO ............................................... 41
3.8. INTEGRAÇÃO DOS CIRCUITOS COM O ARDUINO ........................................................... 42
3.9. INTEGRAÇÃO ENTRE O ARDUINO E O MATLAB .......................................................... 44
3.10. PROGRAMAÇÃO ........................................................................................................... 48
3.10.1. Visão Geral da Programação .................................................................................... 48
3.10.2. Máquina de Estados e Seleção de Cordas ................................................................. 49
3.10.3. Detecção do Período da Forma de Onda .................................................................. 53
3.10.4. Programação da função MATLAB ............................................................................. 56
4. RESULTADOS E DISCUSSÕES ......................................................................... 61
5. CONCLUSÃO ........................................................................................................ 71
REFERÊNCIAS ..................................................................................................................... 74
APÊNDICE A – CÓDIGO DA FUNÇÃO MATLAB ......................................................... 77
APÊNDICE B – ENVIO DO CÓDIGO PARA O ARDUINO ........................................... 79
APÊNDICE C – RESULTADO DO ENVIO DO CÓDIGO AO ARDUINO .................... 80
ANEXO A – DATASHEET DO AMPLIFICADOR OPERACIONAL TL082 ................ 81
14
1. INTRODUÇÃO
A música sempre foi um elemento presente na vida do ser humano. Desde as antigas
civilizações, o arranjo de sons provenientes de diversas fontes é utilizado como uma
forma de manifestar pensamentos, sensações e inquietações intrínsecas a um ser vivo.
Não obstante, apenas a geração ou agrupamento de quaisquer sons de forma não
padronizada não garante o atendimento do objetivo anteriormente expresso. Assim sendo,
é necessário que exista um conjunto de padrões que possibilitem a criação de uma
sequência melódica e rítmica que satisfaça as expectativas do autor, padrões estes como
escalas, harmonia, fórmulas de compasso e diversos outros (BARBOUR, 2004).
Um dos padrões musicais que permitem a criação de melodias e harmonias que
façam sentido é a afinação. De fato, a afinação de instrumentos musicais é tão antiga
quanto a própria escala musical, principalmente se considerada a maneira como hoje
entende-se a mesma. Isso porque não se sabe se as escalas musicais - compostas
basicamente por intervalos entre dois ou mais tons, foram criadas a partir de princípios
de afinação ou o inverso (BARBOUR, 2004).
A afinação então figura como a maneira através da qual garante-se que um
instrumento emitirá, para uma determinada nota, uma frequência correspondente. A partir
de 1955, a Organização Internacional para Padronização (International Organization for
Standardization – ISO) adotou a frequência de 440Hz para a nota Lá que se encontra à
direita do Dó central do piano, reafirmando esta padronização como a ISO16:1975 de
1975. Esta passou então a ser a frequência padrão mais aceita e a partir da mesma se torna
possível afinar diversos instrumentos (INTERNATIONAL ORGANIZATION FOR
STANDARDIZATION, 1975).
1.1. Histórico da Tecnologia
Com o decorrer do tempo, não apenas a música como forma de expressão se
aprimorou, mas também as tecnologias utilizadas para gerar, registrar e reproduzir sons
evoluíram infinitamente. Das gravações em fios metálicos ao Streaming de música hoje
existente, é impossível desvincular o aumento da qualidade sonora obtenível do
desenvolvimento e aprimoramento constante de equipamentos eletrônicos. Um exemplo
15
claro é a capacidade atual de se criar músicas contando somente com o auxílio de
softwares que possuam um banco de dados de sons diversos - tal como ocorre nas músicas
do gênero eletrônico - e que permite que qualquer usuário de computador, com alguns
cliques, componha uma música com extrema facilidade.
Uma das aplicações mais fundamentais de equipamentos tecnológicos no ambiente
musical é justamente no que se refere à afinação. Como já expressado anteriormente, os
instrumentos, quer seja para uma performance solo ou em conjunto, devem produzir
ondas sonoras em frequências específicas e próprias. Exemplificando, as quatro cordas
de um violino devem soar um Mi – E5 – 695,26 Hz, um Lá – A4 – 440,0 Hz, um Ré –
D4 – 293,66 Hz e um Sol – G3 – 196,0 Hz, respectivamente (DONOSO, TANNÚS, et
al., 2008). Portanto, é de grande utilidade para um músico a existência de um aparelho
que o auxilie a chegar a esta configuração. Desta forma, surgiram os afinadores, em um
primeiro momento compostos por circuitos analógicos e, posteriormente, por circuitos
digitais. A Figura 1 e Figura 2 exibem dois afinadores, sendo o primeiro analógico e o
segundo digital, ambos produzidos pela empresa americana BOSS.
Figura 1 – Afinador Analógico BOSS
Fonte: (BOSS, 2018a)
Figura 2 - Afinador Digital BOSS
Fonte: (BOSS, 2018b)
16
Um afinador, em uma análise básica, nada mais é do que um comparador de
frequências. Tomando como base a nota Lá – A4, com frequência de 440 Hz, o aparelho
é capaz de medir a nota tocada e classificá-la como afinada ou desafinada, de modo que
o músico possa atuar no instrumento de modo a corrigir a afinação do mesmo. A Figura
3 a seguir exibe um diagrama básico da atuação dos afinadores.
Figura 3 - Diagrama do funcionamento básico de Afinadores
Fonte: Autoria própria.
A partir da aplicação de conceitos de controle e automação, pode-se então inserir
um processo a mais dentro da estrutura básica da afinação: atuação sobre o instrumento.
Assim, libera-se o usuário do equipamento da etapa de ajuste manual do instrumento,
passando esta tarefa a ser executada pelo próprio afinador. Surge então um afinador
autônomo, capaz de atuar de maneira automática sobre o instrumento e que exige de quem
o utiliza um nível menor de interação, além de maior precisão e rapidez. Deste modo, o
diagrama anterior, introduzido na Figura 3, após tal alteração, passa a ser apresentado
como se mostra na Figura 4.
Figura 4 - Diagrama do funcionamento básico de Afinadores modificado
Fonte: Autoria própria.
De fato, a tendência é que cada vez mais se apresentem ao mercado tecnologias que
facilitem e agilizem a utilização dos instrumentos, e atualmente já se encontram
disponíveis, mesmo que em poucos modelos e para poucos instrumentos, afinadores
automáticos. Um exemplo de produto já existente é o afinador automático de guitarra e
violão G-Force da Gibson, que acompanha alguns dos modelos de instrumentos da marca.
Acoplado ao próprio instrumento, o aparelho permite diversas configurações de notas
Entrada: Nota executada pelo
músico
Comparação com frequência de
referência
Determinação da nota executada
Resultado: Afinado/Desafinado
Entrada: Nota executada pelo
músico
Comparação com frequência
de referência
Determinação da nota
executada
Atuação no instrumento e realimentação
da nota
Resultado: Instrumento
afinado
17
para as cordas da guitarra, bastando ao usuário selecionar a afinação desejada e tocar as
cordas. A atuação ocorre, nesse caso, através de servo-motores inseridos nas presilhas
que mantém as cordas tensionadas (GIBSON BRANDS, 2016). Este produto é exibido
na Figura 5.
Figura 5 - Afinador G Force Gibson
Fonte: (ANDERTON, 2014)
Outra solução disponível no mercado é o afinador Roadie. Sua segunda versão
permite a utilização tanto com conexão com o celular via Bluetooth, contando com mais
recursos, quanto sozinho. O aparelho reconhece a nota sendo tocada através de sensores
de vibrações em seu interior e conta com um motor ligado à uma estrutura física
apropriada para o engate nas tarraxas de afinação dos instrumentos. Assim como o
afinador da Gibson, permite ao usuário a configuração de diversas afinações. Sua
principal vantagem é não ser instalado no próprio violão ou guitarra, o que garante a
possibilidade de uso em diversos instrumentos. De acordo com o fabricante, é possível
afinar de violões a banjos, passando por guitarras, ukuleles e mandolins, utilizando o
mesmo produto (BAND INDUSTRIES, 2017a). A Figura 6 a seguir mostra a segunda
versão do afinador Roadie.
18
Figura 6 - Afinador Roadie 2
Fonte: (BAND INDUSTRIES, 2017b)
Embora seja uma tecnologia ainda a engatinhar, o potencial de expansão da mesma
é considerável. Além do aumento do número de modelos disponíveis no mercado, o
investimento em pesquisa e desenvolvimento desta área podem trazer novas funções para
o equipamento. Ao invés de se limitar a uma única afinação para seu instrumento, por
exemplo, o músico pode escolher alterar as configurações do afinador para obter novos
padrões sonoros. Outra aplicação possível seria a atuação em tempo real do afinador de
modo a manter a afinação do violão e/ou guitarra mesmo durante a execução de uma
música. Seria possível, ainda, integrar o afinador com um módulo eletrônico para se ativar
sons pré-programados conforme se detectasse alguma frequência, criando então o que se
chama de overlay, ou seja, uma camada de sons executadas em conjunto com os sons
produzidos pelos instrumentos.
Assim, percebe-se que praticamente não existem limites para as aplicações de
tecnologias no campo da música, sendo o afinador automático apenas uma dentre as
diversas opções – sejam elas existentes ou ainda a serem inventadas.
1.2. Objetivos e Justificativa
Tendo em vista todas as considerações e exemplos apresentados anteriormente,
evidencia-se não apenas a possibilidade de se unir os campos de conhecimento de
Controle e Automação com os da Música, mas também que tal união apresenta utilidade
e propósitos reais, com um grande potencial de exploração para futuras tecnologias. Por
mais que Engenharia e Música pertençam a categorias diferentes de conhecimento, as
19
mesmas sempre atraíram o interesse do autor deste Trabalho de Graduação que, então,
aproveita-se do mesmo como um meio de trazer as duas frentes para próximo uma da
outra.
Deste modo, o objetivo do trabalho é projetar e construir um afinador automático
de guitarra que reduza a intervenção necessária por parte do músico no processo de
afinação de seu instrumento. Ao longo deste trabalho, buscar-se-á explicar o
funcionamento dos componentes eletrônicos utilizados, como associá-los com softwares
computacionais já naturais para os graduandos em Engenharia de Controle e Automação
e exibir os resultados obtidos.
Com a realização de tal trabalho e consequente construção de um afinador
automático, visa-se possibilitar que o instrumentista invista mais de seu tempo tocando e
menos tempo afinando seu instrumento.
20
2. CONCEITUAÇÃO
Esta seção tem o objetivo de introduzir ao leitor desta monografia os diversos
conceitos práticos e teóricos a serem utilizados ao longo do desenvolvimento do trabalho,
bem como aos componentes eletrônicos e computacionais que se farão presente daqui
para frente. Deste modo, serão apresentados a seguir: O Arduino, o software MATLAB
Simulink¸ o conceito de Amplificação e DC Offset e o os princípios de funcionamento do
Servo Motor.
2.1. O Arduino
De acordo com o próprio fabricante, Arduino é uma plataforma eletrônica de código
aberto – livre de licenças, que se fundamenta tanto em hardware quanto em software de
fácil utilização (ARDUINO, 2018a). Estas placas são capazes de realizar leituras de suas
portas de entrada e, através do programa desenvolvido pelo usuário, transformá-las em
sinais apropriados para suas saídas. Em outras palavras, é possível implementar os mais
variados projetos, através dos circuitos físicos e dos códigos escritos para, por exemplo,
tomar a leitura de uma temperatura e a partir da mesma acionar um exaustor ou, ainda,
como é o objetivo desta monografia, a partir de uma leitura de frequência, determinar se
um instrumento está afinado ou não para, em seguida, atuar sobre um motor que realizará
o ajuste de afinação.
A maior parte das placas Arduino consiste em estruturas com microcontroladores
de 8-bit AVR da Atmel e possuem uma vasta quantidade de memória flash, entradas e
saídas e outras características disponíveis (ARDUINO, 2018a). A Figura 7 a seguir
apresenta alguns dos modelos de Arduino disponíveis, sendo seguida pela Tabela 1 que
apresenta suas principais especificações técnicas.
21
Figura 7 – Arduino UNO, LilyPad e DUE
Fonte: (ARDUINO, 2018b). Montagem do autor.
Tabela 1 - Características gerais de modelos de Arduino
Modelo Microcontrolador
Tensão
dos Pinos
(E/S)
Pinos
Digitais
(E/S)
Pinos
Analógicos
(Entradas)
Memória
Uno ATmega328P 5V 14
(6 PWM) 6 32KB
Lilypad ATmega32u4 3,3V 9
(4 PWM) 4 32KB
Due AT91SAM3X8E 3,3V 54
(12 PWM) 12 512KB
Fonte: (ARDUINO, 2018b). Montagem própria.
Para este trabalho, foi utilizada a placa Arduino Due, uma versão de 32-bit baseada
no microcontrolador Atmel SAM3X8E. Este microcontrolador apresenta maior potencial
de processamento e uma quantidade maior de portas de entrada e saída analógicas e
digitais (ARDUINO, 2018c). Sua escolha se deu por ser um modelo cuja memória e
processamento disponíveis são mais apropriados para o código mais complexo a ser
utilizado e também por permitir a leitura em tempo real dos sinais de entrada, bem como
alteração de parâmetros básicos enquanto o código é executado, quando conectado ao
MATLAB Simulink – software a ser conceituado a seguir.
As placas Arduino já possuem programação de bootloader de fábrica, uma rotina
de inicialização que facilita o envio de programas para a memória interna do chip do
microcontrolador. Tal envio é feito, nas placas atuais, através de conexão no computador
via porta USB (Arduino, 2018).
22
Já no que diz respeito ao Software, os programas para Arduino podem ser escritos
em qualquer linguagem que possua compiladores que convertam o código em linguagem
de máquina para o processador da placa em uso. A Arduino oferece uma interface de
desenvolvimento integrada (do inglês, IDE – Integrated Development Environment),
multiplataforma, através da qual o usuário pode utilizar a linguagem Wiring¸ similar à
C/C++ para escrever seus programas. Tais códigos são salvos pela interface no
computador utilizando a extensão .ino e são chamadas de Sketch. Assim, um Sketch nada
mais é do que um programa para Arduino escrito na interface do próprio fabricante
(Arduino, 2018).
A Figura 8 mostra tal ambiente de desenvolvimento.
Figura 8 - Interface de programação do Arduino
Fonte: Autoria própria.
Para programar o Arduino, além do uso do compilador nativo do fabricante, é
possível realizar diversas interações com outros softwares computacionais, como por
exemplo, o MATLAB, o qual será introduzido a seguir.
2.2. O Software MATLAB Simulink
O MATLAB, abreviação de Matrix Laboratory – inglês para “Laboratório
Matricial” ou “Laboratório de Matrizes” –, é um ambiente de computação numérica,
voltado para a manipulação e solução de cálculos envolvendo matrizes, apresentação
gráfica de funções e dados, implementação de algoritmos e interface com diversas outras
linguagens, como C, C++, C# entre outras (THE MATHWORKS INC, 2018a). Isso se
23
deve à própria linguagem MATLAB, desenvolvida pela MathWorks. Além da linguagem
de programação, este ambiente apresenta diversas ferramentas adicionais que aumentam
o seu rol de possíveis aplicações.
Uma dessas ferramentas é a interface gráfica para usuário (GUI – Graphical Users
Interface) Simulink. O Simulink é uma ferramenta poderosa para realizar a modelagem de
sistemas de controle, fornecendo ao usuário uma interface gráfica para contornar a
necessidade de uma programação complexa e também permitir simular a resposta de tais
sistemas ao longo do tempo. Seu uso ocorre através de diagramas de blocos no lugar de
equações matemáticas (TEWARI, 2002). Para isso, o software é equipado de diversos
blocos – lineares, não-lineares, fontes de entrada e dispositivos de saída, por exemplo.
Para a utilização em conjunto com o Arduino, foi desenvolvido um pacote de
compatibilidade que permite ao Simulink se conectar ao microcontrolador, ao mesmo
tempo que dá ao programa a capacidade de traduzir seus diagramas de bloco em
linguagem compatível com o chip disponível na placa. Este pacote, denominado Simulink
Support Package for Arduino Hardware, possui uma biblioteca própria de blocos de
configuração e acesso aos sensores e atuadores do Arduino, bem como para suas
interfaces de comunicação (THE MATHWORKS INC, 2018b). Uma característica
importante deste pacote é a capacidade de gerar e enviar para o Arduino projetos que não
necessitam da conexão com o software para funcionar, além de ser compatível com
praticamente todas as versões disponíveis do Arduino (THE MATHWORKS INC,
2018c).
O Simulink foi então escolhido como ambiente de desenvolvimento deste trabalho
e sua utilização será explicada em detalhes na descrição do desenvolvimento do projeto.
2.3. Amplificação e DC Offset
Devido às características do sinal a ser trabalhado no Arduino, pode ser necessário
realizar a amplificação do mesmo, de modo a obter maior precisão quando realizada a
determinação da frequência da onda analisada. Do mesmo modo, também pode ser
desejável realizar o offset DC desta onda, ou seja, alterar o valor médio em torno do qual
a mesma oscila. Uma vez que os sinais provenientes de algumas fontes podem apresentar
24
amplitudes baixas e oscilar em torno de zero volts, o uso destas operações se torna
essencial (GHASSAEI, 2012a).
Para o sinal de uma guitarra, a amplitude do sinal também é pequena, encontrando-
se na faixa dos 200 mV, podendo variar de acordo com a corda sendo tocada. Além disso,
seu sinal oscila em torno de 0 V, ou seja, seu valor médio é nulo, possuindo tensões
positivas em parte do seu período, e tensões negativas em outra parte de seu período
(GHASSAEI, 2012a). Na Figura 9, pode-se verificar o sinal de saída de uma guitarra.
Figura 9 - Sinal não amplificado
Fonte: (GHASSAEI, 2012a)
Por ser o Arduino Due uma interface que permite em suas portas de entrada tensões
entre 0V e 3,3V, é necessário que se adeque o sinal proveniente do instrumento para que
atenda aos requisitos do microcontrolador. Basicamente, para os fins deste trabalho, é
necessário amplificar o sinal para um nível de 3,3 V pico a pico, com um valor médio de
1,65 V. Portanto, o uso de um circuito Amplificador Operacional mostra-se indicado para
esta situação. As principais características deste componente serão apresentadas a seguir.
2.3.1. Amplificador Operacional
Um Amplificador Operacional (AOP) é um dispositivo eletrônico composto por um
amplificador multiestágio, com entrada diferencial. Apresenta características próximas
das de um amplificador ideal (WENDLING, 2010). Dentre elas, tem-se:
Impedância de entrada infinita;
Impedância de saída nula;
25
Ganho de tensão infinito;
Resposta de frequência infinita;
Insensibilidade à temperatura.
Assim sendo, são diversas as aplicações possíveis para estes dispositivos,
empregados desde em equipamentos de telecomunicações e áudio a sistemas de controle
industrial, passando por diversos sistemas de instrumentação, como a médica e a
industrial (WENDLING, 2010).
2.3.1.1. Simbologia
A Figura 10 apresenta a simbologia básica para um AOP.
Figura 10 - Simbologia do Amplificador Operacional
Fonte: (WENDLING, 2010)
Sendo:
V- - Tensão Inversora;
V+ - Tensão Não-Inversora;
Vo – Tensão de Saída.
2.3.1.2. Circuito Amplificador Não-Inversor
Para realizar a amplificação do sinal sem que ocorra a inversão do mesmo – dado
que se deseja obter tensões positivas, é importante definir um circuito que seja capaz de
amplificar a tensão de entrada por um ganho controlável e não-inversor. Para isto,
apresenta-se a configuração mostrada na Figura 11.
26
Figura 11 – Configuração não inversora
Fonte: (WENDLING, 2010)
O ganho é encontrado a partir das Equações (1) e (2) a seguir (WENDLING, 2010).
𝑉𝑂 = (1 +𝑅𝑓
𝑅1) . 𝑉𝑖 (1)
𝐺𝑎𝑛ℎ𝑜 = 𝑉𝑂
𝑉𝑖= (1 +
𝑅𝑓
𝑅1) (2)
Desta maneira, através do ajuste dos resistores R1 e Rf é possível realizar um
incremento de tensão por um ganho constante, dado pela parcela que multiplica a tensão
Vi na Equação 1.
O circuito completo utilizado na implementação deste projeto será descrito na seção
de desenvolvimento, onde serão apresentadas todas as expressões e cálculos que regem o
funcionamento do mesmo.
2.3.2. DC Offset
Além da adequação da amplitude do sinal para melhor aproveitamento da precisão
do Arduino, a forma de onda deve oscilar numa faixa de tensão que seja suportada pelo
microcontrolador. O Arduino DUE permite leituras de sinais com tensões positivas,
variando de 0 V a 3,3 V, conforme já mencionado.
Portanto, para o sinal de uma guitarra que oscila entre valores positivos e negativos,
deve-se realizar a elevação do valor de tensão médio de 0 V para 1,65 V. Este
procedimento é denominado DC offset. Para realizá-lo, utilizou-se um capacitor atuando
em conjunto um divisor de tensão composto por dois resistores de mesmo valor. Este
divisor de tensão é conectado entre os terminais Terra e 3,3 V do Arduino, criando em
seu centro uma tensão de 1,65 V. A oscilação positiva e negativa da tensão proveniente
27
da saída do amplificador operacional, atingindo um dos terminais do capacitor, faz com
que ocorra o acúmulo e repulsão momentâneo de cargas em seu outro terminal, conectado
ao divisor de tensão. Com isso, a tensão passará a oscilar para valores acima e abaixo dos
1,65 V já existentes.
A construção deste circuito será detalhada na seção de Desenvolvimento deste
trabalho.
2.4. O Servo Motor
2.4.1. Composição
O Servo Motor é um atuador rotativo ou linear que permite um controle preciso de
posição, velocidade e aceleração, seja angular ou linear. Os mesmos não são uma classe
específica de motores, embora sua nomenclatura seja utilizada para se referir a motores
apropriados para uso em um sistema de controle de malha-fechada (SAWICZ, 2001). Isso
porque, basicamente, um Servo Motor é composto por um pequeno motor DC, um
potenciômetro, um jogo de engrenagens e um circuito de controle. As Figuras 12 e 13 a
seguir exibem tais componentes e um Servo Motor montado, respectivamente.
Figura 12 - Composição de um Servo Motor
Fonte: (REED, 2018). Alterações do autor.
28
Figura 13 - Servo Motor Futaba S3003
Fonte: Acervo pessoal.
Através desta composição forma-se um pequeno sistema de malha fechada, pois o
motor é conectado ao potenciômetro através das engrenagens e, com sua rotação, altera a
resistência do potenciômetro vista pelo circuito de controle, que pode então controlar a
direção e quantidade de movimento necessárias para atingir determinada posição.
Basicamente, a existência do potenciômetro conectado ao motor configura um sistema de
feedback, ou seja, uma realimentação para o circuito de controle que, desta maneira, passa
a conhecer a saída do sistema. Em Servo Motores mais básicos, a saída controlada é a
posição do motor, enquanto modelos mais avançados permitem também o controle de
velocidade e aceleração (REED, 2018).
2.4.2. Controle
Os servos motores apresentam o que se denomina Controle Proporcional, ou seja,
a velocidade do motor é proporcional à distância entre a posição atual do eixo e sua
posição desejada. Logo, o eixo do motor se deslocará mais lentamente quanto mais
próximo estiver da posição final (REED, 2018).
Quando o eixo do servo se encontra na posição desejada, o fornecimento de energia
para o motor DC é cessado por parte do circuito de controle. Caso contrário, o motor é
acionado na direção apropriada até que se atinja a posição desejada. Esta posição é
informada ao controlador através de sinais elétricos enviados em um de seus três cabos
(REED, 2018). Este sinal apresenta a estratégia Modulação por Largura de Pulso, mais
amplamente conhecida pela nomenclatura em inglês, Pulse Width Modulation – PWM.
Controlando esta modulação define-se a posição final desejada. A Figura 14 exibe a
29
relação entre a duração do pulso PWM e a posição do eixo, para um Servo Motor que
tenha movimentação entre 0º e 180º.
Figura 14 - Pulsos de acionamento de um Servo Motor
Fonte: (REED, 2018). Alterações do autor.
Através da Figura 14, notamos que um pulso mínimo de um milissegundo (1 ms)
de duração movimentará o eixo do motor no sentido anti-horário, para a posição de 0º. Já
o pulso de 2 ms fará o motor girar no sentido horário até que se atinja sua máxima posição,
que neste caso é de 180º. Um pulso intermediário, de duração de 1,5 ms leva o motor à
sua posição central, ou neutra. Como o circuito de controle espera receber pelo menos um
pulso a cada 20 ms, o envio de pulsos repetidamente para o Servo Motor garante que o
motor irá atingir a posição especificada e, além disso, permanecer nela, pelo tempo em
que se estiver fornecendo o sinal de controle (REED, 2018).
Uma característica importante a ser destacada é justamente a da limitação de
movimento por parte dos servo motores. Estes componentes podem girar apenas em uma
determinada quantidade de graus, geralmente de 0º a 120º ou então a 180º, e alguns
modelos são capazes de girar até 360º. Isso se deve à própria construção física e também
ao método de controle feito através do feedback fornecido pelo potenciômetro. Para que
um Servo Motor possa girar livremente em qualquer direção, conforme é desejado para a
execução deste projeto, deve-se realizar algumas alterações, as quais serão apresentadas
na seção de Desenvolvimento deste trabalho (SAWICZ, 2001).
30
Um aspecto interessante de se destacar é que o uso de servo motores em conjunto
com o Arduino é feito de forma bastante simples, sem a necessidade de se codificar
complexos programas para gerar a forma de onda PWM correspondente à posição
desejada. Pelo contrário, a interface Arduino com sua linguagem Wiring possui
bibliotecas específicas para diversos componentes, e no caso de servo motores, existem
funções específicas para sua utilização. No ambiente do Simulink, com o auxílio do pacote
de conexão para o Arduino, existem blocos de acionamento de servo motores. Em ambos
os casos, o único parâmetro requisitado pela função ou pelo bloco é a posição desejada,
em graus (THE MATHWORKS INC, 2018d). Tais bibliotecas facilitam muito a
utilização desses dispositivos e auxiliam na programação de modo a diminuir a
quantidade de código necessária para execução do projeto.
31
3. DESENVOLVIMENTO
O desenvolvimento deste projeto ocorreu conforme as seguintes etapas:
1. Aquisição e familiarização com os componentes a serem utilizados;
2. Construção do circuito de amplificação;
3. Adaptação do servo-motor;
4. Construção do circuito de seleção de corda a ser afinada;
5. Construção do circuito indicador de afinação;
6. Integração dos circuitos com o Arduino;
7. Integração entre Arduino e Matlab Simulink para construção do código;
8. Construção do código.
A seguir, serão detalhadas cada uma das etapas.
3.1. Aquisição de Materiais e Familiarização
Basicamente, a primeira etapa do desenvolvimento do projeto consistiu em fazer a
aquisição dos materiais a serem utilizados no mesmo para, em seguida, realizar a
familiarização com suas características e métodos de operação.
Efetuaram-se consultas à Internet com o objetivo de verificar se as expectativas do
autor eram condizentes, no que diz respeito aos materiais a serem utilizados, bem como
ao trabalho a ser realizado para construção do afinador automático.
Mais especificamente, foram consultados sites que possuíssem explicações e
descrições detalhadas de projetos de eletrônica, de modo a observar os materiais
utilizados, circuitos projetados e também lógicas de programação construídas. Desta
consulta se aproveitaram também alguns conceitos teóricos relacionados a este trabalho.
Os principais fóruns consultados para esta etapa foram o Instructables
(www.instructables.com) e Mathworks (https://www.mathworks.com/). Os projetos
consultados têm suas contribuições indicadas nas referências bibliográficas citadas ao
longo deste trabalho.
Realizada tal pesquisa e levantada uma lista inicial de componentes necessários, foi
adquirida em um primeiro momento uma placa de Arduino do modelo UNO, cujas
32
características foram apresentadas anteriormente. No mesmo momento, adquiriu-se
também um conjunto básico de componentes eletrônicos tais como resistências,
capacitores, LEDs, displays de diversos tipos, amplificadores operacionais entre outros.
Com tais componentes, foi possível iniciar a montagem de pequenos e simples
circuitos apenas com o intuito de compreender o funcionamento do Arduino, sua conexão
com o computador e utilização da IDE da fabricante. Um desses circuitos construídos,
por exemplo, tem seu código disponível na biblioteca de exemplos da interface de
programação do Arduino e se chama “Blink”. Este código tem o simples objetivo de fazer
um LED piscar intermitentemente (ARDUINO, 2018d). As Figuras 15 e 16 exibem a
localização de tal código dentro da interface e o circuito construído, respectivamente.
Figura 15 - Acesso ao código "Blink"
Fonte: Autoria própria.
33
Figura 16 - Circuito esquemático "Blink"
Fonte: (ARDUINO, 2018d)
Através da construção destes circuitos elementares, foi possível adquirir o
conhecimento necessário para a montagem do projeto como um todo, isso pois o afinador
automático nada mais é do que uma união entre diferentes circuitos, integrados e
controlados pelo Arduino. Estes circuitos são:
1. Módulo de entrada, onde é realizada a aquisição e tratamento do sinal da guitarra;
2. Circuito seletor de corda, responsável por ser a interface entre o usuário e o
afinador;
3. Indicador de afinação, composto por um LED de três cores para fácil identificação
da afinação da corda selecionada;
4. Módulo de atuação, sendo composto pelo Servo Motor e responsável por atuar na
guitarra para ajustar sua afinação.
3.2. A escolha do Arduino DUE
Como foi expresso anteriormente, a placa Arduino DUE foi utilizada para a
implementação do afinador automático. Entretanto, em um primeiro momento iniciou-se
o desenvolvimento do projeto através do modelo UNO, mais básico. A troca ocorreu a
partir do instante em que se optou por fazer a integração do Arduino com o software
computacional MATLAB Simulink.
34
A escolha de utilizar tal programa se deveu a alguns fatores. A existência de um
pacote de integração entre Arduino e Simulink desenvolvido pela fabricante Mathworks
permite o reconhecimento do microcontrolador pelo programa computacional. Com tal
pacote, passou-se a contar com a existência de blocos pré-configurados para realizar a
leitura dos sensores acoplados ao Arduino e também realizar o envio de sinais para as
portas de saída do mesmo.
Um segundo fator foi a maior facilidade de programação, dado que grande parte do
código pôde ser desenvolvido diretamente na forma de diagrama de blocos. Isto tornou a
apresentação da programação mais interativa, sem impedir a inclusão de funções
MATLAB escritas em linguagem C/C++ para realizar a determinação da frequência da
corda sendo tocada.
Outra ferramenta poderosa obtida no uso do Simulink foi a possibilidade de
visualizar o comportamento do sistema e aplicar correções nos parâmetros com o código
em execução. Todos os detalhes da construção do código utilizando o MATLAB Simulink
estão descritos mais adiante.
Assim sendo, notou-se que o modelo UNO do Arduino não teria os requisitos de
processamento e memória necessários para a implementação do projeto como um todo.
Por isso, optou-se pela aquisição do modelo DUE para tirar proveito dos recursos
disponíveis com a integração com o Simulink.
3.3. Lista final de Materiais
Passada então a etapa de definição de componentes a serem utilizados e
familiarização com os mesmos, chegou-se a lista de materiais a seguir, utilizada para a
construção do afinador automático através da integração entre Arduino e o MATLAB
Simulink:
Microcontrolador Arduino DUE
Software MATLAB Simulink com o pacote Simulink Support Package for Arduino
Protoboard
Jumpers e fios conectores
35
Jack de ¼” – 6.35mm Mono
2 Conectores para bateria de 9 V
2 Baterias de 9 V
Potenciômetro de 10 KΩ
Capacitor eletrolítico de 10 µF
Capacitor de cerâmica de 47 ηF
Resistores de 100 KΩ, 10 KΩ e 470 Ω
Amplificador Operacional TL082
Push button
Display de 7 segmentos Cátodo Comum
LED RGB
Servo Motor FUTABA S3003
Encordoador de Guitarra
3.4. Construção do Circuito Amplificador Não-Inversor
O primeiro passo para poder realizar a aquisição do sinal da guitarra foi a construção
do módulo de entrada, composto por um circuito amplificador não-inversor. Para esta
montagem, foi consultado e adaptado o circuito proposto por Amanda Ghassaei no fórum
Instructables (www.instructables.com) (GHASSAEI, 2012a). O projeto elaborado por
Ghassaei apresenta um circuito para adequação de sinais de áudio, para que sejam
recebidos e processados com qualidade pelo Arduino. Esta adequação envolve a
amplificação do sinal e o deslocamento de seu valor médio de 0 V para 2,5 V. Desta
maneira, um sinal que originalmente teria uma tensão de pico de 200 mV e oscilação em
torno do 0 V, passa a ter oscilação de 0 V a 5 V, com valor médio de 2,5 V.
A adaptação realizada em tal circuito envolve a adequação do sinal para um valor
máximo de 3,3 V por ser este o valor máximo aceito pelas portas de entrada do modelo
DUE do Arduino. A Figura 17 exibe o circuito já modificado.
36
Figura 17 - Circuito amplificador de sinais
Fonte: (GHASSAEI, 2012a). Alterações do autor.
Primeiramente, para o acoplamento da guitarra foi utilizado um Jack de ¼” –
6.35mm, o mesmo utilizado em instrumentos e em equipamento de áudio. Soldou-se aos
terminais do Jack fios condutores para posterior acoplamento ao circuito, sendo um dos
terminais responsável por captar o sinal proveniente da ponta do conector da guitarra e o
outro por ser conectado ao Terra do sistema, também ligado ao corpo do conector. As
Figuras 18 e 19 exibem, respectivamente, o conector de um cabo de guitarra com suas
duas áreas e o Jack adaptado para uso no circuito.
Figura 18 - Ponta de cabo de guitarra
Fonte: Acervo pessoal.
37
Figura 19 - Jack de guitarra adaptado
Fonte: Acervo pessoal
Partindo para a construção do circuito, a parte à esquerda do mesmo apresenta o
Amplificador Operacional TLO82 em configuração não inversora. O potenciômetro de
10 KΩ permite realizar um ajuste no ganho de modo que o sinal de saída possua a
amplitude desejada. De acordo com a Equação (2) do ganho do amplificador operacional,
neste circuito temos Rf = 10 KΩ e um R1 variável, sendo que quanto menor seu valor,
menor o denominador da equação, logo, maior o valor do ganho de amplificação do
circuito.
Foi realizada a montagem deste circuito em uma Protoboard, conforme indicado
na Figura 17. Para a alimentação do amplificador operacional foram utilizadas duas
baterias de 9 V em série, de modo a se obter tensões de -9 V e 9V nos terminais de
alimentação. De acordo com as especificações presentes no Datasheet do AOP, o mesmo
deve ser alimentado com tensões de ± 15 V. Entretanto, por não estar-se amplificando o
sinal da guitarra para valores absolutos maiores do que 1,65 V, a utilização das baterias
de 9 V se faz suficiente, além de representar uma solução mais comercialmente acessível
e compacta do que baterias maiores (STMICROELECTRONICS, 2002) e (GHASSAEI,
2012a).
A parte à direita do circuito, entre o AOP e o Arduino, é responsável por fazer a
correção do valor DC do sinal, trazendo-o de 0 V para 1,65 V. Tal feito foi alcançado
38
com o uso de um capacitor de 10 µF conectado ao centro de um divisor de tensão
composto de dois resistores de 100 KΩ. O divisor de tensão está conectado entre o pino
saída de 3,3 V e o Terra do Arduino. Por se tratarem de dois resistores de mesmo valor,
a tensão em seu ponto central será de metade do valor de seus terminais, portanto, 1,65 V.
Com tal configuração, com a variação do sinal amplificado pelo AOP à esquerda
do capacitor, a carga no mesmo sofre acúmulo e repulsão diretamente sobre a região
central do divisor de tensão. Logo, o valor oscilará de 0 V a 1,65 V quando o sinal de
entrada tiver tensões negativas, e de 1,65 V a 3,3 V quando o sinal de entrada tiver tensões
positivas.
3.5. Adaptação do Servo Motor
Conforme já mencionado, um Servo Motor originalmente só é capaz de realizar
movimentos limitados a uma certa quantidade de graus. Para que o mesmo passasse a
girar continuamente em ambas as direções, foi necessário realizar algumas alterações
físicas de modo a, primeiramente, liberar o giro do motor de modo contínuo e, em
segundo lugar, informar para o controlador interno do motor que a posição desejada
jamais foi atingida.
Para isso, foram realizadas duas modificações. A primeira envolveu a remoção de
um limitador físico em uma das engrenagens do motor que impossibilitava que o mesmo
girasse livremente em qualquer sentido. Por serem as engrenagens do Servo Motor Futaba
S3003 produzidas em material plástico, o simples uso de um alicate de corte foi o
suficiente para remover tal limitador.
A segunda modificação incluiu a substituição do potenciômetro interno ao motor
por um divisor de tensão composto por resistências iguais. Isso foi feito para que o
controlador interno do Servo Motor passasse a “enxergar” uma resistência fixa de modo
a enxergar uma posição de eixo que nunca varia. Com isso, dependendo do sinal enviado
ao controlador, o mesmo comandará o motor para girar em determinada direção sem
nunca parar, visto que, para o mesmo, a posição desejada nunca é alcançada. Foram
utilizados dois resistores de 10 kΩ no divisor de tensão.
39
Com esta alteração, a posição de 80º passou a deixar motor centralizado, enquanto
os sinais de 0º e 120º comandavam o motor para a máxima velocidade, em sentidos
opostos. A maneira como o Servo Motor passou a ser acionado será explicado mais
adiante, em conjunto com a apresentação do código construído para o afinador
automático.
Outra adaptação foi realizada para o Servo Motor, para permitir que o mesmo se
conectasse às tarraxas da guitarra. Existe no mercado um dispositivo denominado
“Encordoador”, uma manivela criada para auxiliar no processo de troca de cordas do
instrumento e que pode ser observada na Figura 20.
Figura 20 - Encordoador de guitarra
Fonte: Acervo pessoal.
Como é de se notar, existe no encordoador uma peça que se encaixa nas tarraxas. A
mesma foi removida e utilizada em conjunto com o Servo Motor para que assim se
pudesse atuar na guitarra. As Figuras 21 e 22 exibem o engate do encordoador adaptado
para o uso com o Servo Motor.
40
Figura 21 - Adaptação de parte do encordoador
Fonte: Acervo pessoal.
Figura 22 - Servo Motor adaptado
Fonte: Acervo pessoal.
3.6. Construção do Circuito Seletor de Corda
Com o objetivo de permitir ao usuário indicar ao afinador qual a corda a ser afinada,
foi criado um circuito de seleção, composto por um Push Button e um Display de sete
segmentos do tipo Cátodo Comum. Trata-se da principal interface entre o usuário e o
equipamento e seu funcionamento consiste em, ao apertar do botão, enviar um pulso para
uma das portas do Arduino, sendo este pulso responsável por informar ao código que o
botão foi pressionado e que se deseja afinar a próxima corda.
Em conjunto com botão, o display é responsável por informar ao utilizador do
equipamento qual corda está atualmente selecionada. A Figura 23 a seguir exibe este
trecho do circuito.
41
Figura 23 - Circuito seletor de corda
Fonte: Acervo pessoal.
Por se tratar o Display de um dispositivo do tipo cátodo comum, seus terminais
individuais para cada segmento devem ser alimentados com os sinais lógicos, sendo neste
projeto o valor de 0 V o nível baixo e 3,3 V o nível alto. O terminal comum será conectado
ao Terra do Arduino. A relação de pinos utilizadas poderá ser verificada mais adiante.
3.7. Construção do Circuito Indicador de Afinação
Criou-se também outro ponto de interface com o usuário, de maneira a exibir a atual
afinação da corda, para informar ao mesmo se a frequência da nota tocada está acima,
abaixo ou correspondente à frequência de referência para a corda selecionada.
Trata-se de um simples circuito composto por um LED RGB – ou seja, um LED
com as cores vermelho, verde e azul – em conjunto com resistores de proteção. Conectou-
se os resistores aos terminais R, G e B do LED correspondentes a cada uma das cores,
deixando-se sem resistor o terminal Terra do mesmo. Esta montagem pode ser conferida
na Figura 24.
42
Figura 24 - Circuito indicador de afinação
Fonte: Acervo pessoal.
3.8. Integração dos Circuitos com o Arduino
Cada parte do afinador descrita anteriormente precisou ser devidamente conectada
ao Arduino, para que o mesmo pudesse fazer a leitura dos sinais de entradas existentes,
realizar o processamento através do código – a ser descrito mais adiante – e então atualizar
suas saídas. Tal conexão ocorreu em conjunto com a construção de cada circuito, mas
para facilitar a compreensão e sumarizar as ligações realizadas, as mesmas serão
apresentadas nesta seção.
À porta de entrada analógica de número 0 (PIN0) do Arduino foi conectada a saída
do circuito de amplificação do sinal da guitarra. Desta forma, esta é a porta responsável
por fazer a aquisição de tal sinal para posterior processamento.
O Servo Motor teve seus terminais de alimentação ligados à porta provedora de
tensão de 5 V do Arduino e ao Terra, e seu terminal de sinal conectado à porta digital 11
(PIN 11). Esta é uma das portas digitais do Arduino que permite a saída de sinais PWM,
fator de importante observação para o acionamento do Servo Motor, que utiliza este tipo
de sinal em seu funcionamento.
O sinal proveniente do botão seletor de corda foi conectado ao pino digital 2 (PIN
2). Esta porta então será verificada para atualizar a corda a ser afinada junto ao código do
programa.
43
A configuração dos terminais do Display de sete segmentos pode ser conferida na
Figura 25.
Figura 25 - Conexões do Display de sete segmentos
Fonte: (CIRCUITS TODAY, 2016)
A partir de tal configuração, realizou-se a conexão dos terminais de acordo com a
Tabela 2.
Tabela 2 - Conexões entre o Display de sete segmentos e o Arduino
Terminal Porta Digital do
Arduino
A PIN 29
B PIN 28
C PIN 25
D PIN 22
E PIN 23
F PIN 26
G PIN 27
DP PIN 24
COM. Terra Fonte: Autoria própria
As portas digitais de número 8 (PIN 8), 9 (PIN 9) e 10 (PIN 10) foram conectadas,
respectivamente, aos resistores dos terminais R – Vermelho, G – Verde e B – Azul do
LED RGB.
Desta maneira, passou-se a ter todos os elementos do afinador automático de
guitarra devidamente conectados ao Arduino DUE e pôde-se então passar para a etapa de
integração entre Arduino e MATLAB Simulink e desenvolvimento do programa a ser
executado. O sistema final, resultado das montagens e conexões realizadas, poderá ser
visualizado na seção de Resultados e Discussões.
44
3.9. Integração entre o Arduino e o MATLAB
Uma importante etapa de desenvolvimento, sem dúvida, foi a realização da
integração entre o MATLAB Simulink e o Arduino. Para isso, foi necessário realizar a
configuração do pacote Simulink Support Package for Arduino.
É possível encontrar o pacote para instalação dentro do próprio ambiente MATLAB,
através do Menu Add-Ons. Na versão R2017b do programa, este menu é apresentado logo
na página inicial, conforme se pode conferir na Figura 26.
Figura 26 - Acesso aos Add-Ons do MATLAB
Fonte: Autoria própria.
Ao selecionar o item Get Hardware Support Packages, abre-se uma nova janela
onde é possível pesquisar diversos componentes que possibilitam ao MATLAB
comunicar-se com dispositivos físicos externos. Pesquisou-se então pela palavra
“Arduino” e a ferramenta desejada foi retornada como primeiro resultado. Este resultado
é exibido na Figura 27.
45
Figura 27 - Instalação do pacote Simulink Support Package for Arduino
Fonte: Autoria própria
A seleção do link apresentado direciona o usuário ao processo de instalação do
pacote de compatibilidade para Arduino que, uma vez concluído, habilita os diversos
blocos de programação compatíveis com o microcontrolador dentro do ambiente do
MATLAB Simulink. Esta nova biblioteca pode ser verificada nas Figuras 28 e 29.
Figura 28 – Biblioteca do Simulink Support Package for Arduino
Fonte: Autoria própria
46
Figura 29 - Blocos do Simulink Support Package for Arduino
Fonte: Autoria própria
Uma vez realizada a instalação do Simulink Support Package for Arduino, passou-
se então à familiarização com as novas funcionalidades e com a programação para o
Arduino dentro do ambiente do Simulink. Foram desenvolvidos programas básicos para
compreender o modo de funcionamento da interface.
A conexão do Arduino com o MATLAB foi feita através de um cabo USB e, para
enviar os programas do computador para o microcontrolador, foi necessário configurar o
Simulink para reconhecer esta conexão. Basicamente, foi especificada qual a versão do
Arduino seria utilizada, sendo escolhida a opção “Arduino DUE”. Outra configuração
feita foi a alteração do modo de conexão de “Automático” para “Manual” e a
especificação de em qual porta a placa estava conectada. No caso deste projeto, a porta
utilizada foi a porta COM 9 do computador.
Este ajuste foi realizado no ambiente do Simulink através da rota Tools >> Run on Target
Hardware >> Prepare to Run.... O acesso a este menu é feito conforme exibe a Figura
30.
47
Figura 30 - Acesso ao menu de configurações do Arduino no Simulink
Fonte: Autoria própria
Na janela de configuração de parâmetros aberta em seguida, foi realizada a inserção
dos parâmetros anteriormente descritos. Desta maneira, a Figura 31 a seguir exibe a tela
de configuração com todas as alterações já realizadas.
Figura 31 - Menu de configurações do Arduino no Simulink
Fonte: Autoria própria
A partir deste momento tornou-se possível enviar os programas desenvolvidos no
software para o Arduino e observar o funcionamento dos mesmos sendo executados pelo
48
microcontrolador. Deste ponto em diante, passou-se à construção do diagrama de blocos
e do código a serem rodados para realizar as tarefas finais deste projeto, ou seja, para
possibilitarem o processamento dos sinais provenientes da guitarra e posterior
manipulação da afinação do instrumento através da atuação do Servo Motor.
3.10. Programação
3.10.1. Visão Geral da Programação
A última etapa no desenvolvimento do projeto do Afinador Automático foi a
construção da programação, de modo a permitir ao Arduino realizar a leitura dos sinais
de entrada, seus processamentos e a consequente tomada de decisão sobre a maneira como
as saídas devem ser atualizadas. Para construção de tal programação junto à interface do
MATLAB Simulink, foi consultado e adaptado o programa proposto por Ben Overzat no
fórum Arduino Create (https://create.arduino.cc/) (OVERZAT, 2017).
As duas entradas principais do sistema são o sinal da guitarra e o sinal proveniente
do botão de seleção das cordas. Como saída, existem oito sinais enviados ao Display de
sete dígitos para exibir a corda selecionada, um sinal enviado ao Servo Motor para atuação
nas tarraxas da guitarra e três sinais enviados cada um a seu respectivo terminal do LED
RGB para auxiliar na identificação da afinação do instrumento por parte do usuário.
Existem também parâmetros de código que podem ser alterados no ambiente de
programação para realizar um ajuste mais fino no funcionamento do afinador. São eles o
limite mínimo de amplitude, a velocidade para o motor no sentido horário e a velocidade
para o motor no sentido anti-horário. Tais parâmetros serão comentados em detalhes mais
adiante nesta seção.
De maneira resumida, o código foi segmentado em duas partes. A primeira é
responsável por fazer a leitura do sinal proveniente do botão de seleção de cordas,
atualizar o estado atual de uma Máquina de Estados construída com os parâmetros para
cada corda e atualizar as saídas dos pinos do Display de sete segmentos. A segunda parte
lida com o sinal da guitarra, fazendo sua aquisição e processamento para estimar sua atual
frequência. A partir desta estimativa, passa a controlar o Servo Motor para atuar na
49
guitarra de modo a compensar a diferença entre a frequência atual e a frequência esperada
para a corda selecionada, afinando o instrumento.
Objetivando facilitar a compreensão do desenvolvimento da programação deste
projeto, estas duas segmentações serão explicadas separadamente em detalhes, a seguir.
3.10.2. Máquina de Estados e Seleção de Cordas
Conforme mencionado, foi desenvolvida uma máquina de estados no Simulink para
controlar as saídas e os parâmetros da programação que são alterados a cada vez que o
usuário pressiona o botão de seleção de corda. As saídas controladas são as que alimentam
cada segmento do Display de sete segmentos, que devem ter seus sinais lógicos alterados
para exibir corretamente cada corda selecionada. O parâmetro a ser atualizado é um vetor
que armazena a faixa de período dentro da qual tal corda deve soar para poder ser
considerada afinada. Ou seja, um vetor com dois valores: um para o limite superior e
outro para o limite inferior de período.
Cada corda de uma guitarra corresponde a uma nota específica, com uma frequência
pré-definida. No código do afinador, será identificado o período da onda produzido por
cada corda e, portanto, é necessário que se faça uma equivalência entre as frequências
desejadas e seus respectivos períodos. Sabe-se que, por definição, a frequência é o inverso
do período, conforme a Equação (3) a seguir (HALLIDAY, RESNICK e WALKER,
2009).
𝑓 = 1
𝑇→ 𝑇 =
1
𝑓 (3)
Sendo f a frequência e T o período.
A partir desta relação, construiu-se a Tabela 3, que indica a frequência adotada
como padrão, o respectivo período e a faixa de período que foi adotada na programação
da máquina de estados, para cada corda.
50
Tabela 3 - Frequências e período alvo para cada corda
Corda Frequência
Alvo (Hz)
Período
Alvo (s)
Limites de Período Tolerância
(Hz) Superior Inferior
Mi – E2 82,4 0,0121359 0,0120650 0,0122050 0,95
Lá – A2 110 0,0090909 0,0090385 0,0091436 1,27171307
Ré – D3 146,8 0,0068120 0,0067713 0,0068499 1,694596321
Sol – G3 196 0,0051020 0,0050727 0,0051317 2,266478341
Si – B3 246,9 0,0040502 0,0040262 0,0040730 2,853882566
Mi – E4 329,6 0,0030340 0,0030163 0,0030513 3,802844797
Fonte: Autoria própria
Destaca-se que, dada a característica descrita na Equação (3) anterior, quanto maior
o período, menor a frequência. Logo, o limite superior para o período na verdade
corresponde à menor frequência aceitável para a afinação, enquanto o limite inferior por
sua vez equivale à maior frequência tolerada para cada corda. Esta configuração busca
conferir uma margem de erro adequada para o limite de frequência de cada corda. Vale
observar que a medida de frequência não é linear, ou seja, a diferença de 1 Hz para a
corda Mi mais grave não é equivalente à diferença de 1 Hz para a corda Mi mais aguda.
Isto justifica os diferentes valores de tolerância adotados para cada corda. Com os
parâmetros definidos na Tabela 3, limitou-se a maior faixa de frequência tolerável em
3,80 Hz. Isto implica que a frequência da corda Mi mais aguda poderá estar distante a no
máximo 1,90 Hz da frequência de referência de 329,6 Hz. A menor tolerância, para a
corda Mi mais grave, foi de 0,95 Hz, ou seja, um desvio máximo de 0,475 Hz da
frequência alvo de 82,4 Hz.
Identificou-se o nível lógico a ser enviado para cada segmento do Display de sete
segmentos, de modo a exibir cada corda corretamente. Escolheu-se exibir as cordas
através de suas letras respectivas, sendo a corda Mi mais aguda diferenciada da corda Mi
mais grave através do “ponto” existente no Display. A Tabela 4 exibe a configuração de
sinais lógicos necessários em cada segmento.
51
Tabela 4 - Sinais lógicos para o Display de sete segmentos
Corda Letra
Exibida
Sinal lógico aplicado a cada segmento (1 = ligado)
A B C D E F G PONTO
Mi – E2 E 1 0 0 1 1 1 1 0
Lá – A2 A 1 1 1 0 1 1 1 0
Ré – D3 D 0 1 1 1 1 0 1 0
Sol – G3 G 1 0 1 1 1 1 1 0
Si – B3 B 0 0 1 1 1 1 1 0
Mi – E4 E. 1 0 0 1 1 1 1 1
Fonte: Autoria própria.
Definidos estes parâmetros, foi possível então desenvolver uma máquina de estado,
em que cada estado representa uma corda da guitarra e em que o evento que realiza a
troca de um estado para o outro é o pressionar do botão conectado ao Arduino. Ao
perceber uma alteração de nível baixo para nível alto no sinal, o programa comanda a
mudança de estados. Por padrão, foi determinada que a corda mais grave, Mi (E2) será a
primeira a ser afinada, seguindo em sequência da frequência mais grave para a mais
aguda. A Figura 32 exibe a máquina de estados construída no ambiente do Simulink.
Figura 32 - Máquina de Estados
Fonte: Autoria própria
52
Como se pode notar, em cada estado foram configurados os parâmetros da
respectiva corda para o vetor “FaixaPeriodo” composto pelos valores máximos e mínimos
para o período, e também o sinal lógico de cada saída conectada a um segmento do
Display. A Figura 33 mostra a primeira parte da programação como um todo, exibindo as
entradas e saídas da máquina de estados construída para alterar entre as cordas a serem
afinadas.
Figura 33 - Parte da programação - Seleção de Cordas
Fonte: Autoria própria
Observa-se nesta figura o uso da programação em diagrama de blocos, com blocos
que estão disponíveis graças ao pacote de integração do Arduino no MATLAB Simulink.
Esses blocos são, especificamente, o do pino de entrada (PIN 2), onde se faz a leitura do
sinal do botão seletor de corda, e os pinos de saída do Arduino (PIN 22 a 29), responsáveis
por levar os sinais lógicos a cada segmento do Display de sete segmentos. Foi utilizado
um Scope junto ao sinal de entrada para permitir a visualização do pulso gerado ao se
pressionar o botão.
O bloco central, com nome “Seletor de Corda” é onde está construída a máquina de
estados com a relação de parâmetros para cada corda. A saída deste bloco denominada
“FaixaPeríodo” da máquina de estados é conectada a um bloco do tipo GoTo, para que
53
possa ser utilizada pela parte do programa responsável por fazer a identificação da
frequência da nota sendo tocada.
3.10.3. Detecção do Período da Forma de Onda
A construção da segunda parte da programação envolveu o cálculo do período da
onda sendo produzida pela guitarra, o acionamento do motor para correção da afinação e
indicação através do LED RGB da afinação da corda.
Na programação em diagrama de blocos do Simulink foi adicionada a entrada do
sinal de guitarra, através do bloco de entrada analógica do Arduino com o pino
correspondente (PIN 0). Um novo Scope foi inserido neste ponto para permitir a
visualização do sinal da guitarra amplificado pelo circuito amplificador não-inversor. O
bloco de entrada possui como parâmetro de configuração a taxa de aquisição a ser
utilizada na leitura, em segundos. Esta taxa representa o tempo entre duas aquisições
consecutivas do sinal sendo apresentado na porta de entrada. Configurou-se a taxa para o
valor de 0.0002 segundos, conforme pode-se verificar na Figura 34. Isso equivale a uma
taxa de 5 mil leituras por segundo, ou seja, uma frequência de aquisição de 5 kHz, sendo
esta adequada para o uso com o Arduino DUE por não extrapolar a taxa de aquisição
máxima deste modelo.
Figura 34 - Configuração do bloco de entrada do sinal de guitarra
Fonte: Autoria própria
O principal componente desta parte do programa é o bloco denominado “Estimador
de Nota – Determinação do Sentido de Giro do Servo Motor”. Trata-se de uma função
54
MATLAB, chamada “DirecaoRotacao”, escrita em C/C++ e que será discutida em maiores
detalhes mais adiante. A Figura 35 evidencia que o sinal proveniente da guitarra e os
demais parâmetros de código são fornecidos como entrada para esta função e também que
a partir dela são geradas as saídas, tanto para o Servo Motor quanto para o LED RGB.
Figura 35 - Parte da programação - Determinação de frequência
Fonte: Autoria própria
Como se pode observar, alguns blocos de entrada foram conectados à função
MATLAB. Na entrada “FaixaPeriodo”, foi conectada a saída da máquina de estado através
de um bloco do tipo From, que se conecta ao bloco GoTo especificado anteriormente. Na
entrada “Frame” se conectou o sinal proveniente da guitarra, com destaque para a
existência do bloco “100-ms Frame”. Este bloco é responsável por realizar um buffer no
sinal da guitarra, ou seja, armazenar o sinal por um período e transformá-lo em pacotes
de 100 milissegundos de duração cada. O valor de 100 ms foi escolhido por permitir ao
código analisar um número adequado de períodos da forma de onda. Com isso, o código
da função “DirecaoRotacao” passará a analisar este pacote ao invés de ter que lidar com
um sinal contínuo. Trata-se de uma das etapas da aquisição e adequação do sinal da
guitarra para um ambiente digital.
O próximo bloco de entrada conectado à função MATLAB é um bloco do tipo
Constant, no qual se informa um valor numérico constante. Com ele, determinou-se um
55
limite de amplitude para o sinal da guitarra a partir do qual o Arduino considerará a leitura
como válida. Isso foi feito para evitar que o programa efetue cálculos e tentativas de
afinação em um momento onde não se está tocando nenhuma corda. Para um cenário em
que não se está produzindo nenhum som com a guitarra, observou-se através do Scope
que o sinal da guitarra permaneceu praticamente constante no valor de 500, em uma escala
que vai de 0 a 1023. Esta faixa é a conversão feita pelo Arduino para valores de tensão
que vão de 0 V a 3,3 V em suas portas. Assim, optou-se por um valor de 550 para o bloco
“Limite Mínimo Amplitude”.
Por fim, outros dois blocos do tipo Constant foram utilizados na especificação de
parâmetros para a função “DirecaoRotacao”. Estes são denominados “Vel_Horario” e
“Vel_Anti_Horario” e são utilizados para informar ao código o valor de velocidade a ser
utilizado no controle do Servo Motor. Como a posição central e estacionária do motor
corresponde a um sinal de valor 80, um valor menor a este faz o motor girar no sentido
horário, enquanto um valor maior o acionará no sentido anti-horário. Estes blocos servem
então para fazer a calibragem da velocidade de giro do motor, podendo ser úteis em
momentos que o motor não for capaz de girar as tarraxas devido a uma falta de torque,
bastando para isso alterar os valores destas constantes.
Para as saídas, existem quatro blocos, todos existentes na biblioteca de integração
entre Arduino e MATLAB Simulink. O primeiro é do tipo Standard Servo Write e serve
para enviar o sinal de controle ao Servo Motor, a partir do pino de saída PWM 11 (PIN
11). O valor recebido por este bloco é determinado pela função MATLAB, sendo que
permanecerá parado enquanto não for detectada uma frequência no sinal da guitarra. Os
demais são blocos para enviar sinais às saídas digitais 8, 9 e 10 (PIN 8 a PIN 10) que
estão conectadas aos terminais do LED RGB. Programou-se a função “DirecaoRotacao”
para indicar quando a nota está acima ou abaixo da frequência esperada, acionando a cor
azul ou vermelha, respectivamente. Para o caso de a corda estar afinada, programou-se a
exibição da cor verde.
56
3.10.4. Programação da função MATLAB
Uma vez descritas as entradas e saídas do bloco “Estimador de Nota –
Determinação do Sentido de Giro do Servo Motor”, é necessário descrever a maneira
como foi escrita a função “DirecaoRotacao” presente neste bloco. Esta função atua
detectando o período da onda sendo lida pelo Arduino através da detecção dos seus picos
e posterior cálculo do tempo entre estes picos. Isso é possível pois a forma de onda
produzida pela guitarra é periódica, ou seja, a mesma se repete de tempos em tempos
(GHASSAEI, 2012b). Após detectar o período e compará-lo com o vetor “FaixaPeriodo”,
o programa determina se a frequência do sinal está acima, abaixo, ou de acordo com a
frequência de referência para a corda selecionada.
A primeira verificação realizada no código é se o frame de sinal – ou seja, se o
“pacote” de 100 ms disponibilizado para a função – é valido. Isso é feito verificando se o
início e o fim do frame são maiores do que o valor determinado no bloco “Limite Mínimo
Amplitude”. Caso o sinal seja inválido, o Servo Motor é comandado para a parada e o
LED permanece apagado.
Caso seja detectado um sinal acima do limite mínimo estabelecido, o código passa
para a determinação do período da forma de onda. O programa proposto por (OVERZAT,
2017) utiliza uma técnica de reconhecimento de período chamada “Função de Diferença
da Magnitude Média”, tradução do inglês para “AMDF – Average Magnitude Difference
Function”. Esta função é um dos algoritmos existentes para se realizar a estimativa da
frequência de um sinal de áudio, sendo que outros métodos são o “Espectro do Produto
Harmônico”, “Detecção de Picos”, “Detecção de Ponto Médio”, “Autocorrelação”, entre
outros (GHASSAEI, 2012b) e (CUADRA, MASTER e SAPP, 2001).
A Função de Diferença de Magnitude Média (FDMM) é um algoritmo que busca
analisar o quanto um sinal se correlaciona com sua versão após passado um intervalo de
tempo. Uma forma de onda periódica terá uma forte correlação consigo mesma quando o
intervalo de tempo for igual ao período. A expressão matemática que descreve este
algoritmo é apresentada na Equação 4 (CUADRA, MASTER e SAPP, 2001).
57
𝜓(𝜏) = 1
𝑁∑|𝑥(𝑛) − 𝑥(𝑛 + 𝜏)|
𝑁−1
𝑛=0
(4)
Sendo x(n) o sinal original, x(n+τ) o sinal atrasado por um intervalo de tempo τ e
N o tamanho da amostra. Na implementação do código, N representa o número de
amostras.
A implementação desta função gerará um novo sinal composto por cada valor
absoluto da diferença entre o sinal original e sua versão atrasada. Quando o intervalo de
tempo τ entre as duas amostras de sinais for próximo ao período da onda, a diferença entre
as amostras tenderá a ser zero para formas de ondas periódicas ou quase periódicas
(VERTELETSKAYA e ŠIMÁK, 2009). Esse efeito pode ser verificado na Figura 36.
Figura 36 - Aplicação da Função de Diferença de Magnitude Média
Acima, a forma de onda original. Abaixo, o resultado da aplicação da FDMM.
Fonte: (VERTELETSKAYA e ŠIMÁK, 2009)
Observa-se a existência de “vales” no sinal após a aplicação da FDMM. A distância
entre estes vales corresponde ao período da forma de onda.
A vantagem do uso deste método de detecção de período está no baixo custo
computacional necessário, uma vez que o mesmo analisa apenas a diferença entre duas
versões do sinal adquirido, o que torna o cálculo muito menos complexo do que em
algoritmos que envolvam multiplicações, como o da “Autocorrelação”, por exemplo
(VERTELETSKAYA e ŠIMÁK, 2009) e (CUADRA, MASTER e SAPP, 2001).
58
Definido o método a ser utilizado, o mesmo foi implementado em código na função
MATLAB “DirecaoRotacao”. O mesmo opera da seguinte maneira: é realizada uma da
varredura do frame de sinal, determinando o valor absoluto da diferença de magnitude
entre a amostra original e cada versão atrasada do mesmo, armazenando cada valor desta
diferença num vetor chamado “FDMM”. O passo seguinte realiza a inversão do sinal, ou
seja, transforma-se os vales do sinal em picos, e vice-versa. Em seguida, o código percorre
os elementos deste vetor, comparando-os com o valor de 70% do maior elemento
existente. Assim, todos os elementos com valores menores do que 70% do máximo são
zerados. Isto serve para isolar as regiões aonde estarão localizados os picos do sinal
processado.
O próximo passo é utilizar a função “findpeaks” do MATLAB, que retornará os
picos e seus índices dentro do vetor, ou seja, suas localizações. Tomando a média da
distância entre estes picos, tem-se o período da onda em amostras, sendo que o interesse
do código é ter o período em segundos. Basta para isto realizar a divisão da variável
“PeríodoAmostras” pela variável “TaxaAquisicao”, que no início do código é
configurada para o valor de 5000, conforme a taxa presente no bloco de aquisição do sinal
da guitarra.
Através destas operações, determina-se o período, em segundos, da forma de onda
lida através do PIN 0 do Arduino. A Figura 37 exibe o trecho do código responsável por
esta operação e que foi descrito nos parágrafos anteriores.
Figura 37 - Código para determinação do período da forma de onda
Fonte: Autoria própria.
59
Uma vez criada a parte da função responsável por determinar o período da amostra
do sinal da guitarra, o próximo passo foi então realizar a comparação entre este período e
a faixa de períodos definidos como referência para cada corda. Uma vez que uma das
entradas da função “DirecaoRotacao” é o vetor “FaixaPeriodo” criado na máquina de
estados, bastou escrever no programa a comparação entre o valor real de período
determinado e o valor máximo e mínimo admitidos para a corda selecionada. Criaram-se
então quatro possíveis cenários, onde o primeiro é aquele em que o período da onda está
abaixo do valor mínimo esperado. Neste caso, a frequência da nota tocada está muito alta,
e deve-se girar o Servo Motor no sentido anti-horário para corrigir a afinação. Ao mesmo
tempo, acende-se a luz de cor azul para indicar esta situação. Isto é feito atualizando os
valores das variáveis “VelocidadeServoMotor”, “Led_Vermelho”, “Led_Verde” e
“Led_Azul”, que nada mais são do que as saídas do bloco da função MATLAB e que foram
conectadas aos blocos correspondentes. A Figura 38 a seguir exibe a programação para
esta situação.
Figura 38 - Código para tratamento de períodos de forma de onda abaixo do esperado
Fonte: Autoria própria.
O segundo cenário é aquele no qual o período da onda está acima do valor máximo
esperado, e a frequência, por tanto, está abaixo do ideal. Para esta ocasião, o motor será
comandado para o giro no sentido horário, e se acenderá a cor vermelha do LED, sendo a
programação análoga à da figura acima.
Para o terceiro cenário, a corda tocada da guitarra encontra-se afinada e, então, seu
período está entre os limites estabelecidos na máquina de estados. Desta maneira, o motor
permanecerá parado enquanto se acende a luz verde, de modo a indicar ao usuário que o
mesmo pode passar à afinação da próxima corda.
Por fim, o último cenário é aquele em que o período determinado encontra-se muito
distante do intervalo especificado para a corda selecionada, tanto para valores muito
baixos ou muito altos. Esta situação representa uma provável leitura inválida e que deve
60
ser desconsiderada. O motor permanece parado e o LED apagado, do mesmo modo que
ocorre quando o frame não atinge o valor mínimo de amplitude.
Assim, concluiu-se o desenvolvimento da função MATLAB “DirecaoRotacao” e,
também, toda a parte de programação, tanto em linguagem escrita quanto no uso de
diagramas de bloco. O código completo pode ser verificado no APÊNDICE A.
A partir deste momento, pôde-se enviar o programa para o Arduino DUE. O modo
como se realiza tal envio pode ser verificado no APÊNDICE B. O APÊNDICE C
apresenta a janela os resultados da geração do código. Com o programa salvo no Arduino,
foi possível então executá-lo para analisar os resultados, que serão discutidos a seguir.
61
4. RESULTADOS E DISCUSSÕES
Com a conclusão do desenvolvimento do projeto, tendo todas as partes que
constituem o afinador construídas, foi possível então passar para a etapa de testes e
verificação dos resultados alcançados através da execução do código pelo Arduino. Tais
resultados obtidos e os eventuais ajustes realizados para corrigir o funcionamento do
Afinador Automático de Guitarra serão apresentados nesta seção.
Primeiramente, através da Figura 39 pode-se conferir a construção física final do
projeto, com todos os circuitos presentes: amplificador, seletor de corda e indicador de
afinação, bem como o Servo Motor, e suas conexões com o Arduino.
Figura 39 - Implementação final do projeto
Fonte: Acervo pessoal.
Embora os testes do afinador como um todo tenham sido executados apenas após a
conclusão do desenvolvimento, cada circuito que compõe o projeto passou por seus testes
nos momentos em que foram construídos. A seguir, serão apresentados e discutidos os
resultados finais da execução do projeto para cada parte componente do mesmo.
Em primeiro lugar, para o circuito amplificador não inversor, percebeu-se um
funcionamento adequado e dentro do que era esperado. A presença do potenciômetro
neste circuito e a variação de sua resistência ocasionaram alterações no ganho de
amplitude do sinal proveniente da guitarra. Através da equação de ganho (Equação (2))
62
apresentada na Conceituação deste trabalho, pôde-se determinar o ganho esperado para
algumas situações. Para a Equação (2), tem-se Vo a tensão de saída, Vi a tensão de
entrada, Rf a resistência de realimentação (que liga a saída à entrada não inversora), neste
projeto com o valor fixo de 100 KΩ e R1 a resistência variável do potenciômetro de 10
KΩ.
Assim, para o máximo valor de resistência do potenciômetro, tem-se o maior valor
possível para R1, igual a 10 KΩ. Nesta situação, o ganho esperado é de:
𝐺𝑎𝑛ℎ𝑜1 = (1 +𝑅𝑓
𝑅1) = (1 +
100𝐾
10𝐾) = 11
Este é o menor ganho possível para o circuito amplificador não inversor
implementado.
Ao variar o potenciômetro até sua posição central, obtém-se um valor de resistência
de 5 KΩ. Nesta situação, o ganho será:
𝐺𝑎𝑛ℎ𝑜2 = (1 +𝑅𝑓
𝑅1) = (1 +
100𝐾
5𝐾) = 21
Por fim, o maior ganho teórico possível para o circuito tende a infinito, uma vez
que R1 apresentará valores muito próximos a zero. Entretanto, na prática isso não é
possível, dado que o Amplificador Operacional possui limites de operação e
amplificação. Isto posto, ao levar o potenciômetro ao seu menor valor de resistência, o
AOP passará a “ceifar” a forma de onda, ou seja, limitará a amplitude da forma de onda
de saída, que perderá suas características desejadas (WENDLING, 2010).
Uma vez obtidos os resultados para alguns ganhos possíveis, o primeiro teste
realizado com o circuito amplificador buscou verificar se o mesmo operava corretamente.
Aplicou-se na entrada do circuito uma forma de onda de 110,6 Hz de frequência e de
200 mV de amplitude máxima, com oscilação em torno de 0 V (0 V de tensão DC).
Utilizou-se o Arduino Uno com o objetivo de adaptar o sinal para uma tensão pico-a-pico
de 5 V e oscilação em torno de 2,5 V (2,5 V de tensão DC). A Figura 40 apresenta a
63
configuração do gerador de funções para a produção da onda de entrada e a Figura 41
apresenta tanto a onda de entrada quanto a onda de saída do circuito de amplificação.
Figura 40 - Gerador de função
Fonte: Acervo pessoal.
Figura 41 - Resultado da amplificação
Fonte: Acervo pessoal.
Pode-se perceber um resultado satisfatório para o teste realizado, uma vez que se
obteve uma onda de saída (em azul) com tensão pico-a-pico de 4,88 V e uma tensão DC
de 2,44 V, valores muito próximos do esperado.
Buscou-se em seguida analisar como os ganhos das situações anteriormente
descritas poderiam ser empregados no projeto. Observou-se que a guitarra produzia sinais
elétricos com amplitudes menores do que o esperado, estando estes em torno de 100 mV,
variando de acordo com a corda tocada. Considerando uma tensão de entrada de 100 mV,
o ganho mínimo do circuito, Ganho1, de 11 vezes, propiciaria uma tensão de saída com
amplitude máxima de 1,1 V. Esta tensão já seria adequada para a operação do circuito,
64
podendo, entretanto, ser melhor adequada para aproveitar mais eficientemente a precisão
do Arduino.
Para o segundo valor de ganho determinado anteriormente, Ganho2, de 21 vezes, o
resultado da amplificação já se mostra acima do limite de tensão suportado pelas portas
do Arduino Due, de 3,3 volts. O resultado da amplificação de um sinal de 100 mV seria
uma onda com amplitude máxima de 2,1 V, entretanto, deve-se ressaltar que este valor
oscila em torno de uma tensão média de 1,65 V, o que significaria então uma variação
entre -0,45 V e 3,75 V. Esta oscilação pode danificar o microcontrolador, devendo ser
evitada.
O ponto ideal para operação pode então ser determinado considerando-se que se
deseja elevar a amplitude máxima do sinal de 100 mV para 1,65 V. Para isso, pode-se
fazer a seguinte conta:
𝐺𝑎𝑛ℎ𝑜 = 𝑉𝑂
𝑉𝑖=
1650 𝑚𝑉
100 𝑚𝑉= 16,5
Obtido o valor do ganho, pode-se determinar a resistência R1 do potenciômetro:
𝐺𝑎𝑛ℎ𝑜 = (1 +𝑅𝑓
𝑅1) → 16,5 = (1 +
100 𝑘Ω
𝑅1) → 𝑅1 = 6,06𝑘Ω
Outro ponto analisado com relação ao funcionamento do circuito amplificador foi
o desvio da tensão média. Para o teste realizado com o Arduino Uno e apresentado na
Figura 41, conforme já expressado, notou-se um deslocamento adequado da tensão DC.
Para a operação com o Arduino DUE, através da medição com um voltímetro, notou-se
que a tensão no ponto central do divisor de tensão oscilava em torno de valores próximos
a 1,65 V, conforme esperado.
Através do Scope denominado “Scope Sinal de Entrada” inserido no código, foi
possível observar a forma de onda do sinal da guitarra. A Figura 42 a seguir exibe a onda
para um momento em que não é tocada nenhuma corda.
65
Figura 42 - Sinal de áudio adquirido para a guitarra em silêncio
Fonte: Autoria própria.
Observa-se que o sinal se mantém praticamente estável em torno do valor de 450,
em uma escala adimensional que vai de 0 a 1023 – que representa uma discretização dos
valores de tensão realizada pelo Arduino. Através desse resultado, alterou-se o valor do
bloco constante “Limite Mínimo de Amplitude” para 550, para que apenas sinais com
tensões acima desse limite tenham sua frequência analisada pelo afinador. Isso evitou que
o motor se movesse incessantemente para qualquer pequeno sinal detectado.
Na Figura 43 a seguir é possível visualizar a onda captada quando uma corda é
tocada. Nesta configuração, a resistência do potenciômetro possuía valor de cerca de 6,3
KΩ.
Figura 43 - Sinal de áudio adquirido ao se tocar uma corda
Fonte: Autoria própria.
66
Observa-se que a onda se manteve dentro dos limites operacionais do Arduino
DUE, pois ocupou praticamente todo o espectro de valores discretos disponível sem
extrapolar seus extremos.
O próximo estágio do projeto analisado foi o circuito seletor de corda, composto
pelo Push Button e pelo Display de sete segmentos. Para conferir seu funcionamento,
iniciou-se a execução do código e, através do pressionamento do botão seletor, conferiu-
se a sequência de letras exibidas. Notou-se que a primeira letra exibida foi a “E”,
conforme programado, indicando que a primeira corda selecionada foi a Mi mais grave.
A sequência seguida pelo código correspondeu à esperada e não se notou a existência de
ruídos no pressionamento do botão.
Através do Scope denominado “Scope Botão”, foi possível visualizar o sinal
proveniente do botão de seleção. Notou-se a existência do pulso de subida, que é o evento
responsável por alterar os estados da máquina de estados, trocando então a corda
selecionada. Este pulso é exibido na Figura 44.
Figura 44 - Pulso do botão seletor de corda
Fonte: Autoria própria.
Já a Figura 45 a seguir mostra o Display exibindo cada uma das letras programadas,
evidenciando o resultado positivo tanto da implementação do circuito quanto da
programação da máquina de estados.
67
Figura 45 - Display de sete segmentos - Exibição de cada corda
Fonte: Autoria própria.
Em seguida, analisou-se os resultados obtidos no funcionamento do circuito
indicador de afinação. Como resultado, era esperado que, para cordas com frequência
abaixo da frequência de referência, de acordo com a frequência de referência e acima da
frequência de referência, o LED RGB deveria acender a cor vermelha, verde e azul,
respectivamente. Para conferir o funcionamento, desafinou-se a guitarra de modo a saber
qual cor deveria ser exibida pelo afinador.
O resultado pode ser conferido na Figura 46. Conforme desejado, ao tocar a corda
com frequência abaixo da correta, o LED acendeu sua luz vermelha, enquanto a luz verde
foi exibida para uma corda afinada corretamente e a luz azul surgiu quanto se tocou uma
corda afinada acima da frequência correta.
Figura 46 - LED RGB - Exibição de cada estado de afinação
Fonte: Autoria própria.
Neste momento, foi possível também confirmar o correto funcionamento do Servo
Motor. Com relação à adaptação realizada, a resistência enxergada pelo controlador
interno do motor deixou de variar de acordo com a posição do eixo do servo, o que na
prática significa que o controlador passou a “entender” que o Servo Motor não consegue
atingir a posição desejada e com isso mantém o mesmo girando constantemente quando
acionado com valores diferentes daquele que o mantém em sua posição central – valor
que neste caso foi de 80.
68
Assim, o Servo Motor permaneceu parado enquanto o LED estava apagado ou aceso
com a cor verde, sendo que na primeira situação o mesmo deveria permanecer parado
dado que o afinador não identificou nenhum sinal válido e na segunda situação o afinador
calculou um período para a forma de onda já dentro do esperado, indicando uma corda
afinada e que, portanto, não requer atuação do servo. Para os momentos em que a cor
exibida foi a azul, o motor girou no sentido anti-horário e, enquanto a cor exibida foi a
vermelha, no sentido horário. Este comportamento se mostrou de acordo com o
programado.
O próximo passo então foi realizar a afinação da guitarra utilizando o afinador
automático como um todo. Selecionou-se a corda desejada e segurou-se o Servo Motor
junto à tarraxa correspondente, para que o motor atuasse na mesma, afinando-a. Em um
primeiro momento, notou-se que a velocidade do motor estava configurada para valores
muito rápidos e que não se mostraram satisfatórios, pois a frequência desejada era
ultrapassada com muita facilidade e requeria do afinador uma tentativa de atuação no
sentido contrário.
Alterou-se então os valores dos blocos constantes “Vel_Horario” e
“Vel_Anti_Horario” da programação para os valores de 60 e 90, respectivamente. Estes
valores, por estarem mais próximos do valor de 80 que mantém o motor parado, fizeram
com que o Servo Motor girasse mais devagar, de modo a apresentar uma atuação mais
suave sobre as tarraxas da guitarra. Com este ajuste, corrigiu-se o problema ocasionado
pelo excesso de velocidade do motor.
Na Figura 47, é possível observar o motor sendo conectado à tarraxa da guitarra
para sua atuação sobre o instrumento.
69
Figura 47 - Motor acoplado à tarraxa da guitarra
Fonte: Acervo pessoal.
Para finalizar então os testes de afinação, fez-se uma passagem sequencial com o
afinador em todas as cordas para verificar o funcionamento geral do afinador. Todos os
circuitos componentes demonstraram um correto funcionamento conjunto, sem que
nenhum deles apresentasse intermitência ou comportamentos inesperados.
Um ponto observado, entretanto, diz respeito à sensibilidade do código para
identificar a frequência da forma de onda. No teste de afinação de algumas cordas, notou-
se que o afinador oscilava rapidamente entre os três resultados possíveis de afinação e,
em outros casos, em um primeiro momento era identificada uma nota de frequência acima
da esperada para, logo em seguida, se exibir o resultado de frequência abaixo da esperada.
Estes desvios puderam ser corrigidos adaptando a maneira como as cordas eram
tocadas. Percebeu-se que a sensibilidade do afinador reduziu quando se passou a abafar
as cordas não sendo tocadas com a palma da mão. Isso impede que tais cordas vibrem e
gerem sinais elétricos junto com a corda sendo afinada. Outro cuidado tomado foi o de
não tocar as cordas com força excessiva, pois isso gerou, no primeiro momento, uma onda
com frequência superior à real frequência de vibração da corda, ocasionando erros de
análise por parte do afinador.
Adotadas estas correções, observou-se um funcionamento satisfatório do projeto
como um todo, dado que a afinação da guitarra foi realizada com sucesso, o que evidencia
70
que os circuitos construídos e a programação desenvolvida para o Afinador Automático
de Guitarra foram capazes de executar as tarefas pretendidas.
71
5. CONCLUSÃO
A partir do desenvolvimento deste trabalho de graduação, atingiu-se como principal
resultado um afinador automático de guitarra. Este foi construído com circuitos
controlados pelo Arduino e possibilitou uma correta atuação sobre o instrumento. O
afinador foi capaz de permanecer dentro da faixa de tolerância de erro programada para
cada uma das cordas da guitarra. A tolerância mínima programada e atendida pelo
afinador foi de 0,95 Hz, para a corda Mi mais grave e de frequência alvo 82,4 Hz. A
máxima tolerância permitida e também atendida pelo projeto foi de 1,90 Hz, para a corda
Mi mais aguda, com frequência de referência de 329,6 Hz.
O objetivo deste trabalho foi projetar e construir um afinador automático para
guitarra através da integração entre o Arduino e o software MATLAB Simulink. A partir
deste objetivo, iniciou-se um estudo para averiguar quais os requerimentos para a
execução do projeto, buscando conhecimentos que deveriam ser adquiridos, bem como
quais materiais seriam necessários para construção de um afinador utilizando as interfaces
propostas. Assim, chegou-se à definição dos componentes eletrônicos e computacionais
a serem utilizados.
Partiu-se então para a aquisição dos materiais e consequente familiarização com o
funcionamento dos mesmos. Optou-se pela construção parcial dos circuitos que formam
o projeto justamente para que fossem validadas as etapas de aquisição, processamento e
atuação sobre o sinal de áudio produzido pela guitarra.
Com todos os circuitos conectados ao Arduino, passou-se à etapa de programação
do mesmo. A existência de um pacote de integração entre o microcontrolador e o
MATLAB Simulink e a sua configuração deram acesso à uma biblioteca de blocos que
facilitaram a construção do programa, por se tratarem de blocos responsáveis por fazer a
comunicação entre o Arduino e o software de forma gráfica e intuitiva, reduzindo a
quantidade de linhas de código necessárias para execução do projeto.
Mesmo com tal ferramenta à disposição, seus recursos sozinhos não foram capazes
de suprir toda a programação necessária. Para isso, foi desenvolvida uma máquina de
estados e uma função MATLAB para atuação conjunta com o diagrama de blocos. A
72
máquina de estados foi responsável por guardar os parâmetros de afinação de cada corda
e por conter a sequência de segmentos a serem exibidos no Display do circuito seletor de
cordas. A função MATLAB foi responsável por fazer o processamento do sinal de áudio
proveniente do circuito amplificador, realizando os cálculos necessários para determinar
o período da forma de onda analisada e determinar de qual modo o Servo Motor deveria
ser acionado para corrigir a afinação da guitarra.
Com os resultados obtidos e as devidas correções realizadas, concluiu-se que o
objetivo inicial foi alcançado, mostrando-se então a total exequibilidade do projeto. O
produto final desenvolvido foi um afinador automático para guitarra capaz de atuar de
maneira autônoma sobre as tarraxas do instrumento e realizar a afinação do mesmo,
estando a frequência detectada para a corda acima ou abaixo da ideal.
Não somente o projeto se mostrou exequível como utilizou materiais de fácil
aquisição e de baixo custo. O trabalho mostrou possuir grande possibilidade de
reprodução e até de desenvolvimento de aprimoramentos. Uma possível alteração seria
realizar a pesquisa de um circuito amplificador não inversor no qual se utilize um
Amplificador Operacional que requeira valores menores de alimentação. Embora
disponíveis em abundância, o uso de duas baterias de 9 V pode se mostrar desfavorável
para a comercialização do afinador como um produto de mercado. Assim, poder-se-ia
utilizar um Amplificador Operacional que opere com as tensões disponíveis nas portas
do próprio Arduino, de 5 V, 3,3 V e 0 V.
O afinador foi criado para ser utilizado com uma guitarra de 6 cordas e que adote a
afinação padrão para violões e guitarras, apresentada no decorrer desta monografia.
Recomenda-se como trabalho futuro ampliar o leque de atuação do afinador,
programando-o para atender a instrumentos que possuam mais ou menos cordas, tais
quais como uma guitarra de sete cordas ou mesmo um Ukulele, com quatro cordas. Outra
possibilidade de implementação seria permitir ao usuário ter acesso a afinações não
convencionais em que os parâmetros da máquina de estados desenvolvida pudessem
variar de acordo com o tipo de afinação escolhida. Tais aprimoramentos poderiam
73
otimizar a aplicabilidade do afinador e conferir ao mesmo um maior valor agregado,
despertando também um maior interesse comercial.
Por fim, alguns parâmetros da programação estão acessíveis somente no ambiente
de desenvolvimento do Simulink, tais como a velocidade ideal de rotação do Servo Motor
e o limite mínimo de amplitude que deve ser considerado como válido. Para trabalhos
futuros, recomenda-se realizar adequações que permitam ao programa identificar quando
estes parâmetros estão inadequados, corrigindo-os assim em tempo real sem a
necessidade de configurações complexas por parte do usuário.
De modo geral, o trabalho realizado atende às expectativas iniciais e demonstra que,
embora estejam em campos de conhecimento distintos, a música e a tecnologia podem
caminhar juntas, bastando para isso que exista o interesse e a pesquisa de maneiras de
trazê-las para perto uma da outra.
74
REFERÊNCIAS
ANDERTON, C. How Gibson G FORCE™ Automatic Tuning Works. Gibson, 2014.
Disponivel em: <http://www.gibson.com/News-Lifestyle/Features/en-us/How-Gibson-G-
FORCE-Automatic-Tuning-Works.aspx>. Acesso em: 18 Fevereiro 2018.
ARDUINO. Wikipedia, the free encyclopedia, 2018. Disponivel em:
<https://en.wikipedia.org/wiki/Arduino>. Acesso em: 13 Fevereiro 2018.
ARDUINO. What is Arduino? Arduino, 2018a. Disponivel em:
<https://www.arduino.cc/en/Guide/Introduction>. Acesso em: 13 Fevereiro 2018.
ARDUINO. Arduino Products. Arduino, 2018b. Disponivel em:
<https://www.arduino.cc/en/Main/Products>. Acesso em: 13 Fevereiro 2018.
ARDUINO. ARDUINO DUE. Arduino, 2018c. Disponivel em:
<https://store.arduino.cc/usa/arduino-due>. Acesso em: 13 Fevereiro 2018.
ARDUINO. Blink. Arduino, 2018d. Disponivel em:
<https://www.arduino.cc/en/tutorial/blink>. Acesso em: 12 Março 2018.
BAND INDUSTRIES. Roadie 2 Product Manual: Getting Started with Roadie 2, 2017a.
Disponivel em: <https://www.roadietuner.com/manual.pdf>. Acesso em: 24 Fevereiro 2018.
BAND INDUSTRIES. Roadie 2: We tune your rock. Roadie, 2017b. Disponivel em:
<https://www.roadietuner.com/roadie2vB/>. Acesso em: 24 Fevereiro 2018.
BARBOUR, J. M. Tuning and Temperament: A Historical Survey. New York: Dover
Publications, Inc, 2004.
BOSS. TU-12EX Chromatic Tuner. Boss, 2018a. Disponivel em:
<https://www.boss.info/us/products/tu-12ex/>. Acesso em: 18 Fevereiro 2018.
BOSS. TU-30 Tuner & Metronome. Boss, 2018b. Disponivel em:
<https://www.boss.info/us/products/tu-30/>. Acesso em: 18 Fevereiro 2018.
CIRCUITS TODAY. Arduino and 7 Segment Display – Interfacing Tutorial. Circuits Today,
2016. Disponivel em: <http://www.circuitstoday.com/arduino-and-7-segment-display>.
Acesso em: 14 Abril 2018.
CUADRA, P. D. L.; MASTER, A.; SAPP, C. Efficient Pitch Detection Techniques for
Interactive Music. Center for Computer Research in Music and Acoustics, Stanford
University. Stanford, p. 4. 2001.
DONOSO, J. P. et al. A física do violino. Revista Brasileira de Ensino de Física, São Paulo,
v. 30, n. 2, p. 2305.1-2305.21, 2008. Disponivel em:
<http://www.scielo.br/scielo.php?script=sci_arttext&pid=S1806-
11172008000200006&lng=en&nrm=iso>. Acesso em: 13 Abril 2018.
GHASSAEI, A. Arduino Audio Input. Instructables, 2012a. Disponivel em:
<http://www.instructables.com/id/Arduino-Audio-Input/>. Acesso em: 11 Fevereiro 2018.
75
GHASSAEI, A. Arduino Frequency Detection. Instructables, 2012b. Disponivel em:
<http://www.instructables.com/id/Arduino-Frequency-Detection/>. Acesso em: 11 Fevereiro
2018.
GIBSON BRANDS. Gibson G FORCE 2016 Owner’s Manual, 2016. Disponivel em:
<http://images.gibson.com.s3.amazonaws.com/Media/Product-
Documentation/GFORCE_Owners_Manual_2016_v1.pdf>. Acesso em: 18 Fevereiro 2018.
HALLIDAY, D.; RESNICK, R.; WALKER, J. Fundamentos de Física, volume 2:
gravitação, ondas e termodinâmica. Rio de Janeiro: LTC, v. 2, 2009.
INTERNATIONAL ORGANIZATION FOR STANDARDIZATION. ISO 16:1975:
Acoustics - Standard tuning frequency (Standard musical pitch). International
Organization for Standardization. [S.l.]. 1975.
OVERZAT, B. Arduino-Based Automatic Guitar Tuner. Arduino Project Hub, 2017.
Disponivel em: <https://create.arduino.cc/projecthub/ben-overzat/arduino-based-automatic-
guitar-tuner-2093fe>. Acesso em: 13 Fevereiro 2018.
REED, F. How Do Servo Motors Work. Jameco Electronics, 2018. Disponivel em:
<https://www.jameco.com/jameco/workshop/howitworks/how-servo-motors-work.html>.
Acesso em: 04 Março 2018.
SAWICZ, D. Hobby Servo Fundamentals, 2001. Disponivel em:
<http://www.princeton.edu/~mae412/TEXT/NTRAK2002/292-302.pdf>. Acesso em: 04
Março 2018.
STMICROELECTRONICS. TL082A - TL082B: GENERAL PURPOSE J-FET DUAL
OPERATIONAL AMPLIFIERS, 2002. Disponivel em:
<http://pdf.datasheetcatalog.com/datasheet/stmicroelectronics/2300.pdf>. Acesso em: 14
Abril 2018.
TEWARI, A. Modern Control Design With MATLAB and SIMULINK. Chichester:
JOHN WILEY & SONS, LTD, 2002.
THE MATHWORKS INC. MATLAB Product Description. MathWorks, 2018a. Disponivel
em: <http://www.mathworks.com/help/matlab/learn_matlab/product-description.html>.
Acesso em: 14 Fevereiro 2018.
THE MATHWORKS INC. Simulink Support Package for Arduino Hardware. MathWorks,
2018b. Disponivel em: <https://www.mathworks.com/help/supportpkg/arduino/>. Acesso em:
13 Fevereiro 2018.
THE MATHWORKS INC. Arduino Support from Simulink. MathWorks, 2018c. Disponivel
em: <https://www.mathworks.com/hardware-support/arduino-simulink.html>. Acesso em: 13
Fevereiro 2018.
THE MATHWORKS INC. Standard Servo Write. MathWorks, 2018d. Disponivel em:
<https://www.mathworks.com/help/supportpkg/arduino/ref/standardservowrite.html>. Acesso
em: 14 Abril 2018.
76
VERTELETSKAYA, E.; ŠIMÁK, B. Performance evaluation of pitch detection
algorithms. Access Server, Online Journal. [S.l.]. 2009.
WENDLING, M. Amplificadores Operacionais. Universidade Estadual Paulista - Campus
de Guaratinguetá. Guaratinguetá, p. 44. 2010.
77
APÊNDICE A – Código da Função MATLAB
function [VelocidadeServoMotor, Led_Vermelho, Led_Verde, Led_Azul] =
DirecaoRotacao(FaixaPeriodo, frame, LimiteAmplitude,Velocidade_Horario,
Velocidade_Anti_Horario)
%% Inicialização TaxaAquisicao = 5000; L = length(frame) * 0.3;
%% Validação do Frame. Verificação de validade de acordo com o Limite de
Amplitude definido InicioFrame = frame(1:L); %Define inicio do Frame FimFrame = frame((length(frame) - L):length(frame)); %Define fim do Frame FrameValido = (max(InicioFrame) > LimiteAmplitude) && (max(FimFrame) >
LimiteAmplitude); %Valida Frame com o Limite de Amplitude
if FrameValido %% Determinação do período da forma de onda % Cria um vetor da Funçao de Diferença de Magnitude Média (FDMM) CompFDMM = floor(length(frame) / 2); %Comprimento FDMM = zeros(CompFDMM,1);
for i = 1:CompFDMM FDMM(i) = mean(abs(frame(1:CompFDMM) - frame((1 + i):(CompFDMM + i)))); end
FDMM = max(FDMM) - FDMM;
%Identificação de Picos no vetor FDMM Pico = 0.7 * max(FDMM); %Define a variavel Pico como 0,7 do máximo do
vetor
FDMM(FDMM < Pico) = 0; %Zera todos os elementos do vetor menores do que
0,7 do Pico
[~, locs] = findpeaks(FDMM); %Localiza os picos dentro do vetor
%Calcula o período através da média da diferença entre picos consecutivos PeriodoAmostras = mean(diff(locs)); PeriodoEmSegundos = PeriodoAmostras / TaxaAquisicao;
%Determina a direção de rotação das tarrachas baseado nas leituras
anteriores e na corda selecionada
%% Promove atuação do motor baseado no período da forma de onda if PeriodoEmSegundos < FaixaPeriodo(1) && PeriodoEmSegundos >
FaixaPeriodo(1)/2 %Período da onda abaixo do esperado. Girar ANTI-HORÁRIO.
Acender AZUL VelocidadeServoMotor = Velocidade_Anti_Horario; Led_Vermelho = 0; Led_Verde = 0; Led_Azul = 1;
78
elseif PeriodoEmSegundos > FaixaPeriodo(2) && PeriodoEmSegundos <
FaixaPeriodo(1)*2 %Período da onda acima do esperado. Girar HORÁRIO.
Acender VERMELHO VelocidadeServoMotor = Velocidade_Horario; Led_Vermelho = 1; Led_Verde = 0; Led_Azul = 0;
elseif PeriodoEmSegundos > FaixaPeriodo(1) && PeriodoEmSegundos <
FaixaPeriodo(2) %Corda está afinada. MOTOR PARADO. LED APAGADO VelocidadeServoMotor = 80; Led_Vermelho = 0; Led_Verde = 1; Led_Azul = 0;
else %Periodo está fora da região esperada. Provável leitura inválida.
MOTOR PARADO. LED APAGADO VelocidadeServoMotor = 80; Led_Vermelho = 0; Led_Verde = 0; Led_Azul = 0; end
else %O frame de áudio não é valido e não deve haver afinação. MOTOR
PARADO. LED APAGADO VelocidadeServoMotor = 80; Led_Vermelho = 0; Led_Verde = 0; Led_Azul = 0; end end
79
APÊNDICE B – Envio do código para o Arduino
O envio para o Arduino é realizado através do comando “Deploy to Hardware”
dentro do ambiente MATLAB Simulink
80
APÊNDICE C – Resultado do envio do código ao Arduino
81
ANEXO A – Datasheet do Amplificador Operacional TL082
82
83
84
85
86
87
88
89
90
91
![Introdução ao Simulink[1].pdf](https://static.fdocumentos.com/doc/165x107/55721355497959fc0b9218f2/introducao-ao-simulink1pdf.jpg)
