Embed Size (px)
Citation preview
UNIVERSIDADE REGIONAL DE BLUMENAU
CENTRO DE CIÊNCIAS EXATAS E NATURAIS
CURSO DE CIÊNCIAS DA COMPUTAÇÃO
(Bacharelado)
PROTÓTIPO DE UM SISTEMA PARA AUXÍLIO AO TREINAMENTO DA PERCEPÇÃO MUSICAL
TRABALHO DE CONCLUSÃO DE CURSO SUBMETIDO À UNIVERSIDADE REGIONAL DE BLUMENAU PARA A OBTENÇÃO DOS CRÉDITOS NA
DISCIPLINA COM NOME EQUIVALENTE NO CURSO DE CIÊNCIAS DA COMPUTAÇÃO — BACHARELADO
RICARDO ALEXANDRE BRANDELLI TOMEDI
BLUMENAU, JULHO/2002
2002/1-62
PROTÓTIPO DE UM SISTEMA PARA AUXÍLIO AO TREINAMENTO DA PERCEPÇÃO MUSICAL
RICARDO ALEXANDRE BRANDELLI TOMEDI
ESTE TRABALHO DE CONCLUSÃO DE CURSO, FOI JULGADO ADEQUADO PARA OBTENÇÃO DOS CRÉDITOS NA DISCIPLINA DE TRABALHO DE
CONCLUSÃO DE CURSO OBRIGATÓRIA PARA OBTENÇÃO DO TÍTULO DE:
BACHAREL EM CIÊNCIAS DA COMPUTAÇÃO
Prof. Paulo César Rodacki Gomes — Orientador na FURB
Prof. José Roque Voltolini da Silva — Coordenador do TCC
BANCA EXAMINADORA
Prof. Paulo César Rodacki Gomes Prof. Roberto Heinzle Prof. Miguel Wisintainer
ii
AGRADECIMENTO
À Deus, por seu amor infinito e por sempre mostrar o caminho.
Aos meus pais, Adenir Luiz Tomedi e Maria Rosa Brandelli Tomedi, e minha irmã
Danielle Alessandra Brandelli Tomedi, pelo apoio, incentivo ao estudo, carinho e dedicação.
À minha namorada Dione Trainotti pelo amor, carinho e compreensão.
Ao professor Paulo César Rodacki Gomes que me orientou neste trabalho com
paciência, dedicação e sabedoria.
Aos demais amigos e todas as pessoas que me apoiaram de uma forma direta ou
indireta para a realização deste trabalho.
À todos muito obrigado.
iii
SUMÁRIO AGRADECIMENTO ............................................................................................................... III
LISTA DE FIGURAS ............................................................................................................ VII
LISTA DE QUADROS .........................................................................................................VIII
RESUMO .................................................................................................................................. X
ABSTRACT .............................................................................................................................XI
1 INTRODUÇÃO.....................................................................................................................1
1.1 OBJETIVOS........................................................................................................................2
1.2 ORGANIZAÇÃO DO TEXTO...........................................................................................3
2 TEORIA MUSICAL..............................................................................................................4
2.1 ORIGEM HISTÓRICA.......................................................................................................4
2.2 OS PRIMEIROS PASSOS DA MELODIA........................................................................6
2.3 A ORIGEM DA MÚSICA COMO CONHECEMOS ........................................................6
2.4 TEORIA DA MÚSICA .......................................................................................................7
2.4.1 INTERVALOS..................................................................................................................9
2.4.2 ESCALAS.......................................................................................................................10
2.4.3 ACORDES ......................................................................................................................10
2.5 O MODELO INTEIRO DE ALTURAS ...........................................................................11
2.5.1 TERMOS E HIPÓTESES...............................................................................................12
2.5.2 ALTURAS E SEUS INTERVALOS..............................................................................13
2.5.3 CLASSES DE ALTURAS E SEUS INTERVALOS .....................................................14
2.5.4 INTERVALO DE CLASSE DE ALTURA ORDENADO.............................................16
2.5.5 INTERVALO DE CLASSE DE ALTURA DESORDENADO; CONJUNTOS............17
2.5.6 TRANSPOSIÇÃO ..........................................................................................................19
iv
2.5.7 TRANSPOSIÇÃO DE ALTURAS.................................................................................19
2.5.8 TRANSPOSIÇÃO DE CLASSE DE ALTURA.............................................................19
3 MIDI ....................................................................................................................................21
3.1 UMA BREVE HISTÓRIA................................................................................................21
3.2 A TECNOLOGIA MIDI ...................................................................................................22
3.3 GENERAL MIDI ..............................................................................................................24
3.4 CONFIGURAÇÃO DE SONS GENERAL MIDI ............................................................25
3.5 CONTROLADORES MIDI ..............................................................................................25
3.6 TIPOS DE CONTROLADORES MIDI............................................................................26
3.7 FORMATO DE ARQUIVOS MIDI .................................................................................26
3.8 EVENTOS.........................................................................................................................28
3.9 PROTOCOLO MIDI .........................................................................................................28
3.10 RUNNING STATUS ........................................................................................................31
3.11 SINCRONIZANDO A REPRODUÇÃO DA SEQUÊNCIA............................................32
3.12 IGNORANDO MENSAGENS MIDI ...............................................................................33
4 DESENVOLVIMENTO DO PROTÓTIPO ........................................................................34
4.1 REQUISITOS PRINCIPAIS DO PROBLEMA A SER TRABALHADO.......................34
4.2 ESPECIFICAÇÃO DO PROTÓTIPO ..............................................................................34
4.2.1 DIAGRAMA DE CASO DE USO .................................................................................35
4.2.2 DIAGRAMA DE CLASSES ..........................................................................................36
4.2.3 DIAGRAMA DE SEQÜÊNCIA.....................................................................................39
4.3 IMPLEMENTAÇÃO ........................................................................................................41
4.3.1 TÉCNICAS E FERRAMENTAS UTILIZADAS...........................................................41
4.3.2 OPERACIONALIDADE DA IMPLEMENTAÇÃO......................................................51
5 CONCLUSÕES ...................................................................................................................60
v
5.1 EXTENSÕES ....................................................................................................................61
ANEXO 1 - PATCHES (TIMBRES) GENERAL MIDI .........................................................62
ANEXO 2 - PERCUSSÃO GENERAL MIDI .........................................................................63
ANEXO 3 - MÉTODO EXECUTAQUESTAO ........................................................................64
REFERÊNCIAS BIBLIOGRÁFICAS .....................................................................................69
vi
LISTA DE FIGURAS Figura 1 – DIAGRAMA DE CASO DE USO ........................................................................35
Figura 2 – DIAGRAMA DE CLASSE ...................................................................................36
Figura 3 – DIAGRAMA DE SEQÜÊNCIA DO TREINAMENTO.......................................40
Figura 4 – TELA INICIAL DO PROTÓTIPO........................................................................52
Figura 5 – MENU “INICIAR EXERCICIOS” DESABILITADO .........................................53
Figura 6 – MENU “OPÇÕES”................................................................................................53
Figura 7 – MENU “OPÇÕES DE TREINAMENTO”............................................................54
Figura 8 – MENU “OPÇÔES DE TREINAMENTO” PREENCHIDO .................................54
Figura 9 – MENU “INICIAR EXERCICIOS” HABILITADO..............................................55
Figura 10 – QUESTÃO SOBRE INTERVALOS...................................................................55
Figura 11 – QUESTÃO SOBRE ESCALAS ..........................................................................56
Figura 12 – QUESTÃO SOBRE ACORDES .........................................................................56
Figura 13 – MENSAGEM DE GERAÇÂO DE HISTÓRICO ...............................................57
Figura 14 – DIRETÓRIO DO PROTÓTIPO ..........................................................................58
Figura 15 – MODELO DE HISTÓRICO................................................................................58
vii
LISTA DE QUADROS Quadro 1 – HINO A SÃO JOÃO BATISTA............................................................................7
Quadro 2 – AS SETE NOTAS DA NOTAÇÃO MUSICAL ...................................................8
Quadro 3 – NOTAÇÃO DOS MONOSSÍLABOS ...................................................................8
Quadro 4 – ESCALA TEMPERADA OCIDENTAL...............................................................9
Quadro 5 – RELAÇÃO DE NOTAS E INTEIROS................................................................13
Quadro 6 – AS 12 CLASSES DE ALTURAS........................................................................15
Quadro 7 – MENORES EQUIVALENTES NÃO NEGATIVOS MOD 12...........................17
Quadro 8 – ALGUNS INTERVALOS E SEUS RESPECTIVOS DESLOCAMENTOS......17
Quadro 9 – COMPLEMENTARES MOD 12.........................................................................18
Quadro 10 – MENOR COMPLEMENTAR MOD 12............................................................18
Quadro 11 – VOICE MESSAGES..........................................................................................29
Quadro 12 – MENSAGENS MIDI .........................................................................................31
Quadro 13 – MÉTODO CREATE DO FORMULÁRIO .......................................................41
Quadro 14 – MÉTODO INICIATREINAMENTO .................................................................43
Quadro 15 – ESCALA MAIOR IÔNICA COM TÔNICA EM C# ........................................46
Quadro 16 – MÉTODO SORTEIASEQUENCIA.................................................................47
Quadro 17 – MÉTODO BUSCASEQUENCIANOTAS.......................................................47
Quadro 18 – MÉTODO MONTATESTE ..............................................................................48
Quadro 19 – MÉTODO SORTEIANOTA .............................................................................50
Quadro 20 – MÉTODO GETINFNOTA ................................................................................50
Quadro 21 – MÉTODO GERAHISTORICO ........................................................................50
Quadro 22 – PATCHES GENERAL MIDI ............................................................................62
Quadro 23 – PERCUSSÃO GENERAL MIDI.......................................................................63
viii
Quadro 24 – MÉTODO EXECUTAQUESTAO ...................................................................64
ix
RESUMO
Este trabalho tem por finalidade o desenvolvimento e a construção de um protótipo de
sistema capaz de gerar exercícios interativos para o treinamento da percepção musical.
Primeiramente, é apresentado um estudo sobre a teoria musical e seus conceitos, em particular
o modelo de inteiros para classes de alturas musicais, além do estudo da tecnologia MIDI. Em
seguida, é apresentado o desenvolvimento de um protótipo, em forma de um estudo de caso,
com sua especificação contendo o diagrama de classes, bem como o código fonte dos
principais métodos implementados em ambiente de programação Delphi 5.0. O protótipo
baseia-se apenas na parametrização das regras da teoria musical, aplicada à tecnologia MIDI
para geração aleatória de exercícios de intervalos, escalas e acordes.
x
ABSTRACT
This work has the purpose of developing and building a system prototype capable of
generating interactive exercises for musical perception training. At first, a study about musical
theory and its concepts is showed, particularly the integer model for musical pitch classes,
besides the MIDI technology study. Following, a prototype developing is showed, shaped as a
case study, with its specification containing the class diagram, as well as the source code
from the main methods implemented in the programming environment Delphi 5.0. The
prototype is based only on the parameterizing of musical theory rules, applied to MIDI
technology for random generation of intervals, scales and chords exercises.
xi
1
1 INTRODUÇÃO A música é uma arte difundida entre todas as gerações e culturas, e existe desde os
primórdios da existência humana. Segundo Ribeiro (1965), música é a arte de combinar sons
de modo a produzirem sensações agradáveis ao ouvido e despertarem na alma emoções
especiais. Conforme o homem evolui, a música evolui juntamente, mas certos fundamentos,
permanecem inalterados, pois são deles que se derivam todos os conceitos musicais básicos,
tais como notas, intervalos, acordes e melodias.
Como nas outras artes, a música vem sendo difundida e passada adiante as novas
gerações através de professores, que ensinam a teoria musical, e a técnica necessária para se
aprender a tocar determinado instrumento.
Para que um músico tenha total domínio sobre seu instrumento, ele precisa dominar,
tanto a teoria, quanto a prática, e isso inclui um ouvido bem treinado, a habilidade de
distinguir diferentes combinações de notas musicais pode ser chamada tecnicamente de
percepção musical. Sem uma boa percepção musical dificilmente chegar-se-á a uma boa
proficiência em qualquer instrumento musical.
E como esses sons podem ser reproduzidos para que se aprenda uma música através da
percepção musical? Pode-se ouvir um outro músico executando esta melodia, ouvi-la em uma
gravação, ou até mesmo com o advento da computação, utilizando-se a ferramenta certa,
pode-se gerar esses sons automaticamente através de uma programação prévia da teoria
musical. Com o atual aparato técnico disponível, é possível o desenvolvimento de softwares
para gerar sons alternados, percorrendo toda a escala de notas, e todos os seus intervalos,
fazendo com que o treinamento da percepção musical não tenha mais que se limitar às aulas
práticas com um professor.
Utilizando-se a tecnologia MIDI, pode-se desenvolver esse tipo de sistema. Segundo
Vaughan (1994), Musical Instrument Digital Interface (MIDI) é um padrão da indústria
desenvolvido no início da década de 1980 que permite que os sintetizadores de música e som
de diferentes fabricantes se comuniquem entre si enviando mensagens via cabos conectados
nos dispositivos. Dentro da MIDI há também um protocolo para passar descrições detalhadas
de uma partitura musical, tais como notas, as seqüências de notas e qual instrumento as
2
tocará. Uma mensagem concisa da MIDI pode provocar um som ou uma seqüência de sons
complexa para ser tocada em um instrumento ou sintetizador.
Esta proposta de trabalho de conclusão de curso prevê o desenvolvimento de um
sistema para treinamento de percepção musical. O sistema em questão será desenvolvido em
forma de um jogo, utilizando uma interface gráfica onde o usuário escolhe o nível de
dificuldade, e as opções a serem treinadas (escala, acorde, intervalo, etc.), o sistema então
deverá gerar uma seqüência de sons para que o usuário tente decifrar. A cada som gerado são
contabilizados os acertos e erros, para que, ao final do “jogo”, o usuário possa medir seu
desempenho através da pontuação alcançada. O sistema também deverá guardar um histórico
de cada usuário através do armazenamento de scores percentuais, para verificação da
evolução dos usuários ao longo da realização de mais seções práticas.
1.1 OBJETIVOS Este trabalho tem como objetivo desenvolver uma ferramenta para auxiliar músicos no
treinamento e desenvolvimento na percepção musical.
Os objetivos específicos do trabalho são:
a) a criação de um sistema que utilize arquivos MIDI para gerar sons que serão ouvidos e decifrados pelo músico;
b) geração de baterias de testes de reconhecimento de escalas, acordes e intervalos, como progressões harmônicas e/ou melódicas;
c) criação de um histórico do desempenho de cada usuário.
3
1.2 ORGANIZAÇÃO DO TEXTO O presente trabalho está organizado em 5 (cinco) capítulos, sendo que o primeiro
compreende a introdução ao trabalho, com breve descrição do seu contexto, seus objetivos e
sua organização.
O segundo capítulo trata da fundamentação teórica relativa à música, abrangendo
desde conceituação e harmonia, além da fundamentação do modelo inteiro de alturas relativo
a teoria da música atonal.
No terceiro capítulo é abordada a fundamentação teórica sobre MIDI (Musical
Instrument Digital Interface), compreendendo conceituação, formato e especificação.
No quarto capítulo, é apresentada a fundamentação teórica relativa aos métodos
desenvolvidos e técnicas aplicadas no protótipo, especificação, implementação,
funcionamento e apresentação do protótipo desenvolvido.
Por fim, no quinto capítulo, apresenta-se as conclusões e sugestões para futuros
trabalhos.
4
2 TEORIA MUSICAL
2.1 ORIGEM HISTÓRICA Conforme Plate (2000), as primeiras manifestações musicais não deixaram vestígios.
Alguns estudiosos elaboram hipóteses com base naquilo que se sabe sobre a vida humana na
pré-história, e preenchem as lacunas com uma boa dose de imaginação. Mas nenhuma
hipótese diz com exatidão o momento em que os primitivos começaram a fazer arte com os
sons produzidos.
Tudo indica que o homem das cavernas dava à sua música um sentido religioso, ele
considerava-a um presente dos deuses e atribuía-lhe funções mágicas. Associada à dança, ela
assumia um caráter de ritual, pelo qual as tribos reverenciavam o desconhecido, agradecendo-
lhe a abundância da caça, a fertilidade da terra e dos homens. A natureza fascinava os homens
desse tempo, e inspirava-os a imitar os sons por ela produzidos. Mas, para isto, o ritmo não
bastava, e o artesanato ainda não permitia a invenção de instrumentos melódicos.
Contudo, segundo os atuais conceitos de música, essas tentativas de expressão foram
demasiadamente pobres para se enquadrarem na categoria de arte musical. Mas, do ponto de
vista histórico, elas tiveram uma importância enorme, porque a sua rítmica elementar
acompanhou o homem à medida que este se espalhava sobre a Terra, formando culturas e
civilizações, e evoluiu com ele, refletindo todas as transformações que a humanidade viveu
até os dias de hoje.
A noção que hoje se tem da música como “uma organização temporal de sons e
silêncios” não é nova. Civilizações muito antigas já se aproximaram dela, descobrindo os
elementos musicais e ordenando-os de maneira sistematizada. Por muito tempo as formas
instrumentais permaneceram subdesenvolvidas e predominava a música vocal. Essa forma,
adicionando à música o reforço das palavras, era mais comunicativa e as pessoas
assimilavam-na melhor. Assim se explica o grande desenvolvimento que atingiu entre os
antigos.
Ainda segundo Plate (2000), os povos de origem semita cultivavam a expressão
musical, tornando-a bastante elaborada. Os que habitavam a Arábia, principalmente,
5
distinguiram-se pela criatividade. Possuíam uma ampla variedade de instrumentos e
dominavam diferentes escalas1.
Na China, o peculiar era a própria música, devido à sua monumentalidade. Os chineses
utilizavam nada menos que 84 escalas (o sistema tradicional da música ocidental dispunha de
apenas 24). A variedade da sua instrumentação era imensa. E já por volta do ano 2255 a.C. o
domínio sobre a expressão musical atingia tal perfeição entre eles, que sua influência se
estendia por todo o Oriente, moldando a música do Japão, da Birmânia, da Tailândia e de
Java.
Mas indiscutivelmente, foram os gregos que estabeleceram as bases para a cultura
musical do Ocidente. A própria palavra música nasceu na Grécia, oriunda de “Mousikê” que
significa “a arte das musas”, abrangendo também a poesia e a dança. O ritmo2 era o
denominador comum das três artes, fundindo-as numa só. Como os demais povos antigos os
gregos atribuíam aos deuses sua música, definindo-a como uma criação integral do espírito,
um meio de alcançar a perfeição.
Seu sistema musical apoiava-se numa escala elementar de quatro sons - o Tetracorde.
Unindo-se dois tetracordes formavam-se escalas de oito notas, e estas já possuíam uma
complexidade sonora que permitia esboçar linhas melódicas. Estas escalas mais amplas - os
Modos - tornaram o sistema musical grego conhecido posteriormente como Modal.
O canto prendia-se a uma melodia3 simples, a monodia, pois os músicos da Grécia
ignoravam as combinações simultâneas de sons (harmonias). Mas nem por isso deixavam de
caracterizar com seus modos um sentido moral, tornando os ritmos sensuais, religiosos,
guerreiros, e assim por diante.
1 É uma série de sons ascendentes ou descendentes na qual o último será a repetição do primeiro uma oitava
acima ou abaixo.
2 É a duração e acentuação dos sons e das pausas.
3 É uma sucessão de sons musicais combinados.
6
A música da Grécia evoluiu assim, para a lírica solista, o canto conjunto e o solo
instrumental. Depois, vieram as grandes tragédias inteiramente cantadas, que marcaram o
apogeu da civilização helênica (do século VI ao século IV a.C.).
2.2 OS PRIMEIROS PASSOS DA MELODIA Conforme Plate (2000), com o cristianismo, o homem viu dentro de si, um mundo que
desconhecia, e essa revelação transformou a sua visão de si mesmo, assim como a sua posição
perante às coisas. Os novos hinos e cânticos da nova concepção musical eram inspirados em
salmos da bíblia.
Aos poucos, artistas profissionalizaram-se e aperfeiçoaram o canto das melodias. Os
grandes centros da igreja cristã (Bizâncio, Roma, Antioquia e Jerusalém) eram também os
grandes centros musicais, cada qual com sua liturgia musical particular.
E foi em Roma que se estabeleceram os padrões que deram ao canto litúrgico da Igreja
Romana uma forma fixa. O organizador foi o fundador da Schola Cantorum, Papa Gregório
Magno (donde provém o nome “Canto Gregoriano”) e este gênero caracterizava-se por uma
melodia linear e plana.
2.3 A ORIGEM DA MÚSICA COMO CONHECEMOS Ao longo dos séculos e sob a influência de novas maneiras de cantar, o Gregoriano se
modificou, mas conservando o seu caráter monódico. No século XIII, certos contracantos
desconhecidos começaram a fazer parte da melodia tradicional, subvertendo a liturgia que
fixava os tons da Igreja. E assim os religiosos viram, a contragosto, que sua música também
começava a denotar traços da criação musical erudita que se desenvolvia entre aldeões.
Livre da rigidez litúrgica, esta música impura fugia da monofonia, e reunia várias
melodias no mesmo canto, dando origem a polifonia. E o povo, ajudado pelos trovadores,
acabaria impondo sua fusão com o canto tradicional.
Segundo Plate (2000), a primeira notação que apareceu baseava-se no alfabeto: as sete
primeiras letras representavam os sete sons da escala, começando pela nota lá. Depois,
7
criaram-se os neumas, sinais oriundos dos acentos grave, agudo, circunflexo, e do ponto.
Porém, a notação neumática tinha o defeito de não indicar a altura nem a duração dos sons.
Melhor que ela, era o método do monge Guido d'Arezzo (995-1050), que adotou uma pauta
de quatro linhas e definiu as claves de Fá e Dó para registrar a altura dos sons. Além disso,
d'Arezzo deu nome às notas, tirando as sílabas iniciais de um hino a São João Batista.
O quadro 1 mostra o hino com a primeira sílaba dos versos destacadas:
Quadro 1 – HINO A SÃO JOÃO BATISTA
Ut quéant láxis Para que possam
Resonáre fíbris ressoar as maravilhas
MÍra gestórum de teus feitos
FÁmuli tuórum com largos cantos
SÓLve pollúti apaga os erros
LÁbii reátum dos lábios manchados
Sáncte Ioánnes. Ó São João.
Fonte: Plate (2000)
Segundo Ribeiro (1965), a nota SI, obteve-se unindo a primeira letra de Sancte(S) com
a primeira de Ioannes(I), isso ocorreu no século X. João Batista Doni, maestro italiano, por
volta de 1640, achou que a primeira sílaba de seu sobrenome, Doni, seria bem mais sonora do
que UT, e passou a ensinar a escala musical como se conhece hoje em dia. O Mensuralismo,
inventado por Walter Oddington e Franco de Colônia no século XII, também ajudou a evoluir
a técnica musical. Era um sistema que permitia medir o tempo sonoro, determinando uma
duração específica para cada nota (breve, semibreve, mínima, semínima, colcheia,
semicolcheia, fusa, semifusa, quartifusa).
2.4 TEORIA DA MÚSICA Conforme Chediak (1986), Música é a arte dos sons, constituída de melodia, ritmo e
harmonia. A melodia é a sucessão de sons musicais combinados, o ritmo é a duração e a
8
acentuação dos sons e das pausas enquanto que a harmonia é a combinação dos sons
simultâneos.
O som, pode ser definido como o efeito audível que os movimentos de corpos
vibratórios produzem. Para se produzir o som, é necessário uma fonte sonora, que podem ser
cordas (violão, violino, contra-baixo, piano, etc.), colunas de ar (flauta, trompete, pistão,
saxofone, etc.) e membranas (tamborim, cuíca, bumbo, etc.).
A vibração produzida, tem diferentes características que definem as propriedades
físicas do som, que são altura, intensidade e timbre. A altura é a propriedade do som de ser,
grave, médio ou agudo. A intensidade é a propriedade do som ser fraco, moderado ou forte, e
é caracterizado pela amplitude da vibração do corpo vibratório. O timbre nada mais é do que a
qualidade do som, é através dele que diferencia-se e reconhece-se o instrumento que produz o
som.
Embora sejam inúmeros os sons empregados na música, para representar-se a notação
musical, pode-se utilizar apenas sete notas naturais. O quadro 2 apresenta as sete notas:
Quadro 2 – AS SETE NOTAS DA NOTAÇÃO MUSICAL
Dó Ré Mi Fá Sol Lá Si
Esta notação é utilizada no Brasil, mas existe uma notação, utilizada na Alemanha,
Inglaterra, Estados Unidos e alguns outros países do mundo, que é a dos monossílabos,
partindo-se do Dó. O quadro 3 mostra esta notação:
Quadro 3 – NOTAÇÃO DOS MONOSSÍLABOS
C D E F G A B
Esta será a notação utilizada para representar as notas deste momento em diante.
Pode-se alterar estas notas de forma ascendente ou descendente, fazendo com que estas
tomem assim, o lugar de uma de suas notas adjacentes. Utiliza-se para representar estas notas
adjacentes os símbolos # (sustenido) e o b(bemol). Desta forma, tem-se as doze notas
musicais existentes, sete delas naturais e cinco alteradas. Nota-se que todas as sete notas
podem ser alteradas, mas duas delas, o E# e o B# possuem os mesmos sons de F e C
9
respectivamente. Chega-se assim as doze notas musicais existentes, que compõem a escala
temperada ocidental, como mostra o quadro 4 abaixo:
Quadro 4 – ESCALA TEMPERADA OCIDENTAL
C C# D D# E F F# G G# A A# B
2.4.1 INTERVALOS Segundo Chediak (1986), intervalo é a distância (diferença de altura) entre dois tons.
Podem ser maiores, menores, justos, aumentados e diminutos. A classificação dos intervalos é
feita entre a tônica (primeira nota, da escala, ou grau I) e os demais graus da escala.
Os intervalos podem ser definidos como sete : 2a (segunda), 3a (terça), 4a (quarta), 5a
(quinta), 6a (sexta), 7a (sétima) e 8a (oitava). Os intervalos da escala maior são todos maiores,
menos a 4a, a 5a e a 8a, denominadas justas.
Segundo Ribeiro (1965), os intervalos maiores elevados de meio tom tornam-se
aumentados. Os intervalos maiores abaixados de meio tom tornam-se menores; abaixados de
mais um semitom se tornam diminutos. Os intervalos justos (4a, 5a e 8a) não podem ser
maiores ou menores; se forem elevados de meio tom ficam aumentados; se forem abaixados
de meio tom tornam-se diminutos.
Ainda segundo Ribeiro (1965), inverte-se um intervalo transportando o som grave à
oitava superior, ou som agudo, à oitava inferior, o que é chamado de inversão dos intervalos.
Pela inversão, o intervalo diminuto se torna aumentado, o menor torna-se maior e vice-
versa. Os intervalos justos conservam a denominação de justos em suas inversões.
Conforme a direção em que seguem, os sons podem ser chamados de ascendentes,
quando vão da parte grave para a aguda, ou de descendentes, quando seguem da parte aguda
para a grave.
10
2.4.2 ESCALAS As escalas dos modos são as escalas mais tradicionais da música ocidental. Os modos
são caracterizados de acordo com o intervalo de tons e semitons entre os graus. Os modos
maiores são aqueles que possuem o intervalo de 3ª em relação a tônica sempre maior,
enquanto que para os modos menores o intervalo de 3ª em relação a tônica será sempre
menor. Os modos Iônico, Lídio e Mixolídio são maiores, enquanto que os modos Dórico,
Frígio, Eólio e Lócrio são menores.
2.4.3 ACORDES Segundo Chediak (1986), o acorde pode ser formado por três, quatro ou mais sons.
Quando formado por três sons é chamado de tríade, por quatro sons de tétrade e por mais de
quatro sons, de tétrade com nota acrescentada.
As tríades são formadas pela reprodução de três notas separadas por intervalo de
3ª superpostas, podendo ser maior, menor, diminuta e aumentada. A tríade maior é formada
por exemplo pela tônica, e pelos intervalos de 3ª maior e 5ª justa, nota-se que entre os sons
existe um intervalo de 3ª e que o primeiro intervalo é de 3ª maior, o que dá nome ao acorde, e
o segundo intervalo, relação entre a 3ª maior e a 5ª justa, é uma 3ª menor. A tríade menor
possui as mesmas características, com a exceção de que o primeiro intervalo é caracterizado
como 3ª menor e somente o segundo como 3ª maior, ou seja, a tríade menor é formada pela
tônica, 3ª menor e 5ª justa.
As tríades diminuta e aumentada também possuem entre seus intervalos uma relação
de 3ª superpostas, com a diferença que a tríade diminuta possui entre seus intervalos uma
relação de 3ª menor enquanto que a tríade aumentada a relação entre os intervalos é de 3ª
maior. Ou seja, a tríade diminuta é formada pela tônica, 3ª menor e 5ª diminuta ao passo que a
tríade aumentada é formada pela tônica, 3ª maior e 5ª aumentada.
As tétrades, seguem o mesmo raciocínio, mas ao invés de possuírem somente três
notas, possuem quatro ou mais (tétrade com nota acrescentada). Tem-se por exemplo a tétrade
maior com 7ª maior, que é composta pelos intervalos de tônica, 3ª maior, 5ª justa e 7ª maior,
11
ou outro exemplo pode ser também o da tétrade maior com 7ª menor, semelhante a primeira,
mas com o intervalo de 7ª com uma relação de 3ª menor.
As tétrades podem ter notas acrescentadas de inúmeras formas, uma delas seria a
inclusão do intervalo de 9ª maior na tétrade maior com 7ª maior, o que resultaria de um
acorde formado por tônica, 3ª maior, 5ª justa, 7ª maior e 9ª maior (equivalente a 2ª maior mas
uma oitava acima), lembrando sempre que uma tétrade deve manter a relação de 3ª
superpostas também, apesar de uma nota acrescentada não precisar seguir essa regra.
Estes acordes podem ser reproduzidos de forma melódica ou harmônica. A reprodução
melódica é a reprodução de um acorde de forma arpegiada, ou seja, nota após nota, iniciando
da tônica até seu último intervalo. A reprodução harmônica é caracterizada pelo toque dos
intervalos pertencentes ao acorde simultaneamente, de forma a soarem juntos, como um som
só.
Um acorde pode ter a sua formação invertida, passando um de seus intervalos para o
baixo (nota mais grave). Quando isto acontece este acorde é chamado de acorde invertido.
Para uma tétrade por exemplo, quando toca-se a 3ª no baixo, essa inversão é chamada de 1ª
inversão, se toca-se a 5ª no baixo, é chamada de 2ª inversão, e caso a 7ª esteja no baixo, o
acorde caracteriza-se como estando na 3ª inversão.
2.5 O MODELO INTEIRO DE ALTURAS Para representar-se todas as notas de um piano com oito oitavas, sabendo-se que as
notas se repetem a cada oitava e as alturas das notas vão descendendo a medida que as notas
são tocadas da direita para a esquerda (agudo para grave), pode-se representá-las de uma
forma compacta, o que permitiria a criação de técnicas e processos mais abrangentes e
eficazes para atender-se aos objetivos deste trabalho. O modelo inteiro de alturas, é um
modelo que aplica conceitos matemáticos para classificar e agrupar as notas existentes de
maneira a levar a este objetivo.
12
2.5.1 TERMOS E HIPÓTESES A teoria tônica é tão comum hoje em dia que muitos dos seus conceitos são
construídos dentro da terminologia musical básica. Chamar-se uma altura particular de C# é
aceitar ao menos duas teorias sobre a estrutura das alturas. A primeira e a teoria da
equivalência de classe de altura: todas as alturas chamadas de C#, em qualquer oitava tem o
bastante em comum, analisando-se do ponto de vista da estrutura musical, que torna-se
possível denominar todas elas de C#. A segunda teoria é chamada de funcionalidade ditônica,
um C# não funciona (por exemplo) como o quarto grau de um Ab (bemol4) maior, enquanto
que um Db funciona, apesar de um C# e um Db (que são equivalentes) serem produzidos
tocando-se a mesma nota em um piano.
A teoria da música atonal pode manter a equivalência de classe de altura mas não
pode englobar a funcionalidade ditônica por esta ser particularmente tonal, por este motivo
torna-se importante ter-se uma maneira de montar a notação de alturas sem incorporá-la.
Por décadas estudiosos tem resolvido este problema utilizando os números inteiros
para expressar a notação da altura. Mas os números inteiros tem certas particularidades que
devem ser examinadas. Os inteiros tem uma estrutura diferente da utilizada na teoria tônica
com as letras, pegando-se um par qualquer de inteiros, um sempre será maior do que o outro.
Os inteiros também são igualmente separados, pode-se montar um vetor qualquer de números
inteiros sequênciais, de maneira que um número seja maior que seu subsequente e menor que
seu próximo em exatamente uma unidade. Mas, deve-se cuidadosamente limitar um universo
de números inteiros para não se cair em sua infinidade.
Sendo assim, pode-se associar os números inteiros com as alturas visto que estas
também são ordenadas e igualmente espaçadas.
4 Bemol (b) – abaixa o som em um semitom,. só é utilizado para as notas sustenidas, ou seja, um C# é
equivalente a um Db, um A# a um Bb, etc.
13
2.5.2 ALTURAS E SEUS INTERVALOS Um ouvido treinado pode dizer facilmente qual de duas alturas e maior do que a outra.
Esta relação de maior que pode ser igualmente relacionada aos números inteiros. As alturas
também são igualmente espaçadas no tradicional sistema de 12 alturas por oitava, ou seja, o
intervalo entre duas notas adjacentes é exatamente igual. Isso permite relacionar-se a mínima
diferença entre os inteiros (uma unidade) com a mínima diferença entre as altura (um
semitom). O resultado é uma perfeita relação entre cadeias de inteiros e cadeias de alturas
(escala cromática). Pode-se agora numerar as notas de um piano partindo do número 0 até o
88. Apesar de nenhuma altura merecer ser relacionada ao número 0, o zero pode ser
relacionado ao C4, o C central do piano, pois assim define-se um vetor que parte do –44 e
ascende ao 44. O quadro 5 mostra a relação das alturas com os inteiros conforme descrito.
Quadro 5 – RELAÇÃO DE NOTAS E INTEIROS
... F3 F#3 G3 G#3 A3 A#3 B3 C4 C#4 D4 D#4 E4 F4 F#4 G4 ...
... -7 -6 -5 -4 -3 -2 -1 0 1 2 3 4 5 6 7 ...
O número de semitons entre duas alturas pode ser obtido subtraindo-se o nome de uma
do nome da outra, o que leva a seguinte definição de intervalos ordenados por altura:
Definição: Para quaisquer duas alturas x e y, o intervalo ordenado entre x e y é igual a
y menos x.
IA<x,y> será a denotação para expressar o intervalo ordenado entre as alturas x e y, e x
e y são ordenados de forma crescente, portanto:
IA<x,y> = y – x
Note que esta notação distingue intervalos crescentes e decrescentes. Por exemplo:
C4 para E4 = A<0,4> = 4 – 0 = 4
E4 para C4 = A<4,0> = 0 – 4 = -4
14
Resultados positivos significam que trata-se de um intervalo ascendente enquanto que
os negativos são descendentes. Mas é importante definir-se essa medida de distância,
independente da direção tomada. Por exemplo, existem quatro semitons entre C4 e E4 ou
entre E4 e C4, ascendendo ou descendendo. Este tipo de controle é bastante útil quando se
está lidando com conjuntos (coleções desordenadas) de alturas.
Definição: Para quaisquer duas alturas x e y, o intervalo desordenado entre x e y e
igual ao valor absoluto de y menos x.
Como é sabido, valor absoluto quer dizer que se esta diferença for negativa, será
transformada em positiva.
IA(x,y) = |y - x|
O resultado do cálculo é o mesmo que seria obtido através de um cálculo feito para um
par ordenado, com a exceção de que os valores negativos tornam-se positivos. Por exemplo:
IA(15,4) = |4 - 15| = |-11| = 11
IA(-8,-14) = |-14 - (-8)| = |-14 + 8| = |-6| = 6
IA(-13,-4) = |-4 - (-13)| = |-4 + 13| = |9| = 9
2.5.3 CLASSES DE ALTURAS E SEUS INTERVALOS Muito da teoria da música não trata sobre altura, mas sobre classes de altura. Uma
“classe de altura” é a equivalência de altura que todas as alturas oitavadas possuem. Para ter--
se uma maior precisão deste conceito, utiliza-se o modelo inteiro de altura.
Definição: Duas alturas x e y são da mesma classe de equivalência de altura se e
somente se por algum inteiro n, x = 12.n + y, ou equivalente (para algum inteiro não negativo
n) IA(x,y) = 12.n.
Por exemplo:
IA(3,15) = 12
15
IA(-7, 17) = |17 – (-7)| = 17 + 7 = 24 = 2.12
IA(42,-6) = |(-6) - 42| = |-48| = 48 = 4.12
Ou seja, de acordo com os exemplos acima, as alturas 3 e 15 estão na mesma classe de
equivalência de altura, -7 e 17 estão ambas em uma classe(diferente), e as alturas 42 e –6
estão juntas mas em uma terceira classe de equivalência.
Alturas na mesma classe de altura são alguns múltiplos separados por 12 semitons, ou
seja, o intervalo de altura desordenado entre eles é 0, 12, 24, 36, etc. Pode-se então simplificar
definindo a “classe de altura” (CA) como um conjunto de todas essas alturas.
Definição: Uma classe de altura ou CA é um conjunto de todas alturas onde tomando--
se quaisquer dois membros deste conjunto x e y, IA(x,y) = 12.n (onde n é um inteiro não
negativo).
Por exemplo:
IA(-20, -8) = |(-8) – (-20)| = |-8 + 20| = |12| = 1.12
IA(-8, 16) = |16 – (-8)| = |16 + 8| = |24| = 2.12
IA(-8, 40) = |40 – (-8)| = |40 + 8| = |48| = 4.12
Portanto, conclui-se que –20, -8, 16 e 40 são quatro membros da mesma classe de
altura.
Desta maneira pode-se afirmar que existem 12 classes de altura distintas, e pode-se
nomeá-las pelo seu menor membro não negativo conforme mostrado no quadro 6 a seguir.
Quadro 6 – AS 12 CLASSES DE ALTURAS
0 = (... -36, -24, -12, 0, 12, 24, 36, 48 ...) 1 = (... -35, -23, -11, 1, 13, 25, 37, 49 ...) 2 = (... -34, -22, -10, 2, 14, 26, 38, 50 ...) 3 = (... -33, -21, -9, 3, 15, 27, 39, 51 ...) ... ... ... ... ... ... ... ... ... ... ... 10 = (... -26, -14, -2, 10, 22, 34, 46, 58 ...) 11 = (... -25, -13, -1, 11, 23, 35, 47, 59 ...)
16
Matemáticos já desenvolveram um sistema aritmético de módulo que se encaixa neste
caso, módulo (mod) 12. A definição matemática de módulo é a seguinte: dois inteiros x e y
são “equivalentes mod 12” se e somente se x = 12.n + y para qualquer inteiro n. Esta foi
exatamente a fórmula encontrada nas definições prévias de classes de intervalo. As classes de
altura mostradas na tabela de 12 classes de altura acima são na matemática as “classes
resultado mod 12” dos números inteiros.
Retomando-se a convenção onde o C central do piano é a altura 0, a classe de altura 0
conterá todas as alturas C´s em qualquer oitava, a classe de altura 1 conterá todos os C#´s (ou
Db´s), a classe de altura 2 conterá todos os D´s e assim por diante.
Algumas vezes quando se trabalha com uma música em particular, a altura 0 poderia
ser aplicada a outra classe de altura ao invés do C, no entanto, a altura 0 uma vez estabelecida,
não deve ser movida, pois sua mudança acarretaria na destruição de relacionamentos
importantes.
2.5.4 INTERVALO DE CLASSE DE ALTURA ORDENADO O intervalo ordenado entre duas classes de altura deve seguir o mesmo conceito de um
primeiro intervalo de classe estar abaixo de um segundo, ou seja, uma sequência crescente ou
decrescente. Tomando-se duas classes de altura, uma das duas terá uma altura que é maior do
que qualquer altura da outra classe. Por exemplo, pegando-se um C, algum C# será maior.
Para um C#, algum C será maior (por pelo menos 11 semitons). Por conveniência, relaciona-
se maior com tendo um maior inteiro relacionado, portanto a classe de altura 1 é maior do
que a 0, a 5 é maior que a 1 e assim por diante. Apesar deste detalhe, a definição de intervalo
de classe de altura ordenado pode ser similar a definição de intervalo de altura ordenada.
Definição: I<x,y> = y – x, para quaisquer duas classes de altura x e y, o intervalo de
classe de altura ordenado entre x e y é igual a y – x mod 12.
Esta definição e todas definições a seguir sobre classes de altura assumem que, todos
os números são convertidos para seus menores equivalentes não negativos, mod 12. Por
exemplo, i<5,1> = 1 – 5 = (-4) = 8, mas i<1,5> = 5 – 1 = 4. Se estiver lidando-se com
números negativos, é importante lembrar que 0 = 12 = 24 = 36 = ... sendo assim, -4 = 0 – 4 =
17
12 – 4 = 8; -13 = 0 – 13 = 24 – 13 = 11. Para calcular-se intervalos, o quadro 7 a seguir é bem
prático:
Quadro 7 – MENORES EQUIVALENTES NÃO NEGATIVOS MOD 12
-1 -2 -3 -4 -5 -6 -7 -8 -9 -10 -11 11 10 9 8 7 6 5 4 3 2 1
Assumindo que C = 0, tem-se alguns exemplos mais:
C para B = i<C,B> = i<0,11> = 11 – 0 = 11
B para C = i<B,C> = i<11,0> = 0 – 11 = -11 = 1
E para G# = i<E,G#> = i<4,8> = 2 – 10 = -8 = 4
F# para D# = i<F#,D#> = i<6,3> = 3 – 6 = -3 = 9
O quadro 8 abaixo ilustra os principais intervalos de notas musicais, e os respectivos
valores de deslocamentos:
Quadro 8 – ALGUNS INTERVALOS E SEUS RESPECTIVOS DESLOCAMENTOS
Segunda menor Segunda maior Terceira menor Terceira maior
Quarta justa Tritom
Quinta justa Sexta menor Sexta maior
Sétima menor Sétima maior
Oitava ...
1 2 3 4 5 6 7 8 9 10 11 12 ...
2.5.5 INTERVALO DE CLASSE DE ALTURA DESORDENADO; CONJUNTOS
Assim como é útil simplificar a música em alturas (desconsiderando timbre, dinâmicas,
etc.) e simplificar as alturas em classes de altura (desconsiderando distinção de oitavas),
18
também é útil simplificar sucessões ordenadas de classes de altura em conjuntos
(desconsiderando que altura veio antes).
A classe de altura em um conjunto não é ordenada. Não é possível determinar se num
conjunto com classe de altura {0,7} o 0 virá primeiro ou o 7 virá. Os dois intervalos
ordenados possíveis são <0,7> = 7 e <7,0> = 5. A definição de intervalo de classe de altura
desordenado ou i(x,y) é necessária para não tornar o intervalo entre classes de altura em um
conjunto ambivalente.
Definição: i(x,y) = ao menor resultado entre i<x,y> e i<y,x>
Por convenção, toma-se o menor valor possível da classe de altura ordenada como
sendo o resultado da classe de altura desordenada. Nota-se que, para intervalos de classe de
altura ordenados os possíveis valores vão de 0 a 11, enquanto que os intervalos de classe de
altura desordenados são 0, 1, 2, 3, 4, 5 e 6. Demonstra-se essa teoria abaixo.
Quaisquer dois números que adicionados resultem 12, ou 0 mod 12, podem ser
chamados de complementares mod 12. Note que 0 e 6 são seus próprios complementares (0 +
0 = 0 e 6 + 6 = 0). O quadro 9, mostra alguns exemplos para o melhor entendimento destes
fundamentos:
Quadro 9 – COMPLEMENTARES MOD 12
Inteiros mod 12: 0 1 2 3 4 5 6 7 8 9 10 11 Complementos de mod 12: 0 11 10 9 8 7 6 5 4 3 2 1
Sendo assim, o menor resultado entre i<x,y> e i<y,x> será sempre o menor valor de
dois complementos mod 12, como mostrado no quadro 10.
Quadro 10 – MENOR COMPLEMENTAR MOD 12
(para x <= y) 0 1 2 3 4 5 6 i(x,y) = i(y,x) i<x,y> 0 11 10 9 8 7 6 i<y,x>
Note que o intervalo complementar mod 12 é inversamente relacionado. 11 (uma
sétima maior) é relacionada através de i(x,y) a inversão de uma sétima menor, 1 (uma segunda
menor); 10 é relacionada ao 2; 9 ao 3; e assim por diante.
19
2.5.6 TRANSPOSIÇÃO Transposição e inversão, ambos serão definidos na forma de operações para um
conjunto particular, e neste caso, um mapeamento. Em outras palavras, transposição ou
inversão vão “operar” em uma estrutura para produzir outra. Como estas operações irão
mapear a primeira estrutura para a outra, entende-se que esta operação também deve ser
considerada uma relação entre a entrada e a saída destas operações.
2.5.7 TRANSPOSIÇÃO DE ALTURAS A transposição de um conjunto ou linha de alturas adiciona o mesmo número de
semitons de altura para cada altura. Transposição pode ser definida em termos da transposição
de uma altura, entendendo-se que a transposição de um conjunto ou de uma linha de alturas é
o conjunto ou linha de transposição de uma altura.
Definição: Para qualquer altura x e qualquer intervalo de altura n, Tpn (x) = x + n.
A definição pode ser lida “a transposição de altura de x por n semitons é igual a x mais
n”.
Na transposição de altura todos os intervalos são preservados. De qualquer maneira,
quaisquer duas linhas relacionadas por Tpn terão o mesmo intervalo na mesma ordem.
2.5.8 TRANSPOSIÇÃO DE CLASSE DE ALTURA Transposição de classe de altura é similar a transposição de altura:
Definição: Para qualquer classe de altura x e qualquer intervalo de classe altura n, Tn
(x) = (x + n) mod 12.
Esta definição pode ser lida “a transposição de classe de altura de x por n semitons é
igual a x mais n”. Como sempre, se tratando de classe de altura, todos os resultados devem ser
convertidos para um valor entre 0 e 11 através do mod 12.
Desde que um músico possa ouvir alturas (na sua imaginação) e geralmente pode
facilmente dedilhar uma transposição de uma linha de alturas, como parte de sua performance
20
técnica. Lembre-se, uma classe de altura não é facilmente tocada ou ouvida já que elas
consistem de todas as alturas oitavadas.
Transpor um conjunto de alturas é equivalente a transpor cada um de seus membros.
Os membros devem estar de alguma forma ordenados. Assim, realmente o que se faz é
transpor uma linha, a linha dos membros do conjunto na ordem em que eles aparecem neste
conjunto.
21
3 MIDI
3.1 UMA BREVE HISTÓRIA Segundo Vaughan (1994), Musical Instrument Digital Interface (MIDI), ou Interface
Digital para Intrumentos Musicais, é um padrão da indústria desenvolvido no início da década
de 1980 que permite que os sintetizadores de música e som de diferentes fabricantes se
comuniquem enviando mensagens via cabos conectados nos dispositivos.
Este protocolo de comunicação foi criado com a junção de duas das maiores
fabricantes de instrumentos musicais na época, a empresa americana Sequencial Circuits e a
japonesa Roland que liderava a fabricação de interfaces musicais para computadores, em
expansiva ascensão na época.
A IBM havia acabado de lançar seu primeiro computador pessoal, o IBM PC, então a
Roland planejou a criação de uma interface musical através de um sequênciador digital, que
aproveitasse a versatilidade e fácil programação do IBM PC e que pudesse ser utilizada por
toda sua nova linha de instrumentos. No projeto dessa interface proprietária, após algum
tempo e alguns protótipos a Roland finalmente chegou ao MPU-401 (Musical Processing
Unit, model 401), um circuito de hardware simples que utilizava uma “linguagem digital” que
permitia que um computador e um instrumento musical transferissem dados entre si. Esta
nova interface foi batizada de MIDI.
Neste mesmo período representantes da Roland e da Sequencial Circuits se
encontraram em uma grande feira mundial de fabricantes de instrumentos musicais e trocaram
informações de como o mercado estava exigindo um sequênciador com tecnologia capaz de
interagir com instrumentos de todos os fabricantes. Foi então que a Sequencial Circuits
analisou o projeto da Roland e fez algumas sugestões e adições na especificação da linguagem
digital. Então ambos os fabricantes começaram a adotar os padrões elaborados na fabricação
dos novos instrumentos.
A esta altura, os padrões já não eram mais proprietários, então estas duas empresas
decidiram incluir as demais fabricantes de instrumentos na padronização utilizada por eles, e
contataram as demais gigantes do mercado, dentre elas a Yamaha, Korg e a Oberheim.
22
Com os demais fabricantes de instrumentos incorporando esta tecnologia, MIDI
estourou no mercado musical, e em 1985, praticamente todos os instrumentos musicais
lançados no mercado possuíam a interface MIDI.
3.2 A TECNOLOGIA MIDI Segundo Gontijo (1998), a tecnologia MIDI permite que dispositivos eletrônicos
(usualmente sintetizadores, mas também computadores, gravadores multipista, e até mesmo
controladores de luzes para shows, videocassetes etc.) interajam e trabalhem em sincronia
com outros dispositivos compatíveis com MIDI. Usando um controlador mestre, como um
teclado, um instrumento pode reproduzir ou enviar sons para outro instrumento conectado
remotamente. Isto elimina a necessidade de um tecladista ter nove ou dez teclados à sua volta.
Ele pode reproduzir o som de todos os teclados usando um só teclado, simplesmente
conectando-os via MIDI. Os outros teclados não precisam nem estar próximos, e o músico
não precisa nem tocá-los com as próprias mãos, apesar de poder interagir com eles.
A parte visível da tecnologia MIDI é o hardware, através de conectores fêmea de 5
pinos que geralmente ficam atrás dos equipamentos, os cabos de transmissão de dados são
conectados.
Mas MIDI é muito mais do que apenas conectores em um dispositivo eletrônico. MIDI
é um protocolo de comunicação, composto de um grande conjunto de comandos musicais,
com os quais instrumentos eletrônicos controlam uns aos outros.
Da mesma forma que um modem passa bytes de dados entre um computador e seu
provedor Internet, usando um protocolo chamado TCP/IP, instrumentos eletrônicos passam
bytes de dados usando o protocolo MIDI.
Este protocolo define várias séries diferentes de bytes (de 8 bits). MIDI é, assim, um
protocolo para transferência de informações musicais, em sua maioria, e estas informações
tomam a forma de sinais eletrônicos que os instrumentos passam entre si.
Geralmente os aparelhos que possuem a tecnologia MIDI possuem dois conectores, o
MIDI IN e o MIDI OUT. Como o próprio nome já diz, o conector IN recebe os dados vindos
23
de outro dispositivo enquanto que o conector OUT os envia. Alguns dispositivos possuem um
terceiro conector MIDI chamada MIDI THRU. Este conector serve para que o dispositivo
sirva de passagem para o sinal, mas não permite que o dispositivo “ponte” altere os dados de
qualquer maneira.
Sabe-se então que MIDI é uma tecnologia que permite que dispositivos, geralmente
instrumentos musicais, troquem informações entre si. Estas informações musicais são as
nuances, ações e interpretações que um músico pode executar em um instrumento. Por
exemplo, quando um músico toca uma nota de um piano, ele “inicia o toque da nota”
pressionando a tecla, e finaliza o som soltando a tecla. É possível fazer-se isso com MIDI
através da mensagem NOTE ON, para iniciar o som, e NOTE OFF para finalizar o som.
Estas ações são ações musicais, e MIDI define, para cada ação musical, uma certa série
de bytes (chamadas de mensagens). Assim, MIDI define que para iniciar um som, utiliza-se a
mensagem NOTE ON, e para encerra-lo, a mensagem NOTE OFF.
A tecnologia MIDI possui uma mensagem para cada ação musical. Há uma mensagem
que diz a um instrumento que mova sua Roda de Modulação5(Pitch Wheel) e quanto deve
movê-la. Há outra mensagem que solicita ao instrumento para pressionar ou soltar o pedal de
sustentação6, uma terceira mensagem diz ao instrumento que deve mudar de volume e o
quanto fazê-lo, e outra que diz para o instrumento mudar seu patch7 (órgão para violão, por
exemplo), etc.
Ainda conforme Gontijo (1998), a transferência dos dados MIDI é feita de forma
serial, e esta transmissão é bastante rápida, a uma taxa de 31.250 bits por segundo, e como a
maioria das mensagens MIDI possuem 1, 2 ou 3 bytes de tamanho, as mensagens passam de
um dispositivo para o outro sem que o ouvido humano perceba qualquer atraso, e tem-se a
impressão que os instrumentos estão tocando em uníssono (a mesma coisa ao mesmo tempo).
5 Regula o efeito de vibração da nota.
6 Quando ligado, mantém as notas soando mesmo que as teclas sejam soltas, até ser desligado.
7 Conjunto de timbres (instrumentos).
24
Mas nem todos instrumentos ligados em série, precisam necessariamente tocar em
uníssono sempre, cada um pode tocar uma parte de determinada mensagem, mesmo que esta
mensagem esteja passando por todos os instrumentos.
Isso é possível graças aos canais existentes em MIDI. São 16 canais em um só cabo
MIDI. Ou seja, é possível configurar um instrumento para selecionar a quais canais ele deve
reproduzir e quais deve ignorar.
3.3 GENERAL MIDI Segundo Vaughan (1994), em setembro de 1991 a MMA (MIDI Manufacturers
Association) e a AMEI (Association of Musical Electronics Industry; antiga “JMSC”, Japan
MIDI Standards Commitee) criaram a especificação “General MIDI System Level 1”(GM).
Esta especificação foi projetada para prover um nível mínimo de compatibilidade de
desempenho entre instrumentos MIDI, o que inclusive ajudou a difundir ainda mais o MIDI,
pois até este sistema surgir, havia sempre o risco de uma composição que tinha sido feita por
fala, guitarra elétrica, baixo e piano em um dispositivo MIDI, quando fosse ser reproduzido
em outro dispositivo de outra marca, tocasse os timbres de um flautim, pandeiro, saxofone e
sistro pois os patches (conjuntos) de instrumentos eram diferentes para cada fabricante.
Em novembro de 1999, a MMA e a AMEI liberaram o chamado “General MIDI
System Level 2”, que é um grupo de extensões feitas ao GM nível 1. Evidentemente, todo
dispositivo GM2 é completamente compatível com dispositivos GM.
Para ser considerado compatível com GM, um gerador de sons (teclado, módulo de
som, placa de som, programa de computador etc.) deve atingir os requerimentos de
desempenho do GM, instantaneamente sob demanda, e sem modificações adicionais ou
configurações e ajustes feitos pelo usuário.
Conforme Gontijo (1998), os requerimentos são um mínimo de 24 vozes alocadas
dinamicamente (ou seja, polifonia mínima de 24 vozes) estão disponíveis para sons melódicos
e percussivos, ou 16 vozes alocadas dinamicamente para a melodia mais 8 para percussão,
suportar os 16 canais MIDI, cada canal podendo reproduzir um número variável de vozes
25
(polifonia), além de poder reproduzir um diferente instrumento (som/patch/timbre). A
percussão está sempre no canal MIDI número 10.
Um módulo de som GM deve ser multitimbral, ou seja, ele deve ser capaz de
reproduzir eventos MIDI em todos os 16 canais simultaneamente, com um patch GM
diferente soando em cada canal. O dispositivo deve conter também um mínimo de 16 canais
simultâneos e diferentes timbres reproduzindo vários instrumentos. Um mínimo de 128
instrumentos pré-configurados (números de programas MIDI) de acordo com o “Mapa de
pacthes de instrumentos GM” e 47 sons de percussão de acordo com o “Mapa de percussão
GM”.
Estes patches estão arranjados em 16 famílias de instrumentos, cada uma delas com 8
instrumentos. Por exemplo, há a família de instrumentos de palheta. Entre os oito
instrumentos desta família, encontram-se o saxofone, o oboé e a clarineta.
3.4 CONFIGURAÇÃO DE SONS GENERAL MIDI O recurso mais conhecido do GM é a lista de sons (patches) definidos. Entretanto, GM
não define como o som deve ser produzido, somente seu nome. Por exemplo, um módulo
pode usar um esquema barato como Síntese por FM para simular o patch de piano de cauda
acústico. Outro módulo pode usar 24 waveforms de áudio digital de várias notas de um piano,
mapeadas no alcance de notas MIDI, para criar um patch de piano.
Obviamente, os dois patches não soarão iguais, mas ao menos eles serão pianos em
ambos os módulos. Isto resulta em uma grande variedade de desempenho da mesma música
em diferentes fontes de som GM, mas os autores da especificação acharam importante
permitir a cada fabricante ter suas próprias idéias e expressar sua estética própria no que diz
respeito a escolher os timbres exatos para cada som.
3.5 CONTROLADORES MIDI Conforme Gontijo (1998), uma mensagem controladora (controller message) tem um
byte de status de B0 a BF, dependendo do canal MIDI usado. Além disto, há mais dois bytes
de dados.
26
O primeiro byte de dados é o número do controlador. Há 128 valores possíveis: 0 a
127. Alguns números foram definidos para finalidades específicas, e outros estão indefinidos,
sendo reservados para uso futuro. O segundo byte é o valor ao qual o controlador deve ser
ajustado.
A maioria dos controladores executa um determinado efeito enquanto o dispositivo
MIDI está gerando o som, e o efeito será imediatamente audível. Se o dispositivo for uma
unidade multitimbral, então cada uma de suas partes pode responder diferentemente (ou não
responder) à um número particular de controlador. Cada parte geralmente tem seu próprio
ajuste para cada número do controlador, e a parte responde somente às mensagens de um
controlador no mesmo canal atribuído àquela parte. Assim, as mensagens do controlador para
uma parte não afetam o som de outra parte, mesmo quando essa outra está tocando algo.
3.6 TIPOS DE CONTROLADORES MIDI Alguns controladores são “Controladores Contínuos”, o que significa que seu valor
pode ser ajustado a qualquer valor dentro de uma escala de 0 a 16.384 (para resoluções
grosseiras/finas de 14 bits) ou 0 a 127 (para resolução grosseira de 7 bits).
Outros controladores são meros “interruptores”, cujo estado pode estar “ligado” ou
“desligado”. Tais controladores normalmente geram um só valor: 0 para “desligado”, e 127
para “ligado”. Entretanto um dispositivo deve poder responder a qualquer valor recebido entre
0 e 127; assim, se o dispositivo implementa somente um estado ligado/desligado, ele deve
considerar valores de 0 a 63 como desligado, e valores entre 64 a 127 como ligado.
3.7 FORMATO DE ARQUIVOS MIDI Segundo Gontijo (1998), o formato MIDI padrão (Standard MIDI File, ou SMF) é um
formato de arquivos especificamente projetado para armazenar os dados que um
sequenciador8 grava e reproduz.
8 É um software ou hardware que reproduz um desempenho musical completo, com as inflexões rítmicas e
melódicas apropriadas.
27
Este formato armazena as mensagens MIDI padrão (bytes de status, com os bytes de
dados apropriados) mais um timestamp para cada mensagem (isto é, uma série de bytes que
representam quantos pulsos de relógio aguardar antes de reproduzir o evento). O formato
permite salvar informações sobre tempo, número de pulsos em resolução de semínima (ou
resolução expressa em divisões de segundo, chamada configuração SMPTE), duração e tom
da música, e nomes de trilhas e padrões. Pode armazenar múltiplos padrões e trilhas, de forma
que qualquer aplicativo pode preservar estas estruturas quando carregar o arquivo.
O formato foi projetado para ser genérico, de forma que qualquer sequenciador poderia
ler ou escrever tal arquivo, sem perder os dados mais importantes, e flexível o suficiente para
um determinado aplicativo armazenar seus dados próprios (extras) de forma que outro
aplicativo poderia carregá-lo sem problemas, e poderia ignorar com segurança esses dados
extras que não precisasse. O formato de arquivos MIDI salvam dados em blocos (grupos de
bytes precedidos por um identificador e tamanho) que podem ser analisados, carregados,
saltados etc. Assim, pode ser facilmente estendido para incluir informações proprietárias de
um programa.
Pode haver vários blocos dentro de um arquivo MIDI. Os bytes de dados em um bloco
estão relacionados de certa forma. Um bloco é simplesmente um grupo de bytes relacionados.
Ainda conforme Gontijo (1998), cada bloco começa com um identificador de 4 bytes
ASCII, que diz que “tipo” de bloco é. Os próximos 4 bytes (assumindo que um byte é igual a
8 bits), indicam o tamanho em bytes do bloco (este valor é expresso em um número de 32
bits). Todos os blocos devem começar com estes dois campos (estes 8 bytes), os quais são
referidos como cabeçalho do bloco.
Aqui tem-se um exemplo de um cabeçalho (com bytes expressados em hexadecimal):
4D 54 68 64 00 00 00 06
Note que os primeiros 4 bytes formam o identificador ASCII “MThd”, isto é, os
primeiros 4 bytes são valores ASCII para “M”, “T”, “h” e “d’’. Os próximos 4 bytes dizem
que deve haver mais 6 bytes de dados no bloco (e após isso encontrados o próximo cabeçalho
de bloco ou o fim do arquivo).
28
Na verdade, todo arquivo MIDI começa com esse cabeçalho MThd (e é assim que se
sabe que este arquivo é um arquivo MIDI).
3.8 EVENTOS Os primeiros 4 bytes em um MTrk serão os primeiros eventos de tempo de quantidade
de tamanho variável. O próximo byte de dados é atualmente o primeiro byte do evento em si,
e é chamado de Status do evento. Para eventos MIDI, este será o byte de Status MIDI atual
(ou o primeiro byte de dados MIDI em caso de running status). Por exemplo, se o byte vale 90
hexa, então este evento é um NOTE ON no canal 0 MIDI. Se por exemplo, o byte vale 23
hexa, precisa-se verificar o status do evento anterior (MIDI running status). Obviamente, o
primeiro evento MIDI em MTrk deve ter um byte de status. Após um byte de status tem-se
um ou 2 bytes de dados (dependendo do status - algumas mensagens MIDI possuem apenas
um byte de dados subsequente). Após isso você terá o tempo do próximo evento (de
quantidade variável) e o início do processo de leitura do próximo evento.
Eventos SysEx (System Exclusive), cujo status é F0, são um caso especial, porque um
evento SysEx pode ter qualquer tamanho. Após o status F0 (que é sempre armazenado, isso é,
não há running status aqui), tem-se outra série de bytes de tamanho variável. Combinando-se
com um evento SysEx teria-se um valor de 32 bits que diz mais quantos bytes seguem para
criar o evento SysEx. Este tamanho não inclui o status F0.
Algumas unidades MIDI enviam uma mensagem SysEx como uma série de pequenos
“pacotes” (com um intervalo de tempo entre as transmissões de cada pacote). O primeiro
pacote começa com um F0, mas não termina com um F7. Os pacotes subseqüentes não
iniciam com F0 nem com F7. O último pacote não inicia com um F0, mas termina com um
F7. Assim, entre o F0 inicial do primeiro pacote e o F7 final do último, há uma mensagem
SysEx. Estes eventos especiais não-MIDI são chamados de Meta-Eventos e a maioria é
opcional a não ser quando notado.
3.9 PROTOCOLO MIDI O protocolo MIDI é composto de mensagens. Uma mensagem consiste em uma string
de bytes de 8 bits. MIDI tem muitas mensagens definidas. Algumas mensagens consistem em
29
somente 1 byte. Outras mensagens tem 2 bytes. Outras tem 3 bytes. Um certo tipo de
mensagem MIDI pode ter um número ilimitado de bytes.
Um detalhe que todas as mensagens têm em comum é que o primeiro byte da
mensagem é o byte de status. Este é um byte especial, porque é o único byte que tem o bit 7
setado.
Assim, sempre que encontrar-se um byte destes, detectou-se o começo de uma
mensagem MIDI. Este será um byte de status entre 80 a FF. Os bytes restantes da mensagem
(isto é, os bytes de dados, se existirem) estarão na escala 00 a 7F.
Os bytes de status de 80 a EF são para as mensagens que podem ser transmitidas em
qualquer dos 16 canais MIDI. Por causa disto, estes são chamados Voice Messages (ou
“Mensagens de Voz”).
Para estes bytes de status, separa-se o byte de 8 bits em 2 conjuntos de 4 bits. Por
exemplo, um byte de status de valor 92 pode ser separado em 2 conjuntos, com valor de 9
(conjunto superior) e de 2 (conjunto inferior). O conjunto superior mostra que tipo de
mensagem MIDI esta mensagem representa.
O quadro 11, mostra os valores possíveis para o conjunto superior, e que tipo de
“Voice Message” cada um representa:
Quadro 11 – VOICE MESSAGES
8 = Note Off
9 = Note On
A = AfterTouch (também conhecida como “Key Pressure”)
B = Control Change
C = Program Change
D = Channel Pressure
E = Pitch Wheel
30
Assim, para o exemplo de 92, vês-se que o tipo de mensagem é NOTE ON (já que o
conjunto superior é 9). E o 2 do conjunto baixo significa que a mensagem está no canal MIDI
2. Há 16 canais (lógicos) possíveis em MIDI, sendo 0 o primeiro. Assim, esta mensagem é um
NOTE ON no canal 2.
Note que, embora o byte de status MIDI conte os 16 canais em números 0 a F (15),
todo equipamento MIDI (incluindo softwares de computador) indicam um número de canal ao
músico como 1 a 16. Assim, um byte de status emitido no canal 0 MIDI é considerado estar
no canal 1 para o músico. Esta discrepância entre o número de canal, de acordo com o byte de
status, e que canal o músico acredita ser, é aceita porque a maioria dos povos utiliza o sistema
decimal em sua rotina diária e começa a contar coisas a partir de um, e não a partir de zero.
Portanto, bytes de status de 80 a EF são para as mensagens de voz. Os bytes de status
de F0 a FF são para as mensagens que não estão em nenhum canal particular (e
consequentemente todos os dispositivos MIDI ligados em série sempre as ouvem e agem em
uma destas mensagens).
Estes bytes de status são usados para as mensagens que carregam uma informação que
interessa a todos os dispositivos MIDI, tais como sincronização de todos os dispositivos de
playback em determinado momento. Por contraste, as mensagens da categoria de voz tratam
das partes individuais da música que cada instrumento pode reproduzir, assim o esquema de
“conjunto do canal” permite que um dispositivo responda a seu próprio canal MIDI e ignore
as mensagens de categoria de voz enviadas para um outro dispositivo em um outro canal.
Estes bytes de status são divididos em duas categorias. Os bytes de status de F0 a F7
são chamados de “mensagens comuns ao sistema” (ou system common messages). Os bytes de
status de F8 a FF são chamados de “mensagens de tempo real do sistema” (ou realtime system
messages).
Determinados bytes de status dentro desta escala não são definidos pela especificação
MIDI, e são reservadas para uso futuro. Por exemplo, os bytes de status de F4, F5, e FD não
são usados. No quadro 12, há uma relação de algumas mensagens MIDI.
31
Quadro 12 – MENSAGENS MIDI
Mensagens de Voz
Note Off
Note On
AfterTouch (também conhecida como “Key Pressure”)
Control Change
Program Change
Channel Pressure
Pitch Wheel
Mensagens Comuns ao Sistema
System Exclusive
MTC Quarter Frame
Song Position Pointer
Song Select
Tune Request
Mensagens de Tempo Real do Sistema
MIDI Clock
MIDI Start
MIDI Continue
MIDI Stop
MIDI Tick
Active Sense
MIDI Reset
3.10 RUNNING STATUS Segundo Vaughan (1994), a especificação MIDI permite que uma mensagem MIDI
seja emitida sem seu byte de status (ou seja, apenas seus bytes de dados serão transmitidos),
desde que a mensagem anteriormente transmitida tenha o mesmo status. Isto é chamado de
running status.
32
O running status é simplesmente uma forma inteligente para maximizar a eficiência da
transmissão MIDI (através da remoção de bytes de status redundantes). A filosofia básica do
running status é que um dispositivo deve sempre se lembrar do último byte de status que
recebeu (com exceção de RealTime), e, se não receber um byte de status em mensagens
subsequentes, deve supor que está tratando de uma situação running status. Isto permite que o
dispositivo poupe tempo.
As mensagens da categoria de RealTime (status de F8 a FF) não efetuam running
status de forma nenhuma, por que uma mensagem de RealTime consiste em somente 1 byte, e
pode ser recebida a qualquer momento (inclusive dentro de outra mensagem), portanto deve
ser tratada de forma transparente.
As mensagens da categoria comuns ao sistema (de status F0 a F7) cancelam todo
running status. Ou seja, a mensagem após uma mensagem comum ao sistema deve começar
com um byte de status.
Sendo assim, pode-se notar que o running status é executado somente para mensagens
da categoria de voz (cujo status é 80 a EF).
3.11 SINCRONIZANDO A REPRODUÇÃO DA SEQUÊNCIA Frequentemente, é necessário sincronizar um sequenciador a algum outro dispositivo
que está controlando um playback programado, tal como um drum box (bateria eletrônica)
que reproduz seu próprios ritmos internos, de modo que ambos toquem no mesmo instante (e
o mesmo tempo musical).
Diversas mensagens MIDI são usadas para ordenar aos dispositivos que comecem a
reprodução em determinado ponto na sequência, certificar-se de que os dispositivos comecem
simultaneamente, e manter os dispositivos em sincronia, até que sejam parados
simultaneamente.
33
3.12 IGNORANDO MENSAGENS MIDI Um dispositivo deve estar preparado para ignorar todas as mensagens MIDI que não
usa, incluindo mensagens MIDI atualmente não definidas (de status F4, F5, ou FD).
Ou seja, um dispositivo trata todas as mensagens MIDI que venha a receber,
simplesmente ignorando aquelas mensagens que não são aplicáveis às suas funções.
34
4 DESENVOLVIMENTO DO PROTÓTIPO O presente trabalho resultou na criação de um protótipo de software que possibilita o
treinamento da percepção musical aplicando-se algumas da técnicas e teorias vistas.
Nesta seção será descrita a especificação utilizada para o desenvolvimento do
protótipo, bem como os requisitos e técnicas para a implementação do mesmo, além de um
exemplo de sua utilização.
4.1 REQUISITOS PRINCIPAIS DO PROBLEMA A SER TRABALHADO Este sistema tem por objetivo a utilização da teoria da música aplicada a tecnologia
MIDI para gerar exercícios para reconhecimento auditivo de intervalos musicais, escalas e
acordes. Os exercícios devem ser gerados aleatoriamente, de acordo com configuração pré-
estabelecida pelo usuário do protótipo. Para tanto é necessário um recurso computacional com
multimídia, mais precisamente recursos compatíveis com a tecnologia MIDI, para que o
usuário possa interagir com a máquina e através do ouvido (percepção musical) possa
assinalar a alternativa correta apresentada pelo sistema.
O protótipo emprega o modelo de inteiros (usado na análise de música atonal) para
representação paramétrica das informações sonoras e sua codificação no padrão MIDI.
4.2 ESPECIFICAÇÃO DO PROTÓTIPO Para a especificação do protótipo foi utilizado a UML, que é apresentado através do
diagrama de casos de uso, do diagrama de classes e do diagrama de seqüência. Estes
diagramas serão apresentados a seguir e foram construídos na ferramenta CASE Rational
Rose 4.0.
35
4.2.1 DIAGRAMA DE CASO DE USO A figura 1 mostra o diagrama de caso de uso do sistema, com as ações de entrada das
opções, inicio de treinamento e geração do histórico:
Figura 1 – DIAGRAMA DE CASO DE USO
Entrar com as opções
Músico
Iniciar treinamento
Gerar histórico
Abaixo, segue a explicação detalhada de cada evento do diagrama.
a) Entrar com as opções: aqui o usuário seleciona as opções de treinamento que deseja
efetuar, informa seu nome, a quantidade de exercícios a serem efetuados e a
quantidade de repetições do som para melhor entendimento, seleciona também o
tipo de exercício. Os tipos de exercício são: acordes, onde pode ser selecionado
também o tipo de reprodução (melódico ou harmônico) e o nível de dificuldade
(divididos em maior/menor; maior/menor/7ª; maior/menor/7ª/diminuta/aumentada);
escalas, onde pode ser treinado o reconhecimento de escalas naturais (iônico,
dórico, frígio, etc.) além das pentatônicas; e finalmente pode ser escolhida também
a opção de treinamento de intervalos (de 2ª menor a 9ª menor), que também pode
ser feito reproduzindo as notas harmonicamente ou melodicamente;
b) Iniciar treinamento: a partir deste momento o sistema gera exercícios aleatoriamente
tomando como base as opções selecionadas pelo usuário. Cada exercício gerado é
armazenado em uma instância de um objeto. Juntamente com cada exercício, o
sistema gera respostas adicionais, que representam opções de respostas incorretas
para montagem de questões de múltipla escolha. A reprodução do som pode ser
36
feita inúmeras vezes, mediante requisição do usuário, até que ele se sinta pronto
para indicar uma resposta. A duração dos sons emitidos pelo sistema pode ser
regulada através de um elemento de interface do tipo botão deslizante. Depois que o
usuário responde o exercício, o resultado (certo ou errado) é armazenado na
instância do objeto que armazena os dados do exercício. Este item se repete de
acordo com a opção de treinamento “questões”, que indica quantas questões o
sistema irá formular, para então passar para o item “c”.
c) Gerar histórico: após o término das questões é gerado um arquivo tipo texto
contendo o nome do usuário, data e hora do treinamento e lista das questões
elaboradas indicando os acertos e erros do usuário, com um percentual de acertos ao
final da relação de questões.
4.2.2 DIAGRAMA DE CLASSES No desenvolvimento do protótipo foram identificadas três classes que são o formulário
do protótipo, e as duas classes utilizadas para armazenar as informações que vão sendo
geradas conforme a utilização do mesmo.
A figura 2 apresenta o diagrama destas classes e seus principais atributos e métodos:
Figura 2 – DIAGRAMA DE CLASSE
0..NTNotas
Handle : IntegerNotaSorteada : IntegerNotaTocada : StringTesteMontado : StringCerto : Boolean
Create( )Destroy( )
1
1
TContainerNotaspRepeticoes : IntegerRepeticoes : IntegerInfNota[Index] : TNotas
GetInfNota( )SorteiaNota( )DestruirNotas( )PercentualAcertos( )Create( )Destroy( )
1
TPercMusicalFrmslNotas : TStringListslEscalas : TStringListslAcordes : TStringListslIntervalos : TStringListsOpcoes : StringListaNotas : TContainerNotas
IniciaTreinamento( )ExecutaQuestao( )SorteiaSequencia( )MontaTeste( )BuscaSequenciaNotas( )GeraHistorico( )Create( )Destroy( )
37
A classe TPercMusicalFrm, apresentada na figura 2, é responsável por controlar o
funcionamento do protótipo como um todo, por tratar-se da classe que representa o
formulário. Nesta classe, define-se as opções de treinamento, e é a partir dela que são criadas
as classes TContainerNotas e TNotas, que irão armazenar os dados de cada exercício. Esta
classe é responsável também pela geração do arquivo de histórico de cada treinamento.
Ela contém os seguintes atributos:
a) slNotas: contém as notas musicais, partindo do C até o B;
b) slEscalas: contém o nome das escalas dos modos, pentatônica e pentatônica de
blues e a relação de intervalos que as formam;
c) slAcordes: contém o nome dos acordes dos modos maior e menor, com intervalos
de sétima, aumentada e diminuta;
d) slIntervalos: contém os nomes das relações de intervalos de segunda menor a nona
menor, com a relação de deslocamento em relação a nota fundamental;
e) sOpcoes: armazena as opções de treinamento selecionadas em um string contendo o
número relativo as opções;
f) ListaNotas: nome da variável criada como TContainerNotas.
Existem ainda os métodos mais importantes da classe que são:
a) Create: operação responsável por criar a classe TPercMusicalFrm. É neste método
que os atributos do tipo TStringList são inicializados;
b) Destroy: libera o espaço em memória que a classe está utilizando, e que as listas do
tipo TStringList e do ponteiro para TContainerNotas estão utilizando;
c) IniciaTreinamento: método responsável pela inicialização do atributo sOpcoes, e
pela criação de uma instância da classe TContainerNotas apontada pelo atributo
ListaNotas. A partir deste método é chamado o método seguinte;
d) ExecutaQuestao: método que controla a geração, apresentação e contabilização das
questões geradas. Será visto mais a fundo posteriormente;
e) SorteiaSequencia: função que sorteia a sequência de alturas que representará uma
questão;
f) MontaTeste: função responsável pela colocação das alturas de forma ascendente;
g) BuscaSequenciaNotas: função responsável em buscar as alturas que formam as
38
escalas e acordes, com as notas de cada posição em relação a nota fundamental
sorteada;
h) GeraHistórico: procedimento que gera o relatório a partir das informações gravadas
na instância de TContainerNotas.
A classe TContainerNotas, apresentada na figura 2, é a que gerencia os objetos que
guardam as informações de cada questão. Ela faz as inclusões, leituras, cálculos e controles
das informações destes objetos, e nada mais é do que uma lista dos mesmos. Esta classe
possui os seguintes atributos:
a) pRepeticoes: atributo protegido que armazena o número de questões, ou seja, o
número de unidades de TNotas que haverá em cada treinamento;
b) Repeticoes: atributo que lê e escreve as informações de pRepeticoes;
c) InfNota: atributo que permite a leitura e escrita das informações em cada instância
de TNotas controladas por esta classe, através do índice de cada instância de
TNotas.
Os métodos desta classe são listados a seguir:
a) GetInfNota: procedimento privado acessado através do atributo InfNota;
b) SorteiaNota: procedimento que cria as instâncias de TNotas e sorteia a nota
fundamental;
c) DestruirNotas: procedimento que libera a memória de todas as instâncias de TNotas
e dela mesma;
d) PercentualAcertos: função que retorna o percentual de questões certas do
treinamento.
A classe TNotas, também apresentada na figura 2, contém as informações de cada
questão do treinamento. Para cada questão uma instância é criada a partir de
TContainerNotas, e as informações dos atributos são escritas e lidas conforme o
desenvolvimento do treinamento. Esta classe possui os seguintes atributos:
a) Handle: atributo que indica o índice da instância criada;
b) NotaSorteada: atributo que guarda a altura (nota) sorteada;
c) NotaTocada: atributo que guarda a sequência de notas para ser apresentado como
alternativa na questão;
39
d) TesteMontado: atributo que guarda a montagem que será reproduzida, com delay9
entre as notas ou não, e com as oitavas respectivas para respeitar a ascendência das
alturas na reprodução das questões;
e) Certo: atributo booleano que guarda se a questão teve uma resposta certa ou errada.
Existem ainda os métodos da classe TNotas que são:
a) Create: operação responsável por criar uma instância da classe TNotas, e é chamada
pela classe TContainerNotas;
b) Destroy: libera o espaço em memória que as instâncias da classe estão utilizando, e
também é chamado pelo método DestruirNotas da classe TContainerNotas.
4.2.3 DIAGRAMA DE SEQÜÊNCIA Na elaboração do protótipo identificou-se que o diagrama de seqüência possui três
fases, cada uma correspondente a um caso de uso. As fase 1, trabalha somente com a entrada
de opções de treinamento, e não cria nem acessa as classes responsáveis pelo controle das
questões e armazenagem de seus dados. Como esta fase é de fácil descrição, não se viu a
necessidade da criação de um diagrama de sequência para a mesma.
As fases 2 e 3, são ligadas, visto que ao final da fase 2, que é controlada pelo usuário, o
sistema parte automaticamente para a fase 3. Por este motivo, a figura 3, identifica a
seqüência de passos que são realizados para a sequência de treinamento e geração do histórico
do mesmo.
9 Atraso, retardo na reprodução da nota.
40
Figura 3 – DIAGRAMA DE SEQÜÊNCIA DO TREINAMENTO
: Músico : TPercMusicalFrm : TNotas : TContainerNotas
IniciaTreinamento ( )
ExecutaQuestao ( )
SorteiaSequencia (Byte, Byte, TStringlist)
MontaTeste (String, Integer)
BuscaSequenciaNotas (Integer, String)
GeraHistorico ( )
Create (
GetInfNota (Integer)
PercentualAcertos ( )
Create ( )SorteiaNota (Integer)
DestruirNotas ( )
GetInfNota (Integer)
41
4.3 IMPLEMENTAÇÃO Considerações sobre as técnicas utilizadas para implementação do protótipo, bem
como a forma de operação do mesmo, serão apresentadas nesta seção.
4.3.1 TÉCNICAS E FERRAMENTAS UTILIZADAS O protótipo foi implementado no ambiente de desenvolvimento Delphi 5.0, onde foram
empregados alguns conceitos de orientação a objetos para desenvolver as classes responsáveis
pelo controle das questões e armazenamento dos dados (TContainerNotas e TNotas).
O sistema utiliza quatro listas de vetores, implementados em Delphi 5.0 como
StringLists. As listas, lidas a partir de um arquivo de inicialização, contém vetores de
definição de intervalos, escalas, acordes e notas. As notas musicais são tratadas internamente
utilizando-se os conceitos de classe de altura do modelo de inteiros, ou seja, as notas são
agrupadas em um conjunto de 12 (doze) inteiros, partindo do zero (que representa a nota C
neste protótipo) até o onze (que representa a nota B neste protótipo). Através dessa lista
básica, utiliza-se as relações pré-estabelecidas nas outras listas efetuando-se apenas a
transposição da nota sorteada pelo sistema para a relação definida na lista de escalas,
intervalos ou acordes.
Neste mesmo procedimento, é feita a chamada do procedimento que carrega as opções
de treinamento, que vai verificar a existência do arquivo opcoes.pem. Caso o arquivo não seja
encontrado nada é carregado para as configurações das opções de treinamento e o usuário
informa as que julgar apropriadas. Mais adiante será mostrada a geração deste arquivo. O
quadro 13 mostra o procedimento responsável por estas inicializações.
Quadro 13 – MÉTODO CREATE DO FORMULÁRIO //Procedimento executado na criação da instância do protótipo procedure TpercMusicalFrm.FormCreate(Sender: Tobject); var i: Word; sCabecalho: String; mArquivo: TMemo; begin //Título do formulário PercMusicalFrm.Caption := 'Treinamento de percepção musical';
42
//Aqui são instanciadas as string lists que serão utilizadas no //formulário slEscalas := TstringList.Create; slNotas := TstringList.Create; slAcordes := TstringList.Create; slIntervalos := TStringList.Create; //Teste para ver se o arquivo de inicialização existe no diretório do //executável if not FileExists('PERCMUSICAL.INI') then begin //Se não existir o usuário é informado e ocorre a saída do sistema ShowMessage('Arquivo PERCMUSICAL.INI não foi encontrado.'); Exit; End; //Chamada do procedimento que carrega as opções salvas no arquivo CarregaOpcoes; //É criado um TMemo temporário para incluir o arquivo de inicialização e //a partir daí inicializar os string lists mArquivo := TMemo.Create(Self); //Associa o TMemo criado ao formulário mArquivo.ParentWindow := Self.Handle; //Limpa o Tmemo mArquivo.Clear; //Carrega o arquivo testado anteriormente no Tmemo mArquivo.Lines.LoadFromFile('PERCMUSICAL.INI'); sCabecalho := ''; //Executa uma repetição até a última linha do Tmemo for i := 0 to mArquivo.Lines.Count - 1 do begin //Se estiver em uma linha em branco do arquivo, o cabeçalho recebe //vazio para ser mudado if (sCabecalho = '') or (mArquivo.Lines.Strings[i] = '') then sCabecalho := mArquivo.Lines.Strings[i]; //Se o cabeçalho for NOTAS a stringlist de notas será carregada if (UpperCase(sCabecalho) = '[NOTAS]') and (mArquivo.Lines.Strings[i] <> sCabecalho) and (mArquivo.Lines.Strings[i] <> '') then slNotas.Add(mArquivo.Lines.Strings[i]); //Se o cabeçalho for ESCALAS a stringlist de escalas será carregada if (UpperCase(sCabecalho) = '[ESCALAS]') and (mArquivo.Lines.Strings[i] <> sCabecalho) and (mArquivo.Lines.Strings[i] <> '') then slEscalas.Add(mArquivo.Lines.Strings[i]); //Se o cabeçalho for ACORDES a stringlist de acordes será carregada if (UpperCase(sCabecalho) = '[ACORDES]') and (mArquivo.Lines.Strings[i] <> sCabecalho) and (mArquivo.Lines.Strings[i] <> '') then slAcordes.Add(mArquivo.Lines.Strings[i]); //Se o cabeçalho for INTERVALOS a stringlist de intervalos será //carregada
43
if (UpperCase(sCabecalho) = '[INTERVALOS]') and (mArquivo.Lines.Strings[i] <> sCabecalho) and (mArquivo.Lines.Strings[i] <> '') then slIntervalos.Add(mArquivo.Lines.Strings[i]); end; //Destroi o Tmemo mArquivo.Free; end;
Após este método ser executado, o usuário começa a interagir com o formulário
principal do protótipo. Caso seja iniciado o processo de treinamento, o método
IniciaTreinamento é chamado. No quadro 14 pode-se verificar esta chamada.
Quadro 14 – MÉTODO INICIATREINAMENTO //Procedimento que inicializa a variável de opções e chama o processo que //controla as questões procedure TpercMusicalFrm.IniciaTreinamento; var i: Integer; bIntervalo: Boolean; begin //Inicializa a propriedade de opções do formulário sOpcoes := ''; //Se a opção para treinar acordes estiver selecionada if FrameOpcoes.cbAcordes.Checked then //É acrescentado o item 0 nas opções sOpcoes := sOpcoes + '0'; //Se a opção para treinar escalas estiver selecionada if FrameOpcoes.cbEscalas.Checked then //É acrecentado o item 1 nas opções sOpcoes := sOpcoes + '1'; //Se a opção para treinar intervalos estiver selecionada if FrameOpcoes.cbIntervalos.Checked then begin //A string list de intervalos é atualizada de acordo //com as opções de intervalo selecionadas slIntervalos.Values[slIntervalos.Names[0]] := RetornaBooleano(FrameOpcoes.cb2Menor.Checked); slIntervalos.Values[slIntervalos.Names[1]] := RetornaBooleano(FrameOpcoes.cb2Maior.Checked); slIntervalos.Values[slIntervalos.Names[2]] := RetornaBooleano(FrameOpcoes.cb3Menor.Checked); SlIntervalos.Values[slIntervalos.Names[3]] := RetornaBooleano(FrameOpcoes.cb3Maior.Checked); SlIntervalos.Values[slIntervalos.Names[4]] := RetornaBooleano(FrameOpcoes.cb4.Checked); SlIntervalos.Values[slIntervalos.Names[5]] := RetornaBooleano(FrameOpcoes.cbTritone.Checked); SlIntervalos.Values[slIntervalos.Names[6]] := RetornaBooleano(FrameOpcoes.cb5.Checked); SlIntervalos.Values[slIntervalos.Names[7]] := RetornaBooleano(FrameOpcoes.cb6Menor.Checked); SlIntervalos.Values[slIntervalos.Names[8]] := RetornaBooleano(FrameOpcoes.cb6Maior.Checked);
44
SlIntervalos.Values[slIntervalos.Names[9]] := RetornaBooleano(FrameOpcoes.cb7Menor.Checked); SlIntervalos.Values[slIntervalos.Names[10]] := RetornaBooleano(FrameOpcoes.cb7Maior.Checked); SlIntervalos.Values[slIntervalos.Names[11]] := RetornaBooleano(FrameOpcoes.cb8.Checked); SlIntervalos.Values[slIntervalos.Names[12]] := RetornaBooleano(FrameOpcoes.cb9Menor.Checked); BIntervalo := False; for i := 0 to 12 do //Verifica se alguma opção de intervalo está selecionada... if slIntervalos.Values[slIntervalos.Names[i]] = 'True' then bIntervalo := True; //...se tiver, adiciona o número 2 nas opções if bIntervalo then sOpcoes := sOpcoes + '2' //...senão, informa o usuário que a opção intervalos está selecionado, //mas não há nenhum intervalo selecionado para ser treinado else if MessageDlg('Você selecionou a opção de treinamento de intervalos mas não selecionou nenhum intervalo.'+#13+ 'Deseja selecionar um intervalo?', mtConfirmation, [mbYes, mbNo], 0) = mrYes then exit; end; //Cria a instância da lista de treinamento ListaNotas := TcontainerNotas.Create; //Inicializa as questões feitas ListaNotas.Repeticoes := 0; FrameOpcoes.Visible := False; //Mostra o painel de exercício FrameExercicio.Visible := True; //Desabilita as opções de um novo começo de exercício para que o //músico vá até o final do treinamento imIniciarExec.Enabled := False; imOpcoes.Enabled := False; //Chama o processo responsável pelo sorteio das questoes ExecutaQuestao; end;
Como já visto na especificação do protótipo, este método é responsável pela
instanciação da classe TContainerNotas, além da inicialização da variável que armazena as
opções de treinamento pré-definidas.
Ao final do método IniciaTreinamento, vê-se que é chamado o método
ExecutaQuestao, que passará a controlar o sistema na geração de questões aleatórias
conforme pré-definição das opções de treinamento.
45
O anexo 3 apresenta o código fonte do método ExecutaQuestao.
Nota-se que este método é responsável pela chamada dos principais métodos da classe.
A partir deste método são montados todas as questões apresentadas ao usuário para o
treinamento da percepção musical.
Para exemplificar este procedimento, num exercício de intervalos, onde foram pré-
definidos os intervalos de segunda maior, quinta justa, sétima menor e oitava, o sistema terá 4
valores de deslocamento, correspondentes aos 4 intervalos. O sistema deve então sortear uma
nota, que será a nota fundamental do intervalo, e um valor de deslocamento, que é usado para
cálculo da segunda nota do intervalo. Por exemplo, caso o sistema sorteie uma nota G,
correspondente ao inteiro 7 na lista de notas, e um valor de deslocamento igual a 10,
correspondente a um intervalo de sétima menor, então ele deve calcular a segunda nota do
intervalo, acrescentando o valor de deslocamento ao inteiro correspondente à nota
fundamental (7 + 10 = 17). Fazendo-se a divisão inteira deste valor por 12, tem-se:
17 mod 12 = 5
O valor 5 corresponde à nota F, logo o intervalo de sétima menor, com fundamental
em G é reproduzido com as notas G e F, exatamente de acordo com a teoria musical.
Este tipo de cálculo envolvendo distâncias relativas entre alturas (de notas) é previsto
no modelo de inteiros e pode ser aplicado a qualquer relação de intervalos bem como a
escalas e acordes. Esta é justamente a razão pela qual este modelo é amplamente utilizado na
análise musical e em aplicações que necessitem de alguma organização do material sonoro,
como o protocolo MIDI.
Analogamente, em exercícios de escalas o sistema terá dentro da lista de escalas, as
relações de intervalos que compõem as escalas musicais. Então, novamente é sorteada uma
nota da lista de notas, que será a tônica da escala, e uma das relações de intervalos contidas na
lista de escalas, usada para montar a escala a partir da tônica. Se, por exemplo, o sistema
sorteie a nota C#, correspondente ao valor 1 da lista de notas, e através da lista de escalas
sorteie a escala maior iônico. Na lista de escalas, estão definidos os intervalos que montam a
escala correspondente, no caso da escala maior iônica estes intervalos são 0, 2, 4, 5, 7, 9 e 11.
46
Sendo assim, partindo-se da tônica 0, que neste exemplo é C#, correspondente ao valor 1,
soma-se o valor referente a nota a todos os valores que correspondem aos intervalos da escala
sorteada (neste caso, 0+1, 2+1, 4+1, 5+1, 7+1, 9+1 e 11+1), resultaria a relação de notas 1, 3
,5 ,6, 8, 10 e 12. Aplicando-se novamente a teoria de classe de altura faz-se o mod 12 de todos
os valores, que resulta nos valores 1, 3 ,5 ,6, 8, 10 e 0. Tomando-se novamente estes valores
na lista de notas, a escala maior iônico montada a partir da tônica C#, seria formada por C#,
D#, F, F#, G#, A# e C ascendentemente, o que novamente se ajusta a teoria musical.
O quadro 15 representa de uma maneira mais visual o caso apresentado, mostrando
todas as notas de uma oitava, destacando as notas que formam a escala maior iônica com
tônica e C#, indicadas por suas respectivas alturas.
Quadro 15 – ESCALA MAIOR IÔNICA COM TÔNICA EM C#
1 2 3 4 5 6 7 8 9 10 11 0 C# D D# E F F# G G# A A# B C
Partindo-se agora para um exemplo de acordes, nota-se que as relações das alturas que
formam os acordes estão relacionadas da mesma forma que na lista de escalas. Sendo assim,
pode-se dizer que se o sistema sorteia uma nota da lista de notas que será a tônica da escala, e
uma das relações de intervalos contidas na lista de acordes, chegará ao acorde correto em
relação a teoria musical.
Por exemplo, diga-se que foi sorteada a nota E, localizada na posição 4 da lista de
notas, e através da lista de acordes seja sorteada o acorde maior com 7ª menor. Na lista de
acordes os intervalos 0, 4, 7 e 10 formam este acorde. Portanto, tomando-se o valor da nota,
neste caso a nota E, que é 4, e somando-o aos intervalos definidos no acorde maior com
sétima menor tem-se os valores 4, 8, 11 e 14. Aplicando-se a regra de mod 12 da teoria de
classes de altura, chega-se aos valores 4, 8, 11 e 2. Novamente, pegando-se as notas
correspondentes na lista de notas encontra-se o acorde maior com 7ª menor com tônica em E,
que é formado pelas notas E, G#, B e D.
A seguir serão mostrados os métodos SorteiaSequencia, BuscaSequenciaNotas e
MontaTeste.
47
O método SorteiaSequencia é responsável pelo sorteio de uma sequencia de alturas
dentro da lista passada como parâmetro, ou seja, se a lista de escalas for passada como
parâmetro será neste método que uma das relações de alturas referente a uma escala será
sorteada. O quadro 16 apresenta o código fonte deste método.
Quadro 16 – MÉTODO SORTEIASEQUENCIA //Procedure que sorteia uma posição do stringlist equivalente ao treinamento selecionado function TpercMusicalFrm.SorteiaSequencia(xNota: Byte;var XnivelDif: Byte; slGeral: TstringList): String; var i: Byte; s: String; begin Randomize; //Sorteia uma posição do StringList passado como parâmetro i := Random(slGeral.Count – xNivelDif); //Verifica a montagem das notas no vetor s := slGeral.Values[slGeral.Names[i]]; //Passa a posição sorteada e o string da sequencia das alturas BuscaSequenciaNotas(xNota, s); //Retorna a posicao sorteada no StringList xNivelDif := i; //Retorna o string das notas a serem tocadas Result := Copy(s, 0, Length(s) - 1); end;
Pode-se verificar através do código fonte acima que o método BuscaSequenciaNotas é
chamado a partir de SorteiaSequencia. Neste método será montada a sequencia de
monossílabos referente as notas conforme enviados na variável s que contém a sequencia de
alturas. A variável xNota leva a nota sorteada pela questão corrente, e faz a soma “mod 12”
com cada altura da variável s. O quadro 17 mostra o fonte deste método.
Quadro 17 – MÉTODO BUSCASEQUENCIANOTAS //Procedimento recursivo que sequencia um string com as notas a serem tocadas procedure TpercMusicalFrm.BuscaSequenciaNotas(xNota: Integer; var xNotasDesmontar: String); var sNota: String; begin //Pega a primeira nota da sequencia enviada em xNotaDesmontar (notas //separadas por |) sNota := GetShortHint(xNotasDesmontar); //Verifica o nome da nota na StringList de notas sNota := slNotas.Names[(xNota + (StrToInt(sNota))) mod 12]; //Compara o restante do string com a nota que veio, se for diferente... if CompareStr(GetLongHint(xNotasDesmontar), xNotasDesmontar) <> 0 then
48
begin //Atribui o restante do string a variável xNotaDesmontar xNotasDesmontar := GetLongHint(xNotasDesmontar); //Chama a função novamente com o restante do string BuscaSequenciaNotas(xNota, xNotasDesmontar); End Else //...se for igual limpa o string xNotasDesmontar := ''; //Monta o string dos nomes das notas na sequência em que as notas vieram xNotasDesmontar := sNota + ',' + xNotasDesmontar; end;
Nota-se que este método chama a si mesmo caso ainda haja alturas na variável
xNotaDesmontar. Quando esta variável não possuir mais alturas relacionadas, as chamadas do
método vão retornando em cascata, montando dentro da própria variável a sequencia correta
de monossílabos, e retorna ao método que o chamou (SorteiaSequencia) por referência.
O método MontaTeste, é responsável em concatenar na lista de monossílabos montada
as pausas (caso a reprodução do teste seja melódica) e as oitavas das notas de maneira a tornar
a reprodução sonora ascendente. Para melhores esclarecimentos, o quadro 18 apresenta o
código fonte deste método.
Quadro 18 – MÉTODO MONTATESTE //Função que verifica as notas para tornar o som sempre ascendente function TpercMusicalFrm.MontaTeste(s: String; iMelodico: Integer): String; var sComparativo, sResultado : String; iMaiorNota : Byte; begin sComparativo := ''; //Se houver um valor para a variavel a reprodução deve ser melódica... if iMelodico > 0 then //...e é concatenado o valor do delay entre as notas sResultado := Copy(s, 0, (Pos(',', s) - 1))+'4, +IntToStr(iMelodico)+';' else //...senão as notas serão colocadas umas ao lado das outras sResultado := Copy(s, 0, (Pos(',', s) - 1))+'4,'; //O índice da nota sorteada é guardado para ser comparado iMaiorNota := StrToInt(slNotas.Values[Copy(s, 0, (Pos(',', s) - 1))]); //Até que haja notas na sequencia enviada e a variável s tenha algo as //notas são varridas para que seus índices sejam verificados Repeat //Se s for diferente de uma cópia de s após a primeira vírgula... if s <> Copy(s, (Pos(',', s) + 1), Length(s)) then begin //É gravada uma cópia de s após a primeira vírgula dentro dele mesmo s := Copy(s, (Pos(',', s) + 1), Length(s)); //Se existir apenas uma nota em s...
49
if Copy(s, 0, (Pos(',', s) - 1)) = '' then //...a nota é copiada para a variável sComparativo := s else //...senão a variável recebe o que há antes da primeira vírgula sComparativo := Copy(s, 0, (Pos(',', s) - 1)); //Se o indice da nota for menor que o indece da nota na variável //maiornota... if (iMaiorNota > StrToInt(slNotas.Values[sComparativo])) then begin //...a variável maior nota recebe o menor índice iMaiorNota := StrToInt(slNotas.Values[sComparativo]); //A nota recebe a indicação de pertencente a quinta oitava sResultado := sResultado + sComparativo + '5, '; end else //...senão a nota é simplesmente concatenada e continua na mesma //oitava sResultado := sResultado + sComparativo + ', '; end else //...senão s é finalizada como vazia s := ''; until s = ''; //Retorna o resultado das notas em suas oitavas para que a reprodução //seja ascendente Result := Copy(sResultado, 0, Length(sResultado) - 2); end;
Conforme é mostrado na especificação e no quadro referente ao método
ExecutaQuestao, fica claro também que as chamadas do método SorteiaNota e da propriedade
InfNota (que acessa o método privado GetInfNota), ambos pertencentes a classe
TContainerNotas, são principalmente chamados dentro do método ExecutaQuestao.
O método SorteiaNota, é responsável pela criação de cada instância da classe TNotas,
instâncias estas que guardarão as informações de cada questão gerada conforme pré-definição
do usuário. É neste método que a nota de cada questão é sorteada e armazenada na instância
de TNotas criada, para possibilitar futuras escritas e leituras.
A propriedade InfNota por sua vez, é que possibilita a escrita e a leitura dos atributos
da classe TNotas através do índice da questão. Através desta propriedade é possível acessar o
método GetInfNota. Assim, a qualquer momento, é possível saber os dados de cada questão
através desta propriedade.
Os quadros 19 e 20 mostram os fontes do método SorteiaNota e do método
GetInfNota, respectivamente.
50
Quadro 19 – MÉTODO SORTEIANOTA //Procedimento que sorteia um número de 0 a 11 para retornar no objeto //apontado por iHandle procedure TcontainerNotas.SorteiaNota(iHandle: Integer); var nNota: TNotas; begin //Cria uma instância de Tnotas nNota := Tnotas.Create; //Associa o valor de iHandle na propriedade Handle de TNotas nNota.Handle := iHandle; Randomize; //Sorteia um valor de 0 a 11 e atribui a propriedade NotaSorteada de // Tnotas nNota.NotaSorteada := Random(12); //Adiciona a instância criada de TNotas a lista TcontainerNotas como // objeto Self.AddObject(IntToStr(iHandle),nNota); end;
Quadro 20 – MÉTODO GETINFNOTA //Função que busca as informações contidas na classe TNotas no nó indicado //pelo índice function TcontainerNotas.GetInfNota(index: Integer): TNotas; begin //Retorna os conteúdos das propriedades da classe TNotas indicadas pelo //índice "index" Result := TNotas(Self.Objects[Index]); end;
Conforme já descrito anteriormente, ao final do treinamento é gerado um arquivo com
o histórico de desempenho do usuário.
O quadro 21 apresenta o método responsável pela criação do arquivo.
Quadro 21 – MÉTODO GERAHISTORICO //Procedimento que gera o arquivo histórico do exercício procedure TpercMusicalFrm.GeraHistorico; var i: Byte; mHistorico: Tmemo; sNomeHistorico, sAcertou: String; begin //É criado um TMemo temporário para incluir os dados do objeto e partir // dele gerar o arquivo de histórico mHistorico := TMemo.Create(Self); //Associa o TMemo criado ao formulário mHistorico.ParentWindow := Self.Handle; //Limpa o Tmemo mHistorico.Clear;
51
//Cria um nome para o histórico com o nome do usuário que está nas opções //com a extensão .TXT sNomeHistorico := FrameOpcoes.eNomeMusico.Text+'.TXT'; //Verifica se o arquivo já existe... if FileExists(sNomeHistorico) then begin //...se existir joga o que há no arquivo para dentro do TMemo mHistorico.Lines.LoadFromFile(sNomeHistorico); mHistorico.Lines.Add(''); end; //Insere no TMemo o nome do usuário e a data e hora de realização do // treinamento mHistorico.Lines.Add('Usuário:'+FrameOpcoes.eNomeMusico.Text+ '–treinamento realizado em '+DateTimeToStr(Now)); //Faz uma repetição para gravara todas as quetões contidas no objeto for i := 0 to ListaNotas.Count - 1 do begin //Se a questão tiver sido respondida corretamente... if ListaNotas.InfNota[i].Certo then //...a variável recebe Certo sAcertou := 'Certo' else //...senão recebe errado sAcertou := 'Errado'; //Grava uma linha para cada resposta dada no Tmemo mHistorico.Lines.Add(ListaNotas.InfNota[i].NotaTocada+' - '+sAcertou); end; //Calcula o percentual de acerto do treinamento mHistorico.Lines.Add('Percentual de acerto no treinamento: '+ FloatToStrF(ListaNotas.PercentualAcertos, ffFixed, 3, 2)); //Grava as informações do TMemo no arquivo mHistorico.Lines.SaveToFile(sNomeHistorico); //Destroi o Tmemo mHistorico.Free; end;
4.3.2 OPERACIONALIDADE DA IMPLEMENTAÇÃO A seguir serão apresentadas algumas telas do protótipo com suas respectivas
funcionalidades.
Ao entrar-se no sistema pela primeira vez, será apresentada a tela inicial como
demonstra a figura 4.
52
Figura 4 – TELA INICIAL DO PROTÓTIPO
Pode-se selecionar os menus Arquivo, Ferramentas e Sobre. Se o usuário partir para o
menu Arquivo, verá que a única opção habilitada é a de saída do sistema, conforme mostra a
figura 5.
53
Figura 5 – MENU “INICIAR EXERCICIOS” DESABILITADO
Isto ocorre porque nenhuma opção de treinamento foi selecionada. Para poder iniciar o
treinamento o usuário deve primeiramente acessar o menu Ferramentas, Opções para
selecionar as opções de treinamento que deseja exercitar. As figuras 6 e 7 mostram o menu
Ferramentas e o formulário após a seleção do menu Opções, respectivamente.
Figura 6 – MENU “OPÇÕES”
54
Figura 7 – MENU “OPÇÕES DE TREINAMENTO”
Neste ponto, o usuário deve selecionar as opções que deseja exercitar. Deve incluir seu
nome, pois será com este nome que o histórico será gerado. O sistema irá gerar questões
aleatoriamente sobre todas as opções selecionadas. A seguir, será mostrado um exemplo da
utilização do sistema com todas as opções selecionadas. A figura 8, apresenta o menu Opções
com todas as alternativas e dados de treinamento selecionados.
Figura 8 – MENU “OPÇÔES DE TREINAMENTO” PREENCHIDO
Quando há opções selecionadas e o nome do usuário informado, o menu Arquivo,
Iniciar exercícios fica habilitado, para que o usuário possa então, iniciar o treinamento das
55
opções selecionadas. Nota-se que o nome do usuário fica destacado no título do sistema. A
figura 9 mostra este menu habilitado após a inserção das opções.
Figura 9 – MENU “INICIAR EXERCICIOS” HABILITADO
A partir do momento em que o usuário seleciona Iniciar exercícios, o sistema começa
a gerar as questões aleatoriamente, conforme explicado nas seções anteriores. A seguir
apresenta-se três telas com três diferentes questões. A figura 10 mostra uma questão de
treinamento de intervalos.
Figura 10 – QUESTÃO SOBRE INTERVALOS
56
Nota-se que quando o usuário avança no treinamento, indicando sua resposta, o
sistema avisa se o usuário acertou ou errou a questão. A figura 11 mostra uma questão gerada
sobre escalas.
Figura 11 – QUESTÃO SOBRE ESCALAS
A figura 12 apresenta a montagem de uma questão de acordes.
Figura 12 – QUESTÃO SOBRE ACORDES
Pode-se verificar nas telas de treinamento de questões, um botão com a inscrição
Repetir nota além de uma TrackBar chamada Duração do som. O botão disponibiliza ao
usuário a repetição do som gerado pelo sistema para que ele possa analizá-lo novamente. Esta
57
repetição pode ser feita o número de vezes inserido na opção Chances de repetição. A barra
Duração do som adiciona um efeito de sustentação ao som gerado, fazendo com que ele soe
por mais tempo.
Ao final do treinamento, o sistema informa a geração do arquivo de histórico. A figura
13 mostra esta mensagem.
Figura 13 – MENSAGEM DE GERAÇÂO DE HISTÓRICO
Os documentos são gravados no diretório que encontra-se o executável. Na figura 14
pode-se verificar o diretório onde se encontra o protótipo e seus arquivos auxiliares, enquanto
que na 15, um exemplo de um histórico gerado com o nome de Ricardo.TXT.
58
Figura 14 – DIRETÓRIO DO PROTÓTIPO
Figura 15 – MODELO DE HISTÓRICO
59
No arquivo de parâmetros de configuração PercMusical.INI visto na figura 14,
encontra-se a definição das quatro listas principais anteriormente mencionadas, de notas, de
intervalos, de escalas e de acordes. Para execução do sistema, são necessários este arquivo e o
outro arquivo de mesmo nome, chamado PercMusical.EXE. O arquivo Opções.PEM, é gerado
pelo sistema após a primeira execução, e nele são gravadas as opções de treinamento
selecionadas pelo último usuário. Na próxima execução do protótipo, as opções de
treinamento serão automaticamente selecionadas conforme gravadas neste arquivo.
60
5 CONCLUSÕES O objetivo principal deste trabalho, de desenvolver um protótipo baseado na teoria
musical, para gerar questões visando o treinamento da percepção musical, foi atendido.
O principal problema encontrado, foi o de como relacionar a teoria musical de maneira
paramétrica, de forma a possibilitar a utilização de um recurso computacional juntamente com
uma pré programação utilizando a tecnologia MIDI, para gerar questões para o treinamento da
percepção musical.
A geração de questões para treinamento de intervalos, escalas e acordes utilizando a
tecnologia MIDI foi conseguida através do modelo inteiro de classes de alturas musicais, que
faz uma relação das alturas das notas com os números inteiros. Desta forma é possível
parametrizar a teoria musical de forma matemática, para que o protótipo pudesse gerar
automaticamente, as questões para o treinamento conforme uma pré seleção de opções do
usuário.
Este trabalho demostra que, a utilização de relações pré definidas baseadas na teoria
musical para a geração de sistemas musicais é possível, pois a música pode ser encarada, de
certa forma, como uma ciência exata, com atributos lógicos e aritméticos, permitindo assim a
aplicação de relações matemáticas sobre as relações existentes na teoria musical
contemporânea.
Algumas limitações existentes no presente protótipo são:
a) As opções de treinamento existentes no protótipo limitam-se a intervalos, escalas e
acordes, sendo que existem muitas outras relações passíveis de treinamento quando
se trata de percepção musical.
b) Nem todas as relações de intervalos, escalas e acordes foram implementadas, pois
inclusive estas relações possuem muitas variações, de cultura a cultura, e até de
gênero em gênero musical.
c) Este protótipo não permite a detecção da placa de som instalada no recurso
computacional, de forma que esta deve estar previamente configurada.
61
5.1 EXTENSÕES Sugere-se como extensões deste trabalho, a implementação de uma interface visual,
onde poderia ser mostrada ao usuário uma visualização do instrumento (por exemplo, o
desenho do braço de uma guitarra ou as teclas de um piano) ao invés de opções de múltipla
escolha. Isto possibilitaria ao usuário o treinamento da posição das notas no instrumento, além
do treinamento da percepção musical.
Poderia ser implementado também o treinamento de outros elementos da teoria
musical, como por exemplo, o reconhecimento das notas que compõem um acorde ou escala
ao invés de sua qualidade, ou as inversões de um acorde, ou ainda o reconhecimento do
instrumento que produz determinado som.
Seria possível também, a implementação da entrada de dados a partir da porta MIDI do
recurso computacional, conectando diretamente o instrumento ao mesmo. Desta forma o
músico poderia reproduzir o som gerado pelo protótipo no próprio instrumento, e o sistema
reconheceria esta reprodução e a compararia a questão por ele gerada.
Uma última alternativa de extensão, seria a de implementar o protótipo para a
plataforma Palm, ou mesmo para o GameBoy, pois ambos possuem a característica da
portabilidade, mas o segundo apresenta um menor custo. Isto possibilitaria ao usuário o
treinamento da percepção musical em qualquer horário e local que dispusesse de tempo livre.
Como pode-se ver, existem outros exercícios que podem ser montados para
complementar o treinamento da percepção musical de um indivíduo, utilizando-se os recursos
apresentados neste trabalho de conclusão de curso.
62
ANEXO 1 - PATCHES (TIMBRES) GENERAL MIDI
O quadro 22 mostra o nome de todos os 128 instrumentos GM, e os números relativos
que selecionam estes instrumentos.
Quadro 22 – PATCHES GENERAL MIDI Pianos 1 Acoustic Grand Piano 2 Bright Acoustic Piano 3 Electric Grand 4 Honky-Tonk 5 Electric Piano 1 6 Electric Piano 2 7 Harpsichord 8 Clavinet Percussão Cromática 9 Celesta 10 Glockenspiel 11 Music Box 12 Vibraphone 13 Marimba 14 Xylophone 15 Tubular Bells 16 Dulcimer Órgãos 17 Drawbar Organ 18 Percussive Organ 19 Rock Organ 20 Church Organ 21 Reed Organ 22 Accordian 23 Harmonica 24 Tango Accordian Violões 25 Nylon String Guitar 26 Steel String Guitar 27 Electric Jazz Guitar 28 Electric Clean Guitar 29 Electric Muted Guitar 30 Overdriven Guitar 31 Distortion Guitar 32 Guitar Harmonics
Baixos 33 Acoustic Bass 34 Electric Bass(finger) 35 Electric Bass(pick) 36 Fretless Bass 37 Slap Bass 1 38 Slap Bass 2 39 Synth Bass 1 40 Synth Bass 2 Cordas 41 Violin 42 Viola 43 Cello 44 Contrabass 45 Tremolo Strings 46 Pizzicato Strings 47 Orchestral Strings 48 Timpani Ensemble 49 String Ensemble 1 50 String Ensemble 2 51 SynthStrings 1 52 SynthStrings 2 53 Choir Aahs 54 Voice Oohs 55 Synth Voice 56 Orchestra Hit Metais 57 Trumpet 58 Trombone 59 Tuba 60 Muted Trumpet 61 French Horn 62 Brass Section 63 SynthBrass 1 64 SynthBrass 2
Palhetas 65 Soprano Sax 66 Alto Sax 67 Tenor Sax 68 Baritone Sax 69 Oboe 70 English Horn 71 Bassoon 72 Clarinet Tubos 73 Piccolo 74 Flute 75 Recorder 76 Pan Flute 77 Blown Bottle 78 Skakuhachi 79 Whistle 80 Ocarina Synth Lead 81 Lead 1 (square) 82 Lead 2 (sawtooth) 83 Lead 3 (calliope) 84 Lead 4 (chiff) 85 Lead 5 (charang) 86 Lead 6 (voice) 87 Lead 7 (fifths) 88 Lead 8 (bass+lead) Synth Pad 89 Pad 1 (new age) 90 Pad 2 (warm) 91 Pad 3 (polysynth) 92 Pad 4 (choir) 93 Pad 5 (bowed) 94 Pad 6 (metallic) 95 Pad 7 (halo) 96 Pad 8 (sweep)
Efeitos Sintetizados 97 FX 1 (rain) 98 FX 2 (soundtrack) 99 FX 3 (crystal) 100 FX 4 (atmosphere) 101 FX 5 (brightness) 102 FX 6 (goblins) 103 FX 7 (echoes) 104 FX 8 (sci-fi) Étnicos 105 Sitar 106 Banjo 107 Shamisen 108 Koto 109 Kalimba 110 Bagpipe 111 Fiddle 112 Shanai Percussivos 113 Tinkle Bell 114 Agogo 115 Steel Drums 116 Woodblock 117 Taiko Drum 118 Melodic Tom 119 Synth Drum 120 Reverse Cymbal Efeitos Sonoros 121 Guitar Fret Noise 122 Breath Noise 123 Seashore 124 Bird Tweet 125 Telephone Ring 126 Helicopter 127 Applause 128 Gunshot
63
ANEXO 2 - PERCUSSÃO GENERAL MIDI
O quadro 23 mostra quais sons de percussão estão associadas a quais notas MIDI de
um módulo GM que contenha uma parte de percussão, através do número da nota e o som da
percussão.
Quadro 23 – PERCUSSÃO GENERAL MIDI
35 Acoustic Bass Drum 36 Bass Drum 1 37 Side Stick 38 Acoustic Snare 39 Hand Clap 40 Electric Snare 41 Low Floor Tom 42 Closed Hi-Hat 43 High Floor Tom 44 Pedal Hi-Hat 45 Low Tom 46 Open Hi-Hat 47 Low-Mid Tom 48 Hi-Mid Tom 49 Crash Cymbal 1 50 High Tom 51 Ride Cymbal 1 52 Chinese Cymbal 53 Ride Bell 54 Tambourine 55 Splash Cymbal 56 Cowbell 57 Crash Cymbal 2 58 Vibraslap
59 Ride Cymbal 2 60 Hi Bongo 61 Low Bongo 62 Mute Hi Conga 63 Open Hi Conga 64 Low Conga 65 High Timbale 66 Low Timbale 67 High Agogo 68 Low Agogo 69 Cabasa 70 Maracas 71 Short Whistle 72 Long Whistle 73 Short Guiri 74 Long Guiro 75 Claves 76 Hi Wood Block 77 Low Wood Block 78 Mute Cuica 79 Open Cuica 80 Mute Triangle 81 Open Triangle
64
ANEXO 3 - MÉTODO EXECUTAQUESTAO
O quadro 24, apresenta o código fonte do método ExecutaQuestao, principal método
do protótipo.
Quadro 24 – MÉTODO EXECUTAQUESTAO //Procedimento responsável pela geração das questões aleatoriamente, e pelo //armazenamento das mesma no objeto de controle procedure TpercMusicalFrm.ExecutaQuestao; var i, iPosicao, iTipoTeste, iNivelDif, iDif: Byte; sStringDesmontar, sOutraNota: String; begin //Enquanto de repetições do objeto for menor que a quantidade de //repetições gera uma nova questão if ListaNotas.Repeticoes < FrameOpcoes.seQuestoes.Value then begin //Inicializa o tag das chances para verificar depois no botão de //reproduzir novamente o som gerado FrameOpcoes.seChances.Tag := 0; //Sorteia um dos três itens do protótipo 0:Acordes - 1:Escalas – //2:Intervalos... Randomize; Repeat ITipoTeste := Random(3); //...até que o que tenha sorteado esteja nas opções do usuário until Pos(IntToStr(iTipoTeste), sOpcoes) <> 0; //Chama o procedimento da classe de sorteio de nota ListaNotas.SorteiaNota(ListaNotas.Repeticoes); //Verifica a opção Case iTipoTeste of 0 : begin //Acerta o título da questão FrameExercicio.rgAlternativas.Caption := 'Alternativas'; //Verifica o nível de dificuldade do acorde case FrameOpcoes.rgAcordesDif.ItemIndex of 0 : iNivelDif := slAcordes.Count - 2; 1 : iNivelDif := slAcordes.Count - 5; 2 : iNivelDif := 0; end; //Chama o procedimento SorteiaSequencia e joga o resultado que é //a sequencia de notas a ser tocada dentro da variável sStringDesmontar := SorteiaSequencia (ListaNotas.InfNota[ListaNotas.Repeticoes].NotaSorteada, InivelDif, slAcordes); //Insere a sequencia de notas juntamente com o nome da nota da //sequencia de acordes na propriedade da nota
65
ListaNotas.InfNota[ListaNotas.Repeticoes].NotaTocada := SlAcordes.Names[iNivelDif]+' - '+sStringDesmontar; //Verifica se a opção de reprodução do acorde é melódico ou //harmônico... if FrameOpcoes.rgAcordesMelArm.ItemIndex = 0 then //...se for monta o acorde melódico com um intervalo de meio //segundo entre cada nota ListaNotas.InfNota[ListaNotas.Repeticoes].TesteMontado := MontaTeste(sStringDesmontar, 50) Else //...senão monta o mesmo acorde sem intervalos entre as notas ListaNotas.InfNota[ListaNotas.Repeticoes].TesteMontado := MontaTeste(sStringDesmontar, 0); //Limpa o painel de opções da questão FrameExercicio.rgAlternativas.Items.Clear; Randomize; //Sorteia a posição em que ficará a resposta certa iPosicao := Random(5); //Repetição para gerar uma questão de multipla escolha com 5 //alternativas for i := 0 to 4 do begin //Se estiver na posição da resposta certa... if i = iPosicao then //...insere a mesma como item da questão FrameExercicio.rgAlternativas.Items.Add (ListaNotas.InfNota[ListaNotas.Repeticoes].NotaTocada) else begin //senão sorteia uma outra montagem para a mesma questão de //acordes repeat iNivelDif := 0; sOutraNota := SorteiaSequencia (ListaNotas.InfNota[ListaNotas.Repeticoes].NotaSorteada, iNivelDif, slAcordes); sOutraNota := slAcordes.Names[iNivelDif]+' - '+sOutraNota; //até que a mesma já não esteja entre as alternativas de //resposta e seja diferente da resposta certa until (Pos(sOutraNota, FrameExercicio.rgAlternativas.Items.Text) = 0) and (sOutraNota <> ListaNotas.InfNota[ListaNotas.Repeticoes].NotaTocada); //E insere como nova alternativa FrameExercicio.rgAlternativas.Items.Add(sOutraNota); end; end; end; 1 : begin //Acerta o título da questão FrameExercicio.rgAlternativas.Caption := 'Alternativas'; iNivelDif := 0; //Chama o procedimento SorteiaSequencia e joga o resultado que é //a sequencia de notas a ser tocada dentro da variável sStringDesmontar := SorteiaSequencia (ListaNotas.InfNota[ListaNotas.Repeticoes].NotaSorteada, iNivelDif, slEscalas); //Insere a sequencia de notas juntamente com o nome da nota da //sequencia da escala na propriedade da nota
66
ListaNotas.InfNota[ListaNotas.Repeticoes].NotaTocada := slEscalas.Names[iNivelDif]+' - '+sStringDesmontar; //Monta a escala com um intervalo de aproximadamente 1/3 de //segundo entre cada nota ListaNotas.InfNota[ListaNotas.Repeticoes].TesteMontado := MontaTeste(sStringDesmontar, 30); //Limpa o painel de opções da questão FrameExercicio.rgAlternativas.Items.Clear; Randomize; //Sorteia a posição em que ficará a resposta certa iPosicao := Random(5); //Repetição para gerar uma questão de multipla escolha com 5 //alternativas for i := 0 to 4 do begin //Se estiver na posição da resposta certa... if i = iPosicao then //...insere a mesma como item da questão FrameExercicio.rgAlternativas.Items.Add (ListaNotas.InfNota[ListaNotas.Repeticoes].NotaTocada) else begin //senão sorteia uma outra montagem para a mesma questão de //escalas repeat iNivelDif := 0; sOutraNota := SorteiaSequencia (ListaNotas.InfNota[ListaNotas.Repeticoes].NotaSorteada, iNivelDif, slEscalas); sOutraNota := slEscalas.Names[iNivelDif]+' - '+sOutraNota; //até que a mesma já não esteja entre as alternativas de //resposta e seja diferente da resposta certa until (Pos(sOutraNota, FrameExercicio.rgAlternativas.Items.Text) = 0) and (sOutraNota <> ListaNotas.InfNota[ListaNotas.Repeticoes].NotaTocada); //E insere como nova alternativa FrameExercicio.rgAlternativas.Items.Add(sOutraNota); end; end; end; 2 : begin //Coloca o nome da nota sorteada na variável sStringDesmontar := slNotas.Names [ListaNotas.InfNota[ListaNotas.Repeticoes].NotaSorteada]; //Coloca o nome da nota no título da questão FrameExercicio.rgAlternativas.Caption := 'Alternativas - Tônica: '+sStringDesmontar; //Seta a oitava da nota para a quarta oitava sStringDesmontar := sStringDesmontar+'4, '; //Se o tipo de reprodução for melódico... if FrameOpcoes.rgIntervalos.ItemIndex = 0 then //...acrescenta um intervalo de meio segundo entre as notas sStringDesmontar := sStringDesmontar + '50;'; //Sorteia um numero entre 0 e 12 para selecionar o intervalo na //lista de intervalos... repeat i := Random(13); //até que o intervalo estar entre os intervalos selecionados
67
until slIntervalos.Values[slIntervalos.Names[i]] = 'True'; //Verifica o quociente da divisão do valor da nota mais o //intervalo dividido por 12 iDif := (ListaNotas.InfNota[ListaNotas.Repeticoes].NotaSorteada + (i+1)) div 12; //Se o quociente for 0... if iDif = 0 then //...a nota representante do intervalo é acrescentada na mesma //oitava... ListaNotas.InfNota[ListaNotas.Repeticoes].TesteMontado := SStringDesmontar+ SlNotas.Names [ListaNotas.InfNota[ListaNotas.Repeticoes].NotaSorteada + (i+1)] else //Se for 1... if iDif = 1 then //...a nota é acrescentada na quinta oitava ListaNotas.InfNota[ListaNotas.Repeticoes].TesteMontado := SstringDesmontar+ slNotas.Names [(ListaNotas.InfNota[ListaNotas.Repeticoes].NotaSorteada + (i+1)) mod 12]+'5' else //Se for 2... if iDif = 2 then //...é acrescentada na sexta oitava ListaNotas.InfNota[ListaNotas.Repeticoes].TesteMontado := SstringDesmontar+ slNotas.Names [(ListaNotas.InfNota[ListaNotas.Repeticoes].NotaSorteada + (i+1)) mod 12]+'6'; //Limpa o painel de opções da questão FrameExercicio.rgAlternativas.Items.Clear; //o Nome do intervalo é gravado no objeto ListaNotas.InfNota[ListaNotas.Repeticoes].NotaTocada := slIntervalos.Names[i]; Randomize; //Sorteia a posição em que ficará a resposta certa iPosicao := Random(5); //Repetição para gerar uma questão de multipla escolha com 5 //alternativas for i := 0 to 4 do begin //Se estiver na posição da resposta certa... if i = iPosicao then //...insere a mesma como item da questão FrameExercicio.rgAlternativas.Items.Add (ListaNotas.InfNota[ListaNotas.Repeticoes].NotaTocada) else begin //...senão sorteia uma outra montagem para a mesma questão de //intervalos repeat iDif := Random(13); sOutraNota := slIntervalos.Names[iDif]; until (Pos(sOutraNota, FrameExercicio.rgAlternativas.Items.Text) = 0) and (sOutraNota <>
68
ListaNotas.InfNota[ListaNotas.Repeticoes].NotaTocada); //E insere como nova alternativa FrameExercicio.rgAlternativas.Items.Add(sOutraNota); end; end; end; end; //Teste é reproduzido MidiGen.PlayString (ListaNotas.InfNota[ListaNotas.Repeticoes].TesteMontado); //A variável de quantidade de questões ListaNotas.Repeticoes := ListaNotas.Repeticoes + 1; End else begin //Chama o processo que gera o histórico GeraHistorico; //Destroi a lista de notas geradas ListaNotas.DestruirNotas; //Esconde o painel do exercício FrameExercicio.Visible := False; //Informa sobre a criação do arquivo MessageDlg('Um arquivo de histórico foi gerado com o nome de" '+FrameOpcoes.eNomeMusico.Text+'.TXT".', mtInformation, [mbOk], 0); //Habilita novamente os menus para que o usuário possa selecionar as //opções e começar novamente o exercício imIniciarExec.Enabled := True; imOpcoes.Enabled := True; end; end;
69
REFERÊNCIAS BIBLIOGRÁFICAS
CANTÙ, Marco. Dominando o delphi 5: a bíblia. São Paulo: Makron Books, 2000.
CHEDIAK, Almir. Harmonia e Improvisação. Rio de Janeiro: Lumiar Editora. 1986.
FERREIRA, Josemar Dias. Multimídia para programadores e analistas. Rio de Janeiro:
Livraria e Editora Infobook S.A, 1995.
FURLAN, José Davi. Modelagem de objetos através da UML – the unified modeling
language. São Paulo: Makron Books, 1998.
GONTIJO, Christian Haagensen. Sítio Web sobre Midi, [S.l.], [1998]. Disponível em:
<http://www.geocities.com/SiliconValley/Campus/7086/>. Acesso em: 03 maio 2002.
PAULA FILHO, Wilson de P. Multimídia: conceitos e aplicações. Rio de Janeiro: LTC
Livros Técnicos e Científicos, 2000.
PLATE, Eduardo. [email protected], São Paulo, maio [2000]. Disponível em:
<http://www.violao.hpg.ig.com.br/index.html>. Acesso em: 07 maio 2002.
RAHN, John. Basic atonal theory. New York: Schrimer Books, 1980.
RIBEIRO, Wagner. Elementos de teoria da música. São Paulo: Coleção F.T.D. Ltda., 1965.
VAUGHAN, Tay. Multimídia na prática. São Paulo: Makron Books, 1994.
