2.3 Relaxatie-oscillator

Afstudeeropdracht
Saxion Hogeschool Enschede
Meting van de kindruk tijdens vioolspel
Marc Nijdam
Begeleider: ir. ing. E. Bouwmeester
Studierichting elektrotechniek
December 2004

Lucas v. Leyden, 1524, gravure, (detail van) “Musicerend paar”

Inhoudsopgave
Pagina
Hoofdstuk 1 Inleiding
1.1 Meting van de kindruk tijdens vioolspel............................... 6
1.2 Voorwaarden bij het meten.................................................... 6
1.2.1 Synchronisatie met metronoom........................................ 6
1.2.2 Muziek/midi omgeving..................................................... 7
1.2.3 Sequencer.......................................................................... 7
1.3 Ontwerp................................................................................. 8
1.4 Systeem.................................................................................. 8
Hoofdstuk 2
2.1 Drukmeting - krachtmeting................................................... 9
2.1.1 Soorten meetsensoren....................................................... 9
2.1.2 PZT-sensor als krachtsensor............................................. 11
2.2 Oscillatoren........................................................................... 11
2.2.1 Harmonische oscillator..................................................... 12
2.2.1.1 Complexe Impedantie van de Sensor.......................... 12
2.2.1.2 Pierce Oscillator.......................................................... 15
2.2.1.3 Overdracht................................................................... 17
2.2.1.4 Berekening van R1, C1 en C2..................................... 19
2.2.1.5 Wijzigingen Pierce en Simulatie................................. 22
2.2.1.6 Metingen bij de resonantiefrequentie.......................... 24
2.2.1.7 Serieresonantie............................................................ 24
2.3 Relaxatie-oscillator................................................................ 25
2.3.1 Capaciteitsverandering ten gevolge van druk.................. 26
2.3.2 Meetcircuit....................................................................... 28
Hoofdstuk 3 Data-acquisitie en –verwerking.......................................................... 29
3.1 Microcontroller..................................................................... 29
3.1.1 Gestuurde oscillatie......................................................... 30
3.1.2.1 Omzetting naar midi................................................... 32
3.1.2.2 Linearisatie................................................................. 35
3.1.3 Calibratie......................................................................... 37
3.1.4 Complete schakeling....................................................... 39
3.2 PC-Software......................................................................... 40
Hoofdstuk 4 Mechanische constructie en realisatie................................................ 43
4.1 Specificaties van het systeem............................................... 45
4.1.1 Meetbereik....................................................................... 45
4.1.2 Gevoeligheid.................................................................... 45
4.1.3 Meetfrequentie................................................................. 45
4.1.4 Omgevingsinvloeden....................................................... 45
4.1.5 Massa van het meetapparaat............................................. 45

Hoofdstuk 5 Meetresultaten..................................................................................... 46
5.1 Inzichten uit de meetresultaten............................................. 48
Hoofdstuk 6 Conclusies en aanbevelingen.............................................................. 49
6.1 Conclusies............................................................................. 49
6.2 Aanbevelingen...................................................................... 49
Appendix
Sourcecode van het stuurprogramma voor de AT89C2051................ 51
Sourcecode van het midifile-conversieprogramma............................ 64
MIDI File standaard........................................................................... 75
Lijst van literatuur en andere bronnen................................................ 86

1 Inleiding
Door de eeuwen heen heeft zowel de klassieke muziek als het vioolspel een bijzonder grote ontwikkeling
doorgemaakt. Vanwege de ontwikkeling in de muziek werden de technische vaardigheden die van
de violisten werden gevraagd ook steeds groter. Een belangrijke basis die deze ontwikkeling mogelijk
maakte, is de manier waarop het instrument werd vastgehouden. Immers deze bepaalt de stabiliteit van
het instrument tijdens het spel, waardoor de musicus niet geremd hoeft te worden in het weergeven
van zijn interpretatie.
Tegenwoordig tekent zich echter ook een schaduwzijde af aan deze ontwikkeling. Bij sommige violisten
ontstaan lichamelijke klachten, vanwege overbelasting van gewrichten en spieren. Om meer
inzicht in de oorzaken hiervan te krijgen, hebben we getracht een meetapparaat te ontwikkelen, dat tot
doel had bepaalde bewegingen te kunnen meten tijdens het spel. De bewegingen die we onderzoeken,
hebben te maken met het moment waarop de viool werd vastgehouden met de kin of de kaak en met
welke kracht dat gebeurde.
Drie belangrijke aspecten worden daarbij behandeld:
• Het type sensor en het bijbehorende algorithme om de kracht te meten.
• De software die de data verwerkt.
• De mechanische constructie waarin deze sensor voorkomt.
Hoewel de meetresultaten die uit dit onderzoek voortkomen niet direct van betekenis zijn voor de technische
kant van dit verslag, geven ze wel inzicht in de werking van het apparaat en de eigenschappen
waaraan het moet voldoen. Daarom is hieraan hoofdstuk 5 gewijd.
Tenslotte worden er conclusies getrokken en aanbevelingen gedaan die uit de ontwikkeling van het apparaat
zijn voortgekomen.
5

1.1 Meting van de kindruk tijdens het vioolspel
Op de moderne viool zit een kinhouder (afb. 1.1) gemonteerd. Deze kinhouder is een opstaand deel
waar een rand op zit. De kaak of kin van de violist valt over deze rand, waardoor de violist het instrument
daarmee kan vastklemmen en kan voorkomen dat het weggetrokken wordt door de linkerhand
tijdens het spel. Aan de onderkant van het instrument zorgt op zijn beurt het sleutelbeen voor steun.
Afb. 1.1. Kinhouder
(van www.viva-sas.com)
Afb. 1.2. Kracht op de viool
(uit “6 Lessons w. Menuhin”)
Tijdens het spelen op een viool hoeft deze kindruk niet altijd aanwezig te zijn, omdat de linkerhand het
instrument ook kan dragen. Bij sommige bewegingen echter kan de linkerhand niet tegelijkertijd zowel
het instrument dragen als een nieuwe stand opzoeken. Op deze momenten is het van groot belang
dat het instrument wordt vastgeklemd tussen de kaak en het sleutelbeen (afb. 1.2). Deze spanning kan
worden losgelaten zodra de linkerhand de dragende functie van het instrument weer kan overnemen.
We zijn erin geïnteresseerd op welke momenten deze overgang plaatsvindt. En hoe groot deze kracht
is.
Voor het meten van deze kracht volstaat het de kinhouder zo te veranderen, dat er tussen de kinhouder
en de viool een krachtsensor gemonteerd kan worden, waarmee de neerwaartse kracht op de kinhouder
op een krachtsensor kan worden overgebracht.
1.2 Voorwaarden bij het meten
Er bestaan talloze soorten kinhouders. Ze onderscheiden zich in vorm en in hoogte. Elke speler heeft
een voorkeur voor een bepaalde vorm. Deze hangt samen met de lichaamsbouw. Deze bouw heeft
tevens invloed op de hoogte von de kinhouder. Als deze immers te laag is, moet het hoofd een ongezonde
houding aannemen om het instrument te kunnen vasthouden.
Aangezien we verschillende proefpersonen wilden laten spelen, was het nodig de speciale kinhouder
zo te construeren dat hij in hoogte verstelbaar was, om niet meetwaarden te krijgen die door een
krampachtige houding veroorzaakt werden. Daarbij is wat de vorm aangaat een compromis genomen.
We vonden het kunnen aanpassen van de hoogte belangrijker dan de vorm.
1.2.1 Synchronisatie met metronoom
Als iemand zonder overbodige spanningen speelt, zijn de momenten waarop verandering van kracht
wordt uitgeoefend op de kinhouder, meestal gerelateerd aan bepaalde technische moeilijke passage’s in
de muziek. Om te kunnen analyseren op welke plaatsen deze geweest zijn, moeten we de geregistreer-
6

de data vergelijken met de overeenkomstige plaats in de muziek. Als we de gegevens van meerdere
personen ook onderling willen vergelijken is het handig wanneer iedereen in hetzelfde tempo speelt.
Dit leidt ertoe dat een computer het tempo dicteert waarin gespeeld wordt.
1.2.2 Muziek/midi omgeving
De meetdata worden uiteindelijk weergegeven onder de gespeelde notenbalk. (figuur 1.3). Achteraf
kunnen we dan een analyse maken op welke momenten in de muziek er spieren werden aangespannen.
Figuur 1.3. representatie van meetwaarden
De bovenstaande grafiek hebben we in een aantal stappen verkregen:
• In het meetapparaat met de krachtsensor zit een een microcontroller, die de meting uitvoert en
de data produceert.
• Voor de transmissie van de data van het meetapparaat naar de computer gebruik we een bestaand
formaat dat geschikt is voor dit doel: de MIDI-standaard in combinatie met de MIDI File
standaard, die tijdcode-informatie toevoegt. Deze standaard voorziet in een seriële datatransmissie,
waarvan de baudrate en de datastructuur vastligt.
• Op de pc kunnen we met de juiste software deze data opnemen. De software voorziet de data,
op het moment dat deze de PC binnenkomen, van een tijdstempel, tijdcode genaamd.
• De opgenomen data worden geconverteerd, zodat een spreadsheet deze kan importeren.
• Een spreadsheet geeft de data als grafieken weer en toont het notenschrift daarboven.
1.2.3 Sequencer
De software die de MIDI-data opneemt, heet ook wel een sequencer. Zulke programma’s zijn erg handig
om meetdata te verzamelen. Voor verdere verwerking is deze software minder geschikt, omdat een
sequencer niet de mogelijkheid heeft om data van bijvoorbeeld verschillende spelers eenvoudig onderling
te kunnen vergelijken en andersom een spreadsheet niet met data van een sequencer kan omgaan.
We kunnen bij de meeste programma’s wel alle data van een sequencer exporteren naar een MIDI-File
formaat, welke ook gedocumenteerd (Zie hiervoor de appendix) en gestandaardiseerd 1 is. Dit geeft ons
de mogelijkheid met een ander programma de data te kunnen analyseren. Speciaal hiervoor hebben
we een programma geschreven dat MIDI-files omzet naar een tekstbestand, dat we vervolgens in een
spreadsheet kunnen importeren.
7

1.3 Ontwerp
Uit de hiervoor genoemde voorwaarden hebben we onze aandacht op een zestal punten gericht:
• Een geschikte sensor vinden.
• Een speciale kinhouder fabriceren waarin die sensor geplaatst kan worden, zodanig dat we de
drukkracht op de houder kunnen meten.
• De hardware rondom de microcontroller en de sensor realiseren.
• Software voor het debuggen tijdens de testfase.
• Software voor de microcontroller waarop de sensor zit aangesloten.
• Software die een MIDI-file omzet naar een tekstbestand.
Voordat we de speciale kinhouder gemaakt hebben, zijn we eerst gaan kijken welke sensor we konden
gaan gebruiken. De afmeting en de vorm daarvan heeft namelijk invloed op het ontwerp van de kinhouder.
In hoofdstuk twee wordt er op die sensor dieper ingegaan.
Tijdens de testfase hadden we de mogelijkheid de software van de microcontroller te debuggen. Hiervoor
hadden we een programma, geschreven in C, dat bytes van de MIDI-interface inlas, en uitvoerde
naar het scherm. In de microcontroller hadden we vervolgens een routine die de inhoud van een bepaald
register via de seriële poort naar de computer, waarop dit debugprogramma draaide, kon sturen.
De software voor het verwerken van de sensordata in de microcontroller hebben we in assembler
geschreven en niet in C. De reden hiervoor is dat de gebruikte microcontroller een Atmel AT89C2051,
deel van de familie van de MCS ® 51, niet uitblinkt in snelheid. Om toch nauwkeurig te kunnen meten,
was het gebruik van alle timers en een aantal interruptleidingen noodzakelijk. In assembly konden we
zo efficiëntere code schrijven. Bijvoorbeeld doordat we direct konden zien hoeveel clockcycli bepaalde
instructies zouden duren.
Het converteringsprogramma is in C++ geschreven. Met behulp van de fileselector wordt met dit
windowsprogramma een MIDI File geselecteerd, waarin zich MIDI controller data bevinden. De
MIDI controller data zet het programma om naar een standaard, met komma gescheiden, tekstbestand.
Ook de naam van de uitvoerfile wordt met behulp van de standaard windows-fileselector aangegeven.
De converteringsroutine heeft een systeem gebaseerd op het zetten van vlaggen voor alle toestanden
waarin de gelezen character kan voorkomen. Deze volgt de MIDI File standaard (Ondersteund zowel
type 0 als 1)
1.4 Systeem
Het uiteindelijke systeem bestaat uit:
• De speciale kinhouder met de microcontroller en de sensor.
• Een computer, voorzien van een sequencerprogramma waarmee we MIDI-data kunnen opnemen
en het converteringsprogramma om deze data importeerbaar te maken in een spreadsheetprogramma.
8

2.1 Drukmeting - krachtmeting
Hoofdstuk 2 gaat nader in op de sensor waarvan gebruik wordt gemaakt om de drukkracht te meten.
Ook beschrijft het op welke wijze dat is gerealiseerd. Tijdens de zoektocht naar een geschikte sensor,
zijn we uiteindelijk uitgekomen op een PZT-sensor die aan een aantal gunstige voorwaarden voldoet
zoals: een eenvoudige interface naar een schakeling voor verdere dataverwerking, geschikt voor het
meten van een absolute kracht (een soort DC-meting), geringe massa en afmeting. Hiertegenover staan
ook een aantal minder gunstige eigenschappen, zoals onder andere de temperatuurafhankelijkheid
en het ontbreken van specificaties van de producent. Daarnaast is de programmatuur die de verdere
dataverwerking voor zijn rekening neemt ingewikkelder, omdat er vanwege mechanische koppeling
stoorsignalen van het instrument worden opgepikt, die de meetwaarden kunnen beïnvloeden. In de
literatuur is er veel informatie over PZT te vinden. Dit gaat echter maar heel zelden over het gebruik
van PZT als sensor voor het meten van een absolute kracht.
2.1.1 Soorten meetsensoren
Op het internet vinden we onder andere op de homepage van Farnell (www.farnell.com) een overzicht
van leverbare krachtsensoren, waarvan we er hier een paar opnoemen. Daarnaast volgt er een beschrijving
van krachtsensoren die van flexibele folie gemaakt worden. Juist als er in het ontwerp niet veel
ruimte voor een sensor beschikbaar is, zou overwogen kunnen worden deze te gebruiken.
Honeywell FSL05N2C: (figuur 2.1 maten zijn in mm)
Figuur 2.1 Honeywell Forcesensor with specifications
De bijbehorende beschrijving:
“The FS Series Sensors provide precise, reliable force sensing performance in a compact commercial
grade package. The sensor ... utilizes a specialized piezoresistive micro-machined silicon sensing element.
The low power, unamplified, noncompensated Wheatstone bridge circuit design provides inherently
stable mV outputs over the force range.
Force sensors operate on the principle that the resistance of silicon implanted piezoresistors will increase
when the resistors flex under any applied force. The sensor concentrates force from the application,
through the stainless steel plunger, directly to the silicon sensing element. The amount of resistance
changes in proportion to the amount of force being applied. This change in circuit resistance results
in a corresponding mV output level...”
9

Honeywell FSG15N1A: (figuur 2.2 maten zijn in mm)
Figuur 2.2 Honeywell Forcesensor
Deze krachtsensor heeft een iets andere behuizing, maar is wat betreft het grotere meetbereik (0-
1500g) geheel vergelijkbaar met de eerder genoemde Honeywell FSL05N2C.
Omdat de sensor op een plaats gemonteerd gaat worden waar maar heel weinig ruimte is, hebben we
naar nog dunnere sensoren gezocht. Zo kwamen we bij de firma Tekscan. Deze maakt sensoren die uit
twee flinterdunne folies bestaan, waartussen een speciale geleidende inkt zit. Bijvoorbeeld de Flexi-
Force A210 (figuur 2.3)
Figuur 2.3 FlexiForce krachtsensor
Deze sensor heeft een dikte van 0.127 mm. Bij toenemende kracht neemt de weerstand af van 20 MΩ
naar ongeveer 20 kΩ. De beschrijving van het bedrijf:
“With its paper-thin construction, flexibility and force measurement ability, the FlexiForce force sensors
can measure force between almost any two surfaces and is durable enough to stand up to most environments.
FlexiForce has better force sensing properties, linearity, hysteresis, drift and temperature
sensitivity than any other thin-film force sensors.
The new and improved FlexiForce A201 force sensor is an ultra-thin, flexible printed circuit. It is 14
mm wide and 203 mm in full length. The active force sensing area is a 9.5 mm diameter circle at the
end of the force sensor. The force sensors are constructed of two layers of substrate, such as a polyester
film. On each layer, a conductive material (silver) is applied, followed by a layer of pressuresensitive
ink. ...The active sensing area is defined by the silver circle on top of the pressure-sensitive
ink. Silver extends from the sensing area to the connectors at the other end of the sensor, forming the
conductive leads. ....”
Het bedrijf heeft drie soorten krachtsensoren, varierend in het maximale meetbereik: (4.4N,111N en
444N)
Alle hierboven genoemde sensoren hebben als eigenschap dat de weerstand verandert als er een kracht
op wordt uitgeoefend.
Naast de kant-en-klare oplossingen van hierboven, bestaan er ook andere methoden om kracht te meten.
Meestal gaat dat via een mechanische omzetting van kracht naar verplaatsing. Dit gebeurt bijvoorbeeld
bij sommige elektronische weegschalen waarin twee of meer platen zitten die als condensator
fungeren. Via de capaciteit van deze condensator, een maat voor de afstand tussen de platen, kan de
kracht gemeten worden, terwijl een veer de platen van elkaar houdt.
10

Een andere manier om kracht te meten is door de spanning te meten die een PZT-sensor (figuur 2.4)
opwekt als de aangelegde kracht erop verandert 2 . Deze spanning ontstaat door ionen die een andere
plaats innemen in het kristal ten gevolge van een kracht.
Figuur 2.4 PZT-sensor
Willen we de spanning meten die een PZT-sensor opwekt, dan moet het meetcircuit een erg hoge ingangsimpedantie
hebben. We kunnen op deze manier echter niet een onveranderende kracht (statisch)
meten, omdat er altijd heel kleine lekstromen zijn. Ook als op deze statische kracht een wisselende
kracht gesuperponeerd wordt (dynamisch), is deze meetmethode ongeschikt, omdat over een langere
tijd de statische kracht vanwege lekstromen uit het meetsignaal verdwijnt. We moeten dus een andere
methode vinden als we met een PZT-sensor statische kracht willen meten.
2.1.2 PZT-sensor als krachtsensor
Voor het bepalen van krachtverloop op een PZT-sensor meten we daarom niet de opgewekte spanning,
maar de resonantiefrequentie. Deze neemt af bij belasting 3 . Het ligt dus voor de hand een oscillatorschakeling
te nemen waarin de PZT-sensor als frequentiebepalend element wordt opgenomen.
2.2 Oscillatoren
Er zijn twee belangrijke klassen van oscillatoren: harmonische oscillatoren (figuur 2.5) en relaxatieoscillatoren
(figuur 2.6). Harmonische oscillatoren met een kristal hebben als eigenschap dat er een
interne en periodieke uitwisseling van energie plaatsvindt, zoals bijvoorbeeld bij een spoel in serie met
een condensator mogelijk is. Bij relaxatie-oscillatoren wordt er steeds omgeschakeld tussen twee a-stabiele
toestanden, waarin het tijdbepalende element gevormd wordt door bijvoorbeeld een RC-tijd.
-
+
Figuur 2.5 Principeschema
harmonische osicllator (Pierce)
Figuur 2.6 Principeschema
relaxatie-oscillator
-
+
11

2.2.1 Harmonische oscillator
Omdat we de PZT-sensor bij de resonantiefrequentie willen laten oscilleren, moeten we dus een configuratie
met een harmonische oscillator bekijken. Belangrijke voorwaarden voor harmonische oscillatie
zijn de zogenaamde Barkhausen criteria: In een teruggekoppelde lus waarin een frequentieselecterend
en een versterkend element zit, moet de totale fasedraaiing gelijk zijn aan 0 + 2k (k=0,1....). Verder
moet de modulus van de totale versterking gelijk aan 1 zijn voor stabiele oscillatie.
In de praktijk zal een frequentieselecterend element meestal als eigenschap hebben dat er wat energie
verloren gaat. Om dit tegen te gaan, en de oscillatie in stand te houden, moet de versterker dus wat
energie toevoeren. Het verlies van het element wordt uitgedrukt in de kwaliteitsfactor Q en is omgekeerd
evenredig met de kwaliteit: een element met een hoge Q zal weinig energie verliezen.
2.2.1.1 Complexe Impedantie van de Sensor
Het gedrag van de sensor kunnen we afleiden met behulp van de (complexe) impedantie mits in het
gekozen frequentiedomein het netwerk zich lineair gedraagt. Dat betekent dat rond de oscillatiefrequentie
de versterking niet of weinig varieert. Aan de hand daarvan kunnen we de oscillator instellen
om aan de criteria voor oscillatie te voldoen. Om de impedantie te berekenen moeten we de elektrische
grootheden vinden van het vervangingsschema van de sensor. De resonantie wordt bepaald door de
mechanische en elctrische eigenschappen van de sensor. We kunnen de mechanische grootheden omzetten
naar hun equivalente elektrische grootheden 4 : Trillende massa naar zelfinductie (L 1 ), elasticiteit
van het kristal naar capaciteit (C 1 ), en wrijvingsverliezen naar weerstand (R 1 ). Parallel aan deze drie
grootheden bevindt zich nog een condensator, die de parasitaire capaciteit vormt van de aansluitingen
en het oppervlak van de elektroden.
R S
2.16kΩ
L S
1.586H
PZT Sensor
C 0
5.4nF
Figuur 2.7 Vervangingsschema PZT-sensor
C S
411.7pF
In het bovenstaande vervangingsschema, figuur 2.7, zien we voor de grondtoon een LCR-keten met
parallel daaraan capaciteit C 0 . Het gedrag veroorzaakt door boventonen op de grondtoon, zouden we in
het vervangingsschema kunnen opnemen door parallel aan de LCR-keten, andere LCR-ketens aan te
sluiten. Omdat we ons toch alleen maar willen beperken tot frequenties in de buurt van de grondtoon,
is het niet nodig het vervangingsschema uit te breiden.
De sensor is met een HP network analyzer (HP 8510C) doorgemeten. Na opgave van de configuratie
waarin deze onderdelen in het vervangingsschema staan, heeft deze de waarden van L s , C s , R s en C 0
berekend:
R S =2.16kΩ L S =1.586H C S =411.7pF C 0 =5.4nF
12

Het apparaat meet de serie- en parallelresonantiefrequentie, waaruit het de waarden in het vervangingsschema
kan berekenen. Aanvankelijk lieten we de HP network analyzer over een heel groot
frequentiegebied, tot 1 MHz doormeten, om vervolgens het frequentiegebied te kunnen afbakenen,
waarbinnen in ieder geval de serie- en parallelresonantiefrequentie van de grondtoon lagen. Na een
aantal pogingen lag het meetbereik uiteindelijk tussen 4.8 en 6.8 kHz. Buiten deze frequenties kon er
geen vervangingsschema bepaald worden.
De totale impedantie Z X volgt uit de impedanties van de samenstellende componenten. Naast R S zijn
dat:
Z Ls( ~ ) = j $ ~ $ LS
, met ω de frequentie in rad/s (2.1)
Z ( )
1
Cs ~ = Z ( )
1
C0 ~
j $ ~ $ C
= (2.2)(2.3)
j $ ~ $ C0
S
Uit de voorgaande waarden berekenen we de vervangingsimpedantie Z X van de PZT-sensor, bij een ω
in de buurt van een resonantiefrequentie ω r (binnen het afgebakende meetbereik):
1
4
~ r=
~ 3.9 10
rad
r.
$
LS$ C
s
(2.4)
S
Z X(
~ ) =
1
1
+
1
RS+ Z LS( ~ ) + Z CS( ~ ) Z C0(
~ )
Als we Z X in een grafiek uitzetten tegen ω moeten we, omdat het om een complexe grootheid gaat,
twee functies tekenen. Een voor |Z X | en een voor het argument van Z X .
We tekenen de grafiek in de buurt van ω r zodat we een duidelijk beeld krijgen hoe de impedantie verandert.
13
(2.5)
absZ X (ω)=|Z X (ω)| argZ X (ω)=arg(Z X (ω)) (2.6)(2.7)

absZ x
24
22
20
18
16
14
12
10
50
(in kΩ)
8
60
(in ˚)
6
4
2
0 2 10 4
0
4 10 4
Impedantiecurve Zx
6 10 4
x
8 10 4
(in rad/s)
Figuur 2.8. Verandering impedantie
1 10 5
20
10
0
10
20
30
40
70
80
90
100
1.2 10 5
Uit grafiek 2.8 blijkt dat |Z X | naar oneindig gaat als het 0 rad/s nadert. Hij wordt pas zichtbaar na 1·10 4
rad/s. Hier bedraagt zijn waarde 20 kΩ. Het argument loopt van -90° tot 4.1°.
Ook kunnen we aflezen dat de impedantie van de sensor twee extremen heeft rond de 4·10 4 rad/s. Een
lokaal minimum en een lokaal maximum. We bekijken deze punten wat nauwkeuriger vanaf 3.8·10 4
rad/s tot 4.2·10 4 rad/s, (Figuur 2.9)
absZ x
(in kΩ)
12
11
10
9
8
7
6
5
4
3
2
1
3.7 10 4
0
3.8 10 4
Impedantiecurve Zx
3.9 10
Figuur 2.9. Detail verandering impedantie
4
4 10 4
4.1 10 4
x (in rad/s)
4.2 10 4
20
10
-10
-20
-30
-40
-50
-60
-70
-80
-90
argZ x
0
4.3 10 4
-100
argZ x
(in ˚)
14

De (absolute) impedantie is minimaal bij ω=3.9·10 4 rad/s. Deze is:
4
absZ (3.9 10
rad
X $
s
) . 1.8kX
Dit punt, waar de impedantie minimaal is, noemen we de serie-resonantiefrequentie f s , omdat daar de
frequentiebepalende elementen L s , C s en R s in serie staan.
De impedantie is maximaal bij:
4
absZ (4.09 10
rad
X $
s
) . 11.3kX
Deze frequentie van 4.09·10 4 rad/s (6.50 kHz) noemen we de parallel-resonantiefrequentie f p . We
mogen echter dit alleen zo noemen als de verliezen minimaal zijn. Bij de PZT-sensor zijn die verliezen
groot. R s speelt een grote rol. Dit punt noemen we f n : het punt waarbij de admittantie minimaal is (of
de impedantie maximaal).
Uit de impedantie van dit systeem vinden we ook twee frequenties waar de impedantie zuiver reëel is.
Deze liggen bij 3.96·10 4 rad/s (6.30 kHz) en bij 4.02·10 4 rad/s (6.39 kHz). Deze frequenties noemen
we respectievelijk resonantiefrequentie f r en anti-resonantiefrequentie f a . Tussen f r en f a gedraagt de
sensor zich inductief. Daarbuiten capacitief.
De kwaliteitsfactor Q van de serietak L s , C s en R s bij:
f s =6.2kHz
is gedefinieerd als 4 :
Q
2 fS LS
=
r $ $
R
(2.8)
S
Als we de bekende waarden invullen krijgen we:
Q=28.6
Deze Q waarde is bijzonder laag voor de PZT-sensor. Quartzkristallen, met een vergelijkbaar vervangingsschema,
hebben meestal een waarde die een orde 1000 tot 10000 groter is.
Een lage Q waarde is voor de oscillatorschakeling ongunstig, omdat er veel energie moet worden
toegevoerd om oscillatie op gang te houden. Bovendien gedraagt de sensor zich alleen tussen de frequenties
f r en f a inductief. Dit betekent dat eigenlijk alleen daartussen de sensor een duidelijk werkpunt
kan vinden. Omdat echter f r en f a tamelijk ver uit elkaar liggen, zal de oscillator niet erg stabiel op een
frequentie kunnen werken.
2.2.1.2 Pierce Oscillator
Een veelgebruikte oscillatorschakeling voor quartzkristallen is de Pierce oscillator. Een typische
voorbeeld wordt hieronder gegeven. De oscillator bestaat uit een inverter en het terugkoppelnetwerk
R 1 C 1 X 1 C 2 .
Door de looptijdvertraging in de inverter is het faseverschil tussen het uitgangs- en het ingangssignaal
iets meer dan 180°. Het terugkoppelnetwerk hoeft voor oscillatie niet de volledige 180° faseverschil te
15

geven. Als de inverter ook voldoende versterkt, is aan de Barkhausencriteria voldaan en zal de oscillator
een harmonisch signaal opwekken 5 .
Vaak wordt in de literatuur niet over de looptijdvertraging gesproken en neemt men aan dat de condensater
C 1 een fasedraaiing van -90° geeft, en het kristal (de sensor) samen met C 2 voor de resterende
-90° zorgt. Deze voorstelling is niet correct.
Een typische Pierceschakeling (figuur 2.10) met inverter of nand-poort zien we in de volgende figuur:
Rg
10MΩ
Ri
C2
10nF
U1A
CD4049
X1
PZT-Sensor
C1
10nF
Figuur 2.10. Pierce oscillator
Deze oscillator bevat niet veel onderdelen. Hij wordt veelvuldig gebruikt als klokgenerator voor onder
andere microprocessoren. Een voordeel van deze schakeling is dat de uitgangsamplitude groot is, zodat
er direct een andere CMOS-poort op kan worden aangesloten. Bovendien is de ingangsimpedantie
hoog. Daar staan echter ook een aantal nadelen tegenover zoals de lage versterking en de looptijdvertraging.
Overigens wordt in sommige schakelingen R 1 weggelaten, omdat de uitgangsimpedantie van het IC de
weerstand kan vormen van de R i C 1 integrator.
Om de sensor te kunnen laten oscilleren moeten we de juiste waarden vinden voor de drie overige
componenten. Voor de dimensionering van C 1 , C 2 en R 1 zijn er enkele regels, waaruit blijkt hoe deze
waarden samenhangen 6 . Bij paragraaf 2.2.1.4 gaan we iets dieper in over het verband tussen R 1 , C 1
en C 2 . Overigens wordt de dimensionering meestal overgelaten aan de fabrikant, omdat de sensor (bij
kwartskristallen) maar beperkt belast kan worden. De waarden voor C 1 , C 2 en R 1 hebben immers ook
invloed op de stroom door de sensor.
Omdat de inverter een niet-lineaire versterking heeft, nemen we een R g op, zodat daarmee een geschikt
werkpunt ingesteld kan worden. De grootte van R g hangt af van het type inverter. Voor CMOS wordt
daarvoor geadviseerd een waarde te nemen tussen 22 kΩ en 100 MΩ. We nemen 10 MΩ. Omdat we de
sensor bij een lage frequentie laten oscilleren, speelt de looptijdvertraging maar een heel geringe rol.
Voor R 1 geldt dat als hij te groot is, het signaal teveel verzwakt zal worden. Als hij te klein is, kan het
zijn dat de sensor teveel belast wordt. Uit de berekeningen verderop zal bovendien ook blijken, dat R 1
grote invloed heeft op de totale fasedraaiing van het -netwerk. De voedingsspanning bedraagt hier 5
V.
Voor C 1 en C 2 geldt de vuistregel dat de twee capaciteiten parallel geschakeld, groter moeten zijn dan
twee keer de parasitaire capaciteit in de sensor. Ze mogen echter ook niet te groot zijn, omdat dan het
signaal teveel verzwakt. We proberen voor C 1 en C 2 een capaciteit van 10nF uit.
In de praktijk oscilleert de bovenstaande schakeling uitstekend, echter bij een frequentie van 140kHz.
Kennelijk een boventoon of andere trilmodus. In ieder geval veel hoger dan de bij het vervangingsschema
behorende frequentie van ongeveer 6.3 kHz. De twee capaciteiten experimenteel vergroten of
verkleinen brengt de frequentie niet omlaag.
R1
12kΩ
16

Een mogelijke oorzaak dat de schakeling niet oscilleert op de verwachte frequentie, zou kunnen zijn
dat de belasting van de sensor in het netwerk te groot is door de lage uitgangsimpedantie van de
inverter. Dit kan een probleem vormen voor de sensor, die namelijk bij een te grote belasting invloed
ondervindt van stoorresonanties (activity dips), waardoor de impedantie kan toenemen 7 .
Met weerstand R 1 kunnen we de uitgang van de inverter die een lage en niet-lineaire uitgangsimpedantie
heeft, verhogen. Hierdoor wordt de sensor minder gedempt.
We proberen bovenstaande schakeling opnieuw uit. We nemen voor R 1 een instelbare weerstand, zodat
we kunnen kijken wat voor gevolg dit heeft. Bij vergroten van de weerstand tot zelfs 100 kΩ krijgen
we wel allemaal vreemde oscillaties, maar zeker geen harmonisch signaal in de buurt van de verwachte
frequentie.
2.2.1.3 Overdracht
Om meer inzicht te krijgen in waarom dit circuit niet wil oscilleren op de verwachte frequentie, is het
zinvol de overdracht te berekenen van het netwerk van figuur 2.10. Hierdoor kunnen we controleren
op welke wijze aan de Barkhausen criteria kan worden voldaan. We noemen de instelbare weerstand
van hierboven R 1 .
Om de overdracht te berekenen maken we gebruik van het volgende netwerk (figuur 2.11):
R 1
Z C1
Ingang
C 1
0
C0 5.4n
PZT Sensor
Z C2
Z x
Rs 2.16k
Ls 1.586
Cs 411.7p
0
Figuur 2.11. Netwerk met sensor
C 2
Uitgang
We bekijken hoe groot de overdracht is bij de genomen waarden van C 1 en C 2 van 10nF en een R 1 van
12 kΩ uit de vorige Pierce-schakeling.
er geldt:
C 1 =10nF C 2 =10nF R 1 =12kΩ
Z ( )
1
C1 ~ = en Z ( )
1
C2 ~
j $ ~ $ C
= (2.9)(2.10)
1
j $ ~ $ C2
17

De totale vervangingsimpedantie van het netwerk onder weerstand R1 is dan:
Z ( )
1
V ~ =
(2.11)
1
1
Z C1( ~ )
+
Z X( ~ ) + Z C2(
~ )
Vervolgens berekenen we de overdracht H(ω), die per definitie gelijk is aan de ingangsspanning gedeeld
door de uitgangsspanning.
H( ~ ) =
1
$
1
1
R1
Z X
+
( ~ )
Z ( ) 1
V ~ +
Z C2(
~ )
(2.12)
In de buurt van de resonantiefrequentie ziet de overdrachtsfunctie (figuur 2.12) er als volgt uit:
absH
0.09
0.085
0.08
0.075
0.07
0.065
0.06
0.055
0.05
0.045
0.04
0.035
0.03
3.8 10 4
3.9 10 4
4 10 4
(in rad/s)
C 1 =10nF
C 2 =10nF
R1 =12kΩ
4.1 10 4
Figuur 2.12. overdracht sensor in de Pierceschakeling
80
85
90
95
100
105
110
115
120
125
130
135
4.2 10 4
140
We zien duidelijk dat bij 10 nF er niet voldoende fasedraaiing is om aan een Barkhausencriterium
te voldoen. We vergroten C 1 en C 2 om meer in de buurt van de 180° te komen. We nemen -enigszins
experimenteel- de volgende waarden: C 1 =0.33μF, C 2 =68nF, R 1 =4.7kΩ.
argH
(in ˚)
18

Hieruit volgt de volgende overdrachtscurve (figuur 2.13):
absH
0.003
0.0025
0.002
0.0015
0.001
0.0005
0
3.8 10 4
3.9 10 4
4 10 4
(in rad/s)
C 1 =330nF
C 2 =68nF
R 1 =4.7kΩ
4.1 10 4
Figuur 2.13. overdracht sensor in de Pierceschakeling met andere componenten
4.2 10 4
Uit de grafiek blijkt dat met de grotere waarden voor C 1 en C 2 , we nu veel meer fasedraaiing kunnen
krijgen. Deze is op zijn grootst 177°. De versterking is door de grotere condensatoren wel flink afgenomen.
Bij het punt waar de fasedraaiing het grootst is, blijft er ongeveer nog maar 1/1000 deel van
het oorspronkelijke signaal over. In de vorige situatie was dat 1/20 deel.
Ook met de nieuwe waarden krijgen we de CMOS-inverter niet aan het oscilleren in de buurt van de 6
kHz. De versterking kunnen we echter niet genoeg beïnvloeden.
Omdat bovendien het meten aan de schakeling een steeds groter probleem wordt vanwege de belasting
van de meetpennen, vervangen we de CMOS-inverter door twee op-amps. We kunnen een op-amp als
spanningsvolger/versterker schakelen, waardoor die een veel hogere ingangsimpedantie krijgt. Immers
weerstand R g is niet meer nodig. De andere op-amp moet dan het signaal in ieder geval inverteren en
eventueel ook versterken. We laten onze keuze vallen op een TL084. Dit is een veel voorkomende opamp,
zonder spannende eigenschappen.
2.2.1.4 Berekening van R 1 , C 1 en C 2
We hebben gezien dat C 1 en C 2 veel invloed hebben op de overdracht van het netwerk. Dit verband is
iets eenvoudiger te begrijpen als we de impedantie van de sensor bij de resonantiefrequentie als zuiver
reëel beschouwen. We nemen daarvoor het volgende schema (figuur 2.14)
80
90
100
110
120
130
140
150
160
170
180
argH
(in ˚)
19

De overdracht H(ω) is dan:
R1
R2
C1 C2
Figuur 2.14. Overdracht met reële R2
H( ~ ) =
1
$
1
j $ ~ $ C 1 + j $ ~ $ R $ C
1 + R 1$ (j $ ~ $ C1+ )
1 + j $ ~ $ R2$ C2
2 2 2
[ 2 2 1 1 2 2 1 2]
= 1/ 1 + j $ ~ $ R $ C + j $ ~ $ R $ C $ _1 + j $ ~ $ R $ C i + j $ ~ $ R $ C
=
1
2
1 - ~ $ R1$ R2$ C1$ C2+ j $ ~ $ (R2$ C2+ R1$ C1+ R1$ C 2)
De tangens van het argument van H(ω) is dan:
- ~ $ (R2$ C2+ R1$ C1+ R1$ C 2)
tan(arg(H( ~ )) =
2
1 - ~ $ R1$ R2$ C1$ C2
Bij de juiste instelling is ω 2 R 1 R 2 C 1 C 2 >>1, waardoor we dit mogen vereenvoudigen tot:
20
(2.13)
R2 C2 R1 C1 R1 C2
.
$ + $ + $
(2.14)
~ $ R1$ R2$ C1$ C2
Volgens het Barkhausencriterium moet de fasedraaiing 180° zijn. Omdat de teller ongelijk aan nul is,
is deze fasedraaiing mogelijk als de noemer van het argument van H(ω) naar oneindig gaat. We zien
dat hoe groter C 1 en C 2 worden des te dichter komt de fasedraaiing in de buurt van de 180°.
In de praktijk is deze afleiding voor R 1 , C 1 en C 2 meestal niet houdbaar, omdat de versterker in de Pierceoscillator
bij zijn werkpunt niet zuiver reëel is. Bovendien kunnen we uit het bovenstaande niet een
eenduidige bepaling voor R 1 , C 1 en C 2 vinden. Een betere manier om uit het Barkhausencriterium de
waarden voor R 1 , C 1 en C 2 te bepalen is als we het criterium volgens de definitie gaan toepassen. Daaruit
volgt dat de (complexe) versterking A van het versterkend element gelijk moet zijn aan 1/H(ω):
(Zie voor H(ω) vergelijking 12 en figuur 2.11.)
A =
1 (2.15)
H( ~ )
We gaan uit van een bepaalde, door de fabrikant gespecificeerde waarde voor de fasedraaiing van A.
Vaak kunnen we uit een grafiek of tabel aflezen hoeveel de fasedraaiing φ bij een bepaalde frequentie
ω is. Voor de absolute versterking |A| kunnen we binnen bepaalde grenzen zelf een waarde te kiezen.
Er geldt:
1
(1
H( ) Z Z )(1
Z R X
1 )
~ C2
V
= + + , met 1
Z Z 1
= +
1
Z +
Z
V C1 X C2

(1
Z Z X
= + )(1 + R (
1 1
1
))
C2 Z
+
C1 ZX+ Z
(2.16)
C2
Zodat we kunnen schrijven:
jc2
A = (1 + jZXc 2)(1 + R 1(jc1+ )) , met c =ωC , c =ωC
1 + jZXc 1 1 2 2
2
(1 jZ c )(1
R1
= + X 2 + (jc1 jc2 ZXc1c 2))
1 jZXc + -
+ 2
= (1 + jZXc2+ jR 1(c1+ c 2) - ZXR1c 1c 2))
(2.17)
Voor het voldoen aan de Barkhausencriteria moet deze uitdrukking gelijk zijn aan de complexe versterking
A=A r +jA i .(met behulp van Euler |A|e jφ ). We vervangen Z X door de complexe vorm Z Xr + jZ Xi .
Voor het reële deel van de versterking krijgen we:
Ar= 1 - ZXic2- ZXrR1c 1c2 (2.18)
en voor het imaginaire deel:
Ai= ZXrc2+ R1c1+ R1c2- ZXiR1c1c 2
(2.19)
A r is bekend dus vinden we voor c 2 :
c
1 Ar
2=
-
ZXi+ ZXrR1c 1
c 2 ingevuld in vergelijking (19) levert ons op:
Ai= c 2(ZXr+ R1- ZXiR1c 1) + R1c1 1 Ar
=
- (ZXr R1 ZXiR1c 1) R1c1 ZXi+ ZXrR1c + - +
1
&
(Ai- R1c 1)(Z Xi+ ZXrR1c 1) = (1 - A r)(Z Xr+ R1- ZXiR1c 1)
21
(2.20)
2 2
& c 1 (ZXrR 1 ) + c 1(ArZXi- AiZ Xr)R 1+ (1 - A r)(Z Xr+ R 1) - AiZXi= 0
(2.21)
In deze kwadratische vergelijking zijn we geïnteresseerd in één oplossing. Voor de discriminant D
geldt dan:
2
2
D = R 1 7(ArZXi- AiZ Xr)
- 4Z Xr((1 - A r)(Z Xr+ R 1) - AiZ Xi)
A = 0
(2.22)
Voor R 1 vinden we:
2
(ArZXi- AiZ Xr)
+ 4A Z Z
R1=
4(1 - A r)Z Xr
i Xr Xi
- ZXr
(2.23)
R 1 ingevuld in de kwadratische vergelijking geeft ons de oplossing van c 1 :

c
A Z A Z
1=
-
2
2ZXrR1 i Xr r Xi
De waarden voor C 1 en C 2 verkrijgen we tenslotte door c 1 en c 2 te delen door ω.
22
(2.24)
2.2.1.5 Wijzigingen Pierce en Simulatie
Naar aanleiding van de constateringen uit het vorige deel, hebben we onze schakeling veranderd. We
proberen onderstaand schema. Weerstand R 8 dient ervoor om de ingang van de op-amp op een gedefinieerd
niveau te brengen. De versterking stellen we in met weerstand R 6 /R 7 en R 2 /R 3 . Met de in de
schakeling gegeven waarden bedraagt deze ongeveer 1000 keer.
C4
47n
R8
100MEG
3
2
TL084
R6
470
0
U1A
+
-
R7
0
4
11
220k
V+
V2
12V
V- OUT
V1
12V
1
R1
2.16k
R2
4.7k
C1
.4117n
C2
5.4n
0
6
L1
TL084
Fig. 2.15 Schema Pierce oscillator
We voeren de schakeling (figuur 2.15) in Orcad in en laten er met PSpice AD een ‘tijddomein’-simulatie
op los (figuur 2.16). Hieruit blijkt dat de schakeling in de buurt van de berekende frequentie oscilleert:
6.0 kHz. De schakeling start omdat er ruis op het circuit staat. Het valt ook op dat de oscillator
tijd nodig heeft om op gang te komen. Dit komt doordat er steeds maar weinig energie toegevoerd kan
worden aan het netwerk, dat namelijk een hoge impedantie heeft. Vanwege de niet-lineaire versterking
van de op-amps, bij grotere signalen neemt deze af, vindt het circuit een werkpunt waarbij de totale
versterking gelijk aan 1 wordt. De amplitude verandert na dit startverschijnsel niet meer.
5
1.586
0
U1B
+
-
0
R3
10k
4
11
V+
V4
12V
V- OUT
V3
12V
7
R5
6.8k
R4
4.7k
C3
330n

Fig. 2.16 PSpice simulatie startverschijnsel
Van de curve lichten we een deel uit, om inzicht te krijgen in de faseverschuiving die de componenten
in het netwerk veroorzaken. We bekijken drie punten in de schakeling: het signaal dat aangeboden
wordt op de ingang van de eerste op-amp, pin 3 (In de grafiek is dit signaal vergroot weergegeven), het
versterkte signaal dat uit deze op-amp komt, pin 1 en het signaal dat uit de inverterende op-amp komt,
pin 7. In de curve valt met name op dat het signaal van pin 1 achter loopt op dat van pin 3. Dit komt
ons van pas. Uit de overdracht bleek namelijk dat het -netwerk niet 180° kon halen. Uit de simulatie
blijkt dat bij 6.0 kHz faseverschuiving van de op-amps 9.7 µs is. (omgerekend naar de periode is dit
bijna 180°-22°=158°). De faseverschuiving wordt kennelijk veroorzaakt door de grote versterking van
468 keer. Dit blijkt des te meer als we de (absolute) versterking van de twee op-amps verwisselen,
zodat de tweede op-amp een heel grote (inverterende) versterking gaat krijgen. In dat geval treedt de
faseverschuiving op in de tweede op-amp.
Fig. 2.17 Faseverschuiving bij de TL084 PSpice Simulatie
In de praktijk funktioneert de schakeling zoals we uit de berekeningen zouden verwachten. De faseverschuiving
(figuur 2.17) in de op-amps is echter iets meer dan uit de simulatie: 180°-30°=150°. Om
toch, wat betreft de faseverschuiving, aan het Barkhausencriterium te voldoen, zal daardoor de oscillatiefrequentie
omlaag gaan naar 5.3 kHz (figuur 2.20. Bij die frequentie komt de faseverschuiving van
de overdrachtscurve van het -netwerk verder van de 180° af te liggen. Een grafiek uit de datasheet
(figuur 2.18) van de TL084 waarin de open-lus versterking staat afgebeeld en een PSpice AC-analyse
(figuur 2.19) is hiermee ook in overeenstemming:
23

Fig. 2.18 Open-lus versterking TL084
Versterking
|A| (in Vuit/Vin)
1000
900
800
700
Gemeten faseverschuiving
16µs
0 5*10 3
Fig. 2.20 Gemeten faseverschuiving: 30° bij 5.3 kHz
2.2.1.6 Metingen bij de resonantiefrequentie
Versterking vs. Frequentie TL084 (PSpice simulatie )
Frequentie (in Hz)
|A|
φ
10*10 3
180
170
160
150
140
Fig. 2.19. Inverterende versterker, ingesteld op 1000 keer
Nu we met de sensor in de buurt van de resonantiefrequentie kracht kunnen meten, moeten we controleren
of inderdaad de frequentie afneemt bij de belasting, zoals eerder beweerd is. We leggen de
sensor op een vlakke ondergrond, meten de frequentieverandering als er kracht op de sensor wordt
uitgeoefend. We meten onbelast een frequentie van 5.3 kHz. Belasten we de sensor met een kracht
van ongeveer 50mN, loopt de frequentie op naar 5.4 kHz. Als we vervolgens de kracht nog meer laten
toenemen, tot 4 N, verandert de frequentie niet. Een nog grotere kracht zorgt ervoor dat de sensor ophoudt
met resoneren, omdat hij dan teveel gedempt wordt. Het valt ook op dat tijdens het aanbrengen
van een kracht de frequentie verandert met de mate waarmee de kracht verandert. Dit effect is echter
van korte duur, omdat de frequentie nadat de kracht niet meer verandert, weer terugloopt naar 5.4 kHz.
Blijkbaar verandert de frequentie kortdurig, maar valt direct daarna terug naar de beginwaarde. Omdat
bovendien de Q-faktor erg laag is van de sensor, betekent dit dat hij niet erg stabiel op een bepaalde
frequentie zal oscilleren. Samen met het voorgaande concluderen we dat deze schakeling ongeschikt is
om nauwkeurig de resonantiefrequentie te meten.
2.2.1.7 Serieresonantie
Naast de Pierce oscillator, zijn er verschillende andere typen schakelingen bekeken, waaronder een
schakeling om de sensor bij serieresonantie te laten oscilleren 8 . Zie figuur 2.21. Deze schakeling be-
Fase
φ (in °)
24

stond uit twee in serie geschakelde inverters, met daarop de sensor aangesloten.
U1A U2A
C1
R1 R2
Figuur 2.21. Basisschakeling serieresonantie
De sensor zal, afhankelijk van de totale versterking en de faseverschuiving in de lus, ergens oscilleren
tussen twee karakteristieke punten: de frequentie waarbij de impedantie het laagst is en de frequentie
waarbij de faseverschuiving 0 is, respectievelijk f s en f r .
Zoals eerder genoemd in paragraaf 2.2.1.2 nemen we voor R1 en R2 een waarde tussen 100 kΩ en 22
MΩ. Tegen de verwachting in komt de frequentie van de sensor bij die waarden niet in de buurt van
de resonantiefrequentie. Uit de volgende tabel (tabel 2.1) blijkt welk verband er tussen R1 (=R2) en de
frequentie bestaat:
X1
R1 (in Ω) f (in Hz)
16.3·10 3 4.0·10 3
21.0·10 3 3.3·10 3
68.0·10 3 1.0·10 3
380·10 3 760
1.0·10 6 73
Tabel 2.1. Frequenties bij verschillende
terugkoppelweerstanden. (V DD =6V)
Uit de tabel blijkt dat de basisschakeling bij de gegeven weerstandswaarden en de daarna gemeten
resonantiefrequentie niet functioneert als serieresonantieoscillator. De reden dat de oscillator niet aan
de verwachtingen voldoet, is dat vanwege de lage Q-factor, de CMOS-poort teveel moet versterken.
Wel valt ons op dat de frequentie van de oscillator in deze schakeling bij alle waarden van R1 (en
R2) beïnvloed kan worden door het aanbrengen van een kracht. Bij lage weerstandswaarden voor R1
gedraagt de schakeling zich meer als een relaxatie-oscillator. Ongeacht de richting van de krachtuitoefening
neemt de frequentie toe. Hiermee kunnen dus statische krachten gemeten worden.
2.3 Relaxatie-oscillator
Relaxatie-oscillatoren worden steeds vaker gebruikt bij sensorsystemen, omdat veranderingen van het
sensorsignaal doorwerken in een verandering van de periode, die meestal eenvoudig te meten valt 9 .
Bij relaxatie-oscillatoren wordt er steeds omgeschakeld tussen twee (a-stabiele) toestanden, waarvan
de periode vooral bepaald wordt door de weerstand R en de sensor, hier opgenomen als condensator
C. Daarnaast spelen ook nog eigenschappen van de inverter-IC’s een rol, zoals de spanning waarbij de
inverters van logisch niveau wisselen en bij hoge frequenties de vertragingstijd.
25

R
“C”
INV1 INV2
Figuur 2.22. Relaxatie-oscillator
Het schema van een relaxatie-oscillator vinden we in figuur 2.22. De voedingsspanning U DD van de
NAND-poort, een CD4011, bedraagt 6.0 V. We hebben gemeten dat het omschakelpunt U s bij 59% van
de voedingsspanning U DD ligt.
Via weerstand R wordt de condensator steeds opgeladen en ontladen. Van toestand wisselt hij als de
spanning op de ingang van de NAND-poort gelijk wordt aan U s . De spanning die direct na het wisselen
op de condensator staat, is dan:
• Tijdens het laden: U s -U DD
• Tijdens het ontladen: U s +U DD
Hieruit kunnen we de vergelijkingen voor de duur van het laden en ontladen afleiden:
T ln
2 UDD US
1 $
$
=
UDD- US
-
x c m T ln
US UDD
2=
x $ c + m T=T +T (2.25)
U
1 2
S
Als we de volgende waarden nemen:
R=68kΩ C=5.4nF τ=RC
U DD =6.0V U S =0.59U DD
Is de periode gelijk aan:
T=8.2·10 4 s (of f=1.2·10 3 Hz)
In het schema waar deze oscillator deel van uitmaakt (figuur 3.7), vervangen we overigens de weerstand
R door een vaste en een regelbare weerstand in serie, zodat de frequentie niet te hoog kan worden
voor de microcontroller.
2.3.1 Capaciteitsverandering ten gevolge van druk
We meten het signaal, weergegeven in figuur 2.23, dat op de ingang van de NAND-poort staat, als we
de sensor in de schakeling van figuur 2.22 gebruiken. Behalve dat de sensor grote invloed heeft op de
oscillatiefrequentie, ondervindt de sensor ook invloed van het oscillatiesignaal zelf. Het signaal tussen
de aansluitpunten van de sensor zorgt ervoor dat de sensor steeds afwisselend op en neer beweegt.
Als we de sensor niet afdempen, maar vrij laten bewegen, zien we bovenop het signaal nog een soort
tweede-orde effect gesuperponeerd. De frequentie hiervan komt ongeveer overeen met de resonantiefrequentie
van de sensor.
26

Figuur 2.23. Gemeten golfvorm oscillator, zonder demping
Als we vervolgens de sensor gaan belasten, zie figuur 2.24, verdwijnt door de demping dit effect.
Figuur 2.24. Gemeten golfvorm oscillator, sensor wordt gedemp
Bovendien wordt de frequentie hoger. Deze frequentieverandering is anders dan in de configuratie
bij de Pierceoscillator. Bij de relaxatie-oscillator bestaat er namelijk een verband tussen de frequentie
en de kracht die op de sensor wordt uitgeoefend. Blijkbaar is de sensor wel degelijk te gebruiken om
ook een statische kracht te meten. We vermoeden dat de kracht samenhangt met de capaciteit C 0 in het
elektrisch vervangingsschema.
Als we een kracht uitoefen op de sensor, neemt de capaciteit alsmede de periode (zie formule 25),
maximaal af met ongeveer 10%. Zie grafiek 3.1 voor een grafiek waaruit de samenhang zichtbaar is
tussen de kracht en de frequentie. Boven een kracht van ongeveer 25N, verandert de capaciteit niet
meer. We merken overigens niet dat het kristal door deze kracht samendrukbaar zou zijn, immers ondanks
dat de platen ten gevolge van de (druk)kracht dichter bij elkaar zouden moeten komen, neemt de
capaciteit toch af.
27

2.3.2 Meetcircuit
Het volledige meetcircuit zien we in figuur 2.25. De relaxatie-oscillator wordt gevormd door R1 en R2
in serie en de capaciteit van X2. Via weerstand R3 aan de ingang van U1A kunnen we de sensor in een
begintoestand zetten. Transistor Q2 die aan de uitgang van U1B zit vormt de interface met de logica
van de microcontroller. De microcontroller heeft een interne pull-up. We kunnen de uitgang van U1B
niet direct met de ingang van de microcontroller verbinden, omdat de voedingsspanning van het meetcircuit
lager dan 5 V is en de microcontroller 5 V nodig heeft.
Met weerstand R2 kunnen we de frequentie bijregelen waarop de sensor oscilleert.
R5
12k
Vadj.
Q1
BC558C
D1
D1N4148
R3
3k3
1
2
Vadj.
GND
R1
50k
X2
Piezo Cry stal
U1A
CD4011A
R2
Figuur 2.25. Meetcircuit
3
82k
5
6
U1B
CD4011A
De voedingsspanning van het meetcircuit is instelbaar gemaakt, om de amplitude van het signaal in
de relaxatie-oscillator te kunnen regelen. Bij 5 V voedingsspanning is het signaal dat van de sensor
afkomstig is erg goed hoorbaar. Dit willen liever niet en kunnen we zachter krijgen door de spanning
te verlagen. Bij 3.5 V werkt de sensor nog erg goed, en is het geluid dat de sensor produceert al aanzienlijk
zachter.
De voedingsspanningen (figuur 2.26) van 5 V en 3.5 V worden door een 5-volts stabilisator (7805) en
transistor Q3 (BC547) geregeld.
Vin
C4
10u
1
U9
LM78L05A/TO39
VIN
GND
3
VOUT
GND GND
GND
2
Figuur 2.26. Spanningsstabilisatie
4
R4
10k
+5v
Q3
BC547A
Vadj.
C5
10u
R7
1k
R8
4k7
GND GND
C6
1uF
Q2
BC548B
GND
28

3. Data-acquisitie en –verwerking
Om te begrijpen hoe de data-acquisitie plaatsvindt, maken we een iets eenvoudiger voorstelling van de
processen die zich hierbij afspelen. Voor de beschrijving maken we gebruik van het schema van figuur
3.7. De data-acquisitie bestaat in principe uit een bepaling van de lengte van het periodieke signaal
afkomstig van de relaxatie-oscillator. De microcontroller, een AT89C2051, krijgt dit signaal aangeboden
op zijn interrupt-ingang /INT1. Als er op die ingang een transitie plaatsvindt van een hoog naar
laag niveau 10 , wordt een interrupt routine uitgevoerd die de timerwaarden verwerkt. Zo kan de microcontroller
bepalen hoe groot de lengte van het periodieke signaal van de sensor is. De microcontroller
rekent deze tijd om naar een waarde die de kracht op de sensor voorstelt. Tenslotte zet hij 1 op de 10
keer deze waarde conform de MIDI-standaard als een ‘aftertouch control’ op de seriële uitgang. Hierna
kan de cyclus opnieuw beginnen.
De reden dat zowel /INT0 als /INT1 zijn aangesloten op dezelfde lijn, is dat we handig gebruik maken
van de mogelijkheid via maskering van een van de interrupts /INT0 of /INT1 te bepalen waarheen
de interrupt vector zal springen. Afhankelijk van de instelling zal er dan gesprongen worden naar de
“calibration” of “measuring”). We kunnen op deze wijze een instructie uitsparen die anders nodig was
geweest om te bepalen waarheen gesprongen zou moeten worden.
De dataverwerking vindt in de microcontroller steeds plaats gedurende een halve periode van de
cyclus. Op dat moment is de timer ingesteld op ongeveer 1.3 ms. In die tijd kan de microcontroller
ongeveer 650 instructies van 2 machinecycles afwerken. Tijdens de verwerking worden de volgende
opdrachten uitgevoerd:
• Tel de de gevonden meetwaarde bij de vorige op.
• Ieder tiende keer wordt van de cumulatieve meetwaarde een gemiddelde berekend, gelijk aan de
som gedeeld door het aantal meetwaarden. Deze waarde wordt omgezet naar een waarde tussen
0 en 255. Vervolgens wordt deze waarde uit een linearisatietabel omgerekend naar een waarde
tussen 0 en 127. Om de transmissie van mididata efficiënter te laten verlopen sturen we deze
waarde alleen als er een verandering is opgetreden ten opzichte van de vorige. Zo worden er niet
onnodig gegevens overgestuurd.
3.1 Microcontroller
Oorspronkelijk hadden we de schakeling opgebouwd en getest met een 8031. De keuze voor deze controller
hadden we genomen omdat we beschikten over een uitgebreide ontwikkelomgeving daarvoor.
Daarnaast hadden we veel ervaring met de MCS ® 51 familie. De ontwikkelomgeving bestond uit een
eprom-emulator, een PC speciaal ingericht met software (asem51) om de sourcecode te assembleren,
een experimenteerprint gebaseerd op de 8031, een monitorprogramma om de software te debuggen en
een ‘Mini Flash Programmer’, die al in oktober 1996 in het tijdschrift Elektuur gestaan heeft, om een
Atmel AT89C2051 te kunnen programmeren.
We hebben verschillende instellingen in de software getest, gebruikmakend van de ontwikkelomgeving.
Nadat het systeem naar behoren werkte, konden we de software in de veel kleinere microcontroller
van Atmel, de AT89C2051, programmeren. Omdat deze op een aantal externe porten na geheel
compatibel was met de 8031, hoefden we niets aan de software te veranderen. Daarnaast had de
AT89C2051 2KB aan programmeerbare Flash geheugen aan boord, waardoor het externe geheugen en
de latch, zoals die bij de 8031 noodzakelijk waren, konden worden weggelaten.
29

3.1.1 Gestuurde oscillatie
Zonder kracht op de sensor en zonder dat de oscillator aan de ingang belast wordt, genereert de relaxatie-oscillator
tijdens het opstarten een frequentie van ongeveer 370 Hz (of periode is 2.7ms). Deze
wordt door de microcontroller gemeten door gebruik te maken van een hardware-interrupt en een
timer. De hardware-interrupt is zo ingesteld dat hij op een neergaande flank van het signaal reageert.
Weliswaar is de flank aan de uitgang van de sensor op het moment dat we willen meten van laag naar
hoog, maar omdat deze via een transistor loopt die de interruptingang van de microcontroller naar
beneden trekt, krijgen we in de microcontroller een flank van hoog naar laag. Dankzij een hardwareinterrupt
kan de microcontroller, afhankelijk van de instructie waar hij op dat moment nog mee bezig
zou kunnen zijn, binnen 24 klokcycli reageren. Bij een klokfrequentie van 12 MHz is dit 2 μs. Als gevolg
hiervan kan de gemeten frequentie van de sensor met ongeveer +0.28 Hz (2.7ms + 2μs) afwijken.
Na de frequentie bepaald te hebben zonder kracht op de sensor, is de microcontroller gecalibreerd. De
volgende stap in de software is een speciale (interrupt-)procedure starten die met (een frequentie die
iets hoger ligt dan) de gemeten frequentie, de sensor aanstuurt. We kunnen de frequentie beïnvloeden,
door voordat de periode afgelopen zou zijn, de sensor steeds terug te zetten in een uitgangspositie. Dit
geschiedt via het kort sturen van transistor Q1 die ervoor zorgt dat beide aansluitingen van de sensor
op hetzelfde spanningsniveau komen. Door het gering verhogen van de frequentie kunnen we ongewenste
flanken voorkomen, die aan het eind van de periode door storingen zich kunnen manifesteren,
immers dan ligt de ingangsspanning op de NAND-poort van de sensor in de buurt van het omschakelpunt
U s . Storende flanken zijn ongewenst, omdat deze kunnen leiden tot een interrupt die op een
verkeerd moment een meetwaarde gaat vastleggen. Een ander voordeel van deze aansturing is dat
ervoor gezorgd wordt dat de sensor steeds vanuit een gedefinieerde uitgangspositie zijn ‘periode’ begint,
doordat de sensor steeds heel even op een vaste spanning wordt gebracht. De interruptprocedure
kent drie fasen, in figuur 3.1 Part I,II en III genaamd. De hierbovengenoemde aansturing van de sensor
gebeurt gedurende Part I, waarna de verwerking van de meetgegevens, en het registreren van nieuwe
gedurende Part II en III gebeurt. (Zie figuur 3.3 voor details)
Hi-state
(Microcontroller
output port)
Lo-state
Part I Part II Part III
Sensor oscillator circuitry is
connected to an open collector.
Which means when wvmem (or
sensctrl) is hi, it is free to make
a transition, depending on
applied force.
Duration: lo_Tx hi_Tx hivdTx0
Flag:
wvmem
vldsens
0
0
1
0
1
1
Sensor interrupt driven control-timing diagram Fig. 3.1 onderverdeling periode
De PZT-sensor buigt afhankelijk van de aangelegde spanning of naar beneden of naar boven door.
(figuur 3.2) De doorbuiging bij Part I en II is in dezelfde richting. Bij Part III is deze in de andere richting.
Voor een goede werking maakt het overigens niet welke richting het eerst komt.
Figuur 3.2 Doorbuiging PZT-sensor
30

De aansturing van de sensor bij Part I duurt ongeveer 35μs. Deze tijd is voldoende om storingen te
voorkomen en de sensor niet teveel te hinderen bij zijn mechanische beweging. Bij Part II en III neemt
de relaxatie-oscillator de ‘sturing’ van de sensor over. De interrupt die door de uitgang van de oscillator
op de microcontroller wordt aangeboden, wordt alleen bij Part III toegelaten.
Een stroomdiagram van de gehele procedure die de aansturing van de sensor beschrijft, staat in figuur
3.3
631
633
636
637
Part I
clr TR0
test vldsns
wvmem
wvmem
Clear flag
608 wvmem
Set flag
598
Clear output port
sensctrl ti_hins:
Set output port
sensctrl
vldsens
lo_Tx->Timer0
setb TR0
clr EX1
wvmem=1
vldsens=1
117
593
wavectrl:
Load Timer0 with
counter values for part I.
Start Timer0
Do not allow
int1 during
part I.
Return from
293 lo_Tx->Timer0
296 setb TR0
Timer0 IRQ vector points here:
Part II
610
613
np_flag=1
616
624
R3!=0
625
626
hi_Tx->Timer0
setb TR0
wvmem=0
vldsens=0
test np_flag
np_flag=0
OP_x+= tmp_TH0
tmp_TL0
R3--, test R3
setb np_flag
reti interrupt
reti interrupt
reti
Figuur 3.3 Stroomdiagram sensor stuurprocedure
Timer0 runs untill TR0 is cleared.
Timer0 counts machine cycles (1/12 Clk)
Overflow causes TF0 to become high, which
is vectored to 000Bh. 'Zig-zag' means further
processing is done through an interrupt vector.
Stop Timer0
Load Timer0 with
counter values for part II.
Start Timer0
599
If main is still processing 601
data which was captured
here, it is better not to interfere.
So just exit interrupt
Add captured sensor data to
the 24 bits counter
Track number of captured
data. Test if we have enough
Send message to main to
indicate processing is
needed
Return from
604
606
Part III
wvmem=1
vldsens=0
hivdTx0->Timer0
setb TR0
tmp_TH0=0FFh
tmp_TL0=0FFh
clr IE0
setb EX1
Allow sensor to
produce valid
signal
Load Timer0 with
counter values for
part III.
Start Timer0
Preload tmp_Tx0
with the maximum
value. If during
this cycle the sensor
does not produce
an interrupt, we
will have a value
anyway
Software reset for
interrupt flag. (Because
EX1 is still
disabled)
Allow external
interrupt EX1.
So wait for an interrupt
from sensor,
which is vectored
to 0013h.
Return from
interrupt
31

Twee interrupts hebben invloed op het verloop van de procedure. Timer 0 gebruiken we om te bepalen
hoe lang Part I, II en III duren. De timer is geconfigureerd als een 16-bits teller die 1/12 van de
systeemklok, machinecycles genaamd, telt. Tijdens het calibreren worden er voor het telregister drie
verschillende beginwaarden berekend in calc_t0. Deze waarden worden in het stroomdiagram gebruikt
in de drie verticale takken. De tijd dat iedere tak in beslag neemt is hiermee vastgelegd. Omdat deze
waarden snel oproepbaar moeten zijn, worden ze in het geheugen opgeslagen. Een interrupt door de
timer treedt op wanneer alle bits van het telregister van 1 naar 0 verspringen en veroorzaakt een sprong
naar de routine wavectrl. Daar wordt het telregister van timer 0 geladen met de beginwaarden voor het
volgende deel. Na Part III volgt weer Part I, zodat we daarmee een cyclus hebben.
De sensor is verbonden met interrupt /INT1. Deze leidt naar de routine sens_stamp, van waaruit de
waarde die timer 0 op dat moment heeft, wordt opgeslagen.
3.1.2.1 Omzetting naar midi
Voor de omzetting van kracht naar een midi-conform signaal, moeten we de gemeten waarden zo
converteren dat daar een waarde uitkomt dat geschikt is om via midi te versturen. Voor midi-controllerdata
is vastgelegd dat deze een 7-bits getal moeten zijn. (0 tot en met 127). Om een goed beeld van
het krachtverloop te krijgen, ligt het voor de hand om de gemeten waarden zodanig om te zetten dat er
een lineair verband bestaat tussen de uitgeoefende kracht en de waarde die het in midi voorstelt.
Voor deze omzetting worden een aantal stappen doorlopen. We beginnen bij het moment dat er een
meting van de sensor gedaan wordt. Als er een interrupt van de sensor optreedt, moeten we zo vlug
mogelijk de waarde van het telregister opslaan, omdat de timer doorloopt. Om dit mogelijk te maken
wordt na een interrupt als eerste de timer stopgezet om te voorkomen dat het telregister verandert. Vervolgens
wordt de routine sens_stamp uitgevoerd die het telregister tijdelijk kopieert naar het 16-bits
register tmp_T0, waarna timer 0 weer kan doorlopen en de interruptroutine verlaten kan worden.
De verdere dataverwerking van tmp_T0 geschiedt in de interruptroutine wavectrl, tijdens de fase
Part II. De keuze om de verwerking op een andere plaats uit te voeren dan bij sens_stamp, is dat we
tijdens Part II voldoende tijd hebben om de verwerking van tmp_T0 te doen. Timer 0 kan daar ondertussen
tijdens het verwerken namelijk al lopen; immers een interrupt afkomstig van timer 0 hoefden
we de eerste 650 instructies niet te verwachten. De verwerking tijdens Part II van tmp_T0 bestaat uit
het volgende: We tellen de waarden van tmp_T0 cumulatief op in een 24 bits register (OP_1..OP_3).
Nadat we uiteindelijk Part II num_per keer doorlopen hebben, of anders gezegd na num_per perioden
hebben we het gewenste aantal metingen gedaan en maken we vanuit wavectrl de flag np_flag
actief. Deze vlag deelt aan de hoofdlus van het programma mee dat de meetwaarden klaar zijn voor
verdere verwerking. Na het verlaten van de interruptroutine zal in de hoofdlus deze melding worden
opgemerkt.
In de hoofdlus geschiedt de verdere verwerking in convert. We berekenen een gemiddelde van de
meetwaarden. We moeten hiervoor 0xffff (=65535) aftrekken van de meetwaarde. Namelijk als er geen
kracht op de sensor wordt uitgeoefend zou deze flank optreden net iets later dan de periode van de
timer. Zie figuur 3.4. Bij het ontbreken van een kracht wordt er geen interrupt gegenereerd, omdat de
sturing dan alweer aan een volgende periode is begonnen. De sensor krijgt net niet de gelegenheid om
‘uit zichzelf’ van richting te veranderen. Aangezien tmp_T0 door het ontbreken van de interrupt niet
overschreven is en de software tmp_T0 geinitialiseerd had met 0xffff, krijgen we door de aftrekking
bij het ontbreken van druk een resultaat 0. Naar gelang de interrupt door het uitoefenen van kracht eerder
was opgetreden, zou tmp_T0 een waarde lager dan 0xffff hebben gekregen, waardoor het resultaat
een (niet-lineair) verband heeft met de uitgeoefende kracht.
32

4
Vadj -
2
Vt -
GND -
_INT
0
2
0 0.001 0.002
1 -
0 -
1 -
0 -
Timer 0 register
during Part III:
hivdtmr0
(start)
Vadj : VDD CD4011
Vt : Toggle voltage
(typ. 0.59*Vadj)
0xFFFF
(end)
Figuur 3.4 Timingsdiagram van de sensor, interrupt
Sensor waveform output
Interrupt signal
without force applied
Interrupt signal
with force applied
We hebben gemeten dat boven een bepaalde kracht op de sensor er geen verandering meer optreedt in
het oscillatiegedrag. De maximale verschuiving van de flank tijdens Part III hebben we laten afhangen
van de beginfrequentie bij het calibreren. Hij bedraagt 46% (sens_tm) van de duur van Part III.
Het voordeel van deze relatieve waarde is dat we niet gebonden zijn een bepaald werkpunt, mits de
controller vantevoren tijdens het calibreren de frequentie gemeten heeft zonder dat de sensor sturing
kreeg. Aangezien we voor de maximale kracht een van de waarden 0 tot en met 127 willen krijgen,
moeten we in principe de gemeten waarde delen door het maximum en vermenigvuldigen met 127.
Rekentechnisch lossen we dit in de microcontroller anders op, omdat we niet met een drijvende komma
willen gaan rekenen. Er is bovendien nog een andere reden, namelijk dat we het a-lineaire gedrag
eerst met behulp van een tabel willen lineariseren. Hierdoor kunnen we de kracht uitdrukken in een
midi-waarde. De grootte van de tabel bepaalt nu wat de maximale waarde van de meetwaarde moet
zijn. We gebruiken een tabel van 255 elementen. In paragraaf 3.1.2.1 gaan we hier nader op in.
De versturing van de MIDI-data gaat via de seriële poort van de microcontroller. Volgens het midi-protocol
moet deze uit twee bytes bestaan: een controlbyte en de bijbehorende waarde.
Eerst sturen we in de routine sendmd1 een controlbyte met de instructie:
mov SBUF,#midictrl
In de routine waittx wachten we totdat deze verstuurd is.
De volgende byte die we in de routine sendmd2 versturen, is de waarde die we na de linearisatie van
de kracht gekregen hebben. Dit gaat met de volgende instructie:
mov SBUF, midival
En wederom wachten we totdat deze verstuurd is.
33

Na het versturen van de data initialiseren we een aantal registers, waardoor de microcontroller klaar is
om de volgende meting te doen. Zie de lus measure in figuur 3.5
main:
loop:
Initialize
Measure
Description of startup procedure, prior to
normal operation. Stackpointer needs to be set
before the stack is being used (e.g. acall), to
prevent program/stack corruption.
With the aid of timer 1 Calib measures the
period from the relaxation oscillator.
The result is processed in calc_t0, which
calculates values for a fully interrupt driven
process (wavectrl) which controls proper
oscillation.
Figuur 3.5 Stroomdiagram van initialisatie en normaal bedrijf
During normal operation an endless
loop is being performed. Here presented
as a ‘C-style switch case’ instruction.
The loop does basically three things:
-wait for data
-process them
-send to midi.
cptfull has enough data when the flag
np_flag is set. It is set from within wavectrl.
subsequently cptfull calculates a mean value
from a number of captured periods.
convert calculates from the value from the
previous step a level of force which lies
between 0 (no force) and 127 (maximum force).
sendmd1, waittx and sendmd2 take care of
transmitting the level of force to the midi port.
caseovr puts registers back into an initial
state, which permits waiting for new data.
34

3.1.2.2 Linearisatie
We hebben de sensor opgenomen in het circuit met de relaxatie-oscillator, figuur 2.25. De sensor lag
op een vlakke horizontale plaat. Op de sensor hebben we verschillende massa’s, met bekende waarden,
gelegd en vervolgens de daarbij behorende periode gemeten. Het verband tussen de uitgeoefende
kracht en de periode is a-lineair. Grafiek 3.1 toont dit verband.
2.80
2.75
2.70
2.65
2.60
2.55
0 5 10 15 20 25 30
Grafiek 3.1 Periode van de relaxatie-oscillator uitgezet tegen de kracht. (bij 18
Door in de software gebruik te maken van een tabel kunnen we op een eenvoudige wijze de gemeten
periode omzetten naar een kracht. Om de tabel te maken hebben we een functie gezocht waarmee we
de kracht, uitgezet tegen de periode, kunnen benaderen. (Grafiek 3.2)
30
25
20
15
10
5
0
2.54 2.56 2.58 2.60 2.62 2.64 2.66 2.68 2.7
Grafiek 3.2 Gemeten en benaderde kracht uitgezet tegen de periode.
Meting
Benadering
35

Gezien de vorm kunnen we een benadering proberen met een logarithmische functie. In het bereik
waarmee we te maken hebben, vermenigvuldigen we de periode met 4000, zodat tussen de grootste en
de kleinste waarde een verschil van 1 komt. Na aftrekking van 10.2 komt de periode ongeveer tussen 0
en 1 te liggen. Als we hiervan een logarithmische functie nemen, krijgen we een nagenoeg rechte lijn,
die we gebruiken om het volgende functievoorschrift te maken:
F(T)
=
*
9.82 $ ( - ln(4000 $ T - 10.2) - 0.5894)
0.9813
– 710.18 · T + 1.9537
als T G 0.00269
als T > 0.00269
36
(3.1)
(T in s, F in N)
Voor perioden groter dan 2.69 ms is het verloop van de curve zo steil, dat de logarithmische functie
geen goede benadering meer geeft. Daarom hebben we het tweede deel in het functievoorschrift opgenomen,
dat dit (korte) lijnstukje beschrijft. Dit deel is in grafiek 3.2 met een stippellijntje weergegeven.
Voor de tabel hebben we nog de volgende gegevens nodig:
• Kortste periode: 2.561 ms
• Langste periode: 2.751 ms
• Kleinste waarde in de tabel: 0
• Grootste waarde in de tabel: 127
• Aantal elementen in de tabel: 256
Vervolgens hebben met behulp van een spreadsheet de volgende waarden berekend: (Tabel 3.1)
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
32 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
48 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
64 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
80 0 0 0 0 0 0 1 1 1 1 2 2 2 3 3 3
96 3 4 4 4 5 5 5 6 6 6 6 7 7 7 8 8
112 8 9 9 9 10 10 10 11 11 11 12 12 12 13 13 14
128 14 14 15 15 15 16 16 17 17 17 18 18 18 19 19 20
144 20 20 21 21 22 22 23 23 23 24 24 25 25 26 26 27
160 27 28 28 29 29 29 30 30 31 31 32 32 33 34 34 35
176 35 36 36 37 37 38 39 39 40 40 41 42 42 43 43 44
192 45 45 46 47 47 48 49 50 50 51 52 53 53 54 55 56
208 56 57 58 59 60 61 62 63 64 64 65 66 67 68 69 71
224 72 73 74 75 76 77 79 80 81 83 84 85 87 88 90 91
240 93 95 97 98 100 102 104 106 108 111 113 116 118 121 124 127
Tabel 3.1 Linearisatie periode. naar kracht
Ook de temperatuur van de sensor heeft invloed op de capaciteit, en daarmee op de periode. In de volgende
grafiek (3.3) hebben we het temperatuurverloop gegeven bij drie verschillende krachten:

400
390
380
370
360
350
340
330
0 10 20 30 40
Grafiek 3.3 Temperatuurverloop sensor bij verschillende krachten
2.17 N
4.75 N
11.4 N
Boven 26 ˚C vallen de frequenties van de verschillende kracht samen. Voor een goede werking van de
sensor is het belangrijk dat temperatuur niet te veel afwijkt van 18 ˚C.
3.1.3 Calibratie
Nadat de microcontroller een aantal registers heeft geïnitialiseerd, wordt er een subroutine calib
uitgevoerd die de periode van het uitgangssignaal meet, afkomstig van de relaxatie-oscillator. Het
resultaat is een 16-bits waarde. Op dit moment wordt de relaxatie-oscillator nog niet actief gestuurd.
Door de periode iets te verkorten, kunnen we tijdens de actieve sturing op een later moment ervoor
zorgen dat tijdens de stijgende flank de bewegingsrichting van de sensor gelijk is aan wat hij door de
sturing krijgt opgelegd. Zonder die correctie zou de sensor door de relaxatie-oscillator aan het eind van
de periode onder bepaalde omstandigheden uit zichzelf van bewegingsrichting kunnen veranderen, en
vervolgens door de sturing weer opnieuw gestart worden. We zijn van mening dat dit kort achter elkaar
opnieuw starten onwenselijk is, doordat het een gelijkmatige beweging verstoort. De verkorting van
de periode is vastgelegd in de constante shift_wv. We hebben deze proefondervindelijk vastgesteld op
25μs bij een periode van 2.7 ms. Bij deze tijd ontstonden er net geen vroegtijdige flanken meer. De periode
waarmee de sensor gestuurd wordt is daardoor 0.9% korter. Na aftrekking van shift_wv (in μs!)
van de gemeten periode (in machinecycles!) staat het resultaat in de registers prd_h en prd_l.
De calibratie wordt vervolgd in de routine calc_t0, vanwaar een verdeling gemaakt wordt van prd(_
h/_l) over de tijd die de drie fasen (zie figuur 3.6) in beslagen nemen tijdens een meetcyclus.
lo_TH0
lo_TL0
sigpw
hi_TH0
hi_TL0
prd_h/prd_l
Figuur 3.6 Verdeling prd_h/prd_l
hivdTH0
hivdTL0
sens_tm
37

De verdeling berekent de microcontroller met de volgende formules:
- 6
sigpw $ 10 $ Xtal
lo_tmr0 = 0x(1)0000h -
12
sens_tm
hi_tmr0 = 0x(1)0000h - ( prd - lo_tmr0) $ (1 - )
100
hivdtmr0 = 0x(1)0000h - ( prd - lo_tmr0) $
(sigpw in μs, Xtal in MHz)
sens_tm
100
De reden waarom we 0x(1)0000h geschreven hebben is rekentechnisch. Softwarematig trekken we
de getallen van 0 af, maar om de begripsvorming hier duidelijker te maken dat we niet met negatieve
getallen werken, zoals ‘signed-integers’, hebben we hier 0x10000h opgeschreven.
Van de drie berekende waarden wordt tenslotte nog een constante afgetrokken, zodat we een correctie
kunnen maken voor de tijd die er ligt tussen het stoppen van de timer, het schrijven van de nieuwe
waarden in de timerregister en het starten van de timer.
38

3.1.4 Complete schakeling
Om de microcontroller te laten werken, hoeven we behalve een 5 V voeding alleen nog een kristal van
12 MHz en een reset-circuit aan te sluiten. De MIDI-connector is via transistor Q4 verbonden met de
seriële uitgangspoort RXD. Het uitgangssignaal van de relaxatie-oscillator verbinden we via de twee
in serie geschakelde NAND-poorten, weerstand R4 en transistor Q2 zowel aan /INT0 als aan /INT1
(deze hebben een interne pull-up), zodat we in de software via maskering van de interrupts kunnen
bepalen waar er naartoe moet worden gesprongen als er een interrupt optreedt. De sturing van de oscillator
is via weerstand R5 en transistor Q1 aangesloten op een van de vrije poorten van de controller.
Vin
C4
10u
Vadj.
1
Q1
BC558C
R5
12k
U9
LM78L05A/TO39
VIN
GND
3
D1
D1N4148
VOUT
2
R3
3k3
+5v
19
18
17
16
15
14
13
12
C5
10u
U5
GND GND
GND GND GND
GND
1
2
R1
50k
P1.7
P1.6
P1.5
P1.4
P1.3
P1.2
P1.1/AIN1
P1.0/AIN0
AT89C2051
R7
1k
R8
4k7
10
U1A
CD4011A
GND
X2
Piezo Cry stal
R2
3
82k
GND
VCC
RST/VPP
XTAL2
XTAL1
P3.7
P3.5/T1
P3.4/T0
P3.3/INT1
P3.2/INTO
P3.1/TXD
P3.0/RXD
Q3
BC547A
C6
1uF
20
1
4
5
5
6
11
9
8
7
6
3
2
Vadj.
+5v
U1B
CD4011A
+5v
4
GND
X1
C2
20pF
R11
220
R10
220
GND
R9
1k Q4
BC557C
8
9
4
5
Vadj.
14
7
12.0 MHz
C3
20pF
GND
U1C
CD4011A
Reset
Fig. 3.7 Totale schema van de krachtsensor aangesloten op de microcontroller
3
+5v
GND
10
C1
1.0uF
R6
68k
2
1
13
12
JP1
DIN 5P
U1D
CD4011A
Midi Out
11
R4
10k
Q2
BC548B
GND
39

3.2 PC-Software
Het programma dat de data op de PC opneemt, de sequencer, moet deze data kunnen exporteren als
een standaard MIDI File. Ons converteringsprogramma kan zowel type 0 (single multi-channel track)
als type 1 (one or more simultaneous tracks) MIDI Files importeren. Het formaat waarnaar we converteren
is een textbestand met getallen, gescheiden door een komma en een ‘carriage return’: (hier
vanwege de overzichtelijkheid weergegeven in zes kolommen.)
40 mit
384
0,0
3,32
9,56
14,28
19,36
26,44
31,52
41,60
48,52
53,44
58,60
80,56
85,52
92,64
114,68
235,76
240,68
516,64
528,60
539,64
545,68
699,72
710,76
726,88
733,84
738,72
743,68
804,64
809,68
876,64
881,60
888,64
893,60
898,64
903,68
920,72
925,68
1218,72
1223,68
1384,60
1395,64
etc.
In MIDI Files wordt de informatie in pakketten, ‘chunks’ genaamd, ingebed. De pakketten hebben
een header met een vaste structuur en een gedeelte dat volgt met een variabele structuur. Omdat er bij
de vaste structuur opgegeven wordt hoeveel data er in de daarnavolgende variabele structuur komen,
kunnen MIDI Files altijd gelezen worden. Immers, zonder de opbouw van stuurcodes te kennen, kunnen
namelijk data overgeslagen worden. In hoeverre de gegevens ook verwerkt kunnen worden hangt
uiteraard van het implementatieniveau af van de software.
Met verwijzing naar de appendix, waar een uitvoerige beschrijving over de opbouw van MIDI Files
wordt gegeven, laten we de basisstructuur van MIDI Files zien. Het conversieprogramma volgt die
structuur. Om inzicht in de opbouw van dit programma te krijgen, laten we een aantal details weg,
zodat een soort C++ raamwerk van dit programma overblijft:
while ( ( c=getc(fp)) != EOF)
switch (head)
{
case MHDR:
{
if (what2do!=ERR) // process header data if head == TRUE
switch (what2do)
{
case HDR:
..
case HBL:
..
case FMT:
..
case NTB:
..
case RES:
..
} // escape from switch (what2do)
// endif (what2do!=ERR)
break; // escape from case MHDR
}
case MSIG:
{
if (mfmt==1 && what2do!=ERR) // process time/signature tempo track data in format 1
{
switch (what2do)
{
case SHDR:
40

..
case SHL:
..
case STAIL:// need only tempo, if more needed, change case META_DATA
..
} // end switch (what2do)
} // end if
break; // escape from case MSIG
}
case MTRK:
{
if (mfmt==1 && what2do!=ERR) // process track data in format 1
{
switch (what2do)
{
case THDR:
..
case TRKL:
..
case TTAIL:// proces control code AFTER_TOUCH somewhere
..
} // end switch (what2do)
break;
} // escape from case MTRK
}
} // end switch (head)
// end while
In de eerste regel van het bovenstaande C-raamwerk wordt er net zolang een character uit de MIDI
File gelezen, totdat er geen character meer volgt. Zonder dat er eerst gedecomprimeerd moet worden,
kunnen we de deze data sequentieel lezen. Deze data hebben altijd de volgende structuur en kunnen als
‘chunk’ of pakket meerdere keren achter elkaar voorkomen:
•Een identificatiecode van 4 ASCII characters aan het begin van een pakket, gevolgd door
•een ‘word’ van 4 bytes die het aantal volgende bytes behorende bij dit pakket aangeeft.
•De eigenlijke data.
Er bestaan maar twee identieficatiecodes. Dit zijn de characters ‘MThd’ (Master Track header) of
‘MTrk’ (Master Track). Een MIDI File begint altijd met ‘MThd’, waarna de tracks daarna altijd met
‘MTrk’ beginnen:
MThd
MTrk
MTrk
etc.
...
In het programma wordt de ‘MThd’ header aan het begin getest bij case HDR doordat de variabelen
head en what2do juist zijn geïnitialiseerd. Als er inderdaad ‘MThd’ staat, kunnen we de daarnavolgende
vier bytes lezen, die de omvang van het pakket aangeven. Dit gebeurt door de variabele
what2do gelijk te maken aan de constante HBL (what2do wordt met een opgehoogd), zodat het
programma case HBL bereikt. Opnieuw wordt what2do met een opgehoogd. Het krijgt de waarde van
FMT, zodat in case FMT kan worden vastgesteld of we met een type 0 of type 1 MIDI File te maken
hebben. Daarna wordt met behulp van what2do, case NTB en RES doorlopen. In case NTB lezen we
uit de file hoeveel ‘Master Tracks’ er nog volgen. Tenslotte stellen we in case RES de resolutie van
een kwartnoot vast. Deze wordt uitgedrukt in een deltatijd (delta-time). De deltatijd bepaalt in hoeveel
stappen een kwartnoot wordt onderverdeeld. Samen met het tempo, bepaalt zij de kortst mogelijke
opeenvolging van twee meetwaarden.
De volgende ‘chunk’ of pakket ‘MTrk’ komt nu een beurt. De variabele head wordt gelijk aan MSIG,
waardoor case MSIG doorlopen wordt. Hier wordt de time signature data verwerkt. Omdat we met het
41

tempo verder niets doen, wordt dit alleen pro-forma doorlopen, totdat we bij de data komen waar we in
geïnteresseerd zijn. Deze data vinden we in case MTRK. Na de vier characters ‘MTrk’ en de (4 bytes-
)word dat de pakketgrootte aangeeft volgt hier de data van de krachtsensor. In de case TTAIL worden
twee belangrijke zaken bijgehouden. Ten eerste wordt er konkreet gezocht naar ‘After Touch’ MIDI
Events. Ten tweede houden we de plaats bij waarop dit event staat. Nadat er een ‘After Touch’ MIDI
Event gevonden wordt, kunnen we de volgende byte verwachten die de grootte van de kracht aangeeft.
Deze waarde slaan we op in de variabele data1. De plaats waar het event staat en data1 schrijven we
aan het eind van TTAIL naar het textbestand. De laatste case wordt net zolang doorlopen totdat alle
bytes gelezen zijn van deze track. Aan het eind van een track wordt het tekstbestand afgesloten. Als
deze track de laatste was, is het programma klaar. Anders herhaalt het programma case MTRK, waar
weer een nieuw tekstbestand gemaakt wordt met de data uit de volgende track.
42

4. Mechanische constructie en realisatie
Standaard, zoals eerder uitgelegd, zit op de meeste violen een kinhouder. We willlen de kracht meten
die door de violist hierop wordt uitgeoefend. Daartoe wordt het meetapparaat uitgevoerd als kinhouder.
Om het spel niet te beïnvloeden, dient het meetapparaat dezelfde eigenschappen hebben die voor
een kinhouder noodzakelijk zijn. Dit zijn:
• Juiste pasvorm van het gedeelte op de bovenkant dat tegen de kaak aankomt (de houder).
• Juiste hoogte, zodat het hoofd niet ingetrokken of zijwaarts gekanteld hoeft te worden.
• Stevige montage op het instrument, het liefst in het midden over het staartstuk, omdat daar het
instrument het stevigst is, en omdat dat voor de klank beter is.
Daarenboven dient het meetapparaat ook te voldoen aan de volgende eisen:
•De plaatsing van de sensor zodanig dat de denkbeeldige krachtlijn van de kaak door de kinhouder
naar het instrument, midden door de sensor gaat, die zich vlak onder de houder bevindt.
• De houder moet beweegbaar zijn in verticale richting, in de richting van de krachtlijn, zodat de
kracht van de kaak op de houder overgedragen kan worden op de sensor.
• De houder moet in hoogte verstelbaar zijn, zodat die aangepast kan worden aan de lengte van de
nek van de instrumentalist.
• De afmetingen dienen ondanks de toegevoegde onderdelen bescheiden te blijven.
Om de kracht goed op de sensor te kunnen overdragen en de houder voldoende stevigheid te geven,
monteren we de houder op een scharnier. (Figuur 4.1) Aan het andere been van het scharnier zit een
v-vormig plaatje dat deel uitmaakt van een zwaluwstaartgeleiding. Omdat de zwaluwstaartgeleiding
onder een hoek is bevestigd, kunnen we de hoogte van de houder aanpassen aan de instrumentalist: als
we de houder helemaal naar links verschuiven staat die op zijn hoogst, en in de rechtse stand helemaal
op zijn laagst. (Figuur 4.2, 4.3 en 4.5)
Geleidingssysteem
Scharnier
Klemschroef om deel vast te zetten
Drukrichting kaak
Fig. 4.1 Constructieschets meetapparaat
Beweegbaar deel kinhouder
Onderaanzicht beweegbaar deel
Klemdeel kinhouder dat op instrument
vastgezet wordt.
43

Fig. 4.2 Hoge stand kinhouder Fig. 4.3 Middenstand kinhouder Fig. 4.5 Lage stand kinhouder
De sensor monteren we tussen de benen van het scharnier, midden onder de houder. (Figuur 4.4)
Fig. 4.4 Plaatsing sensor Fig. 4.6 Besturing
De elektronica die de sensor bestuurt en alle data verwerkt zit achter het vaste deel van de kinhouder.
(Figuur 4.6)
44

4.1 Specificaties van het systeem
4.1.1 Meetbereik
De op de kinhouder uitgeoefende krachten liggen in de ordegrootte van 0 tot 20 N. Het meetapparaat
kan krachten meten tot 25 N. Daarmee wordt het gewenste meetbereik ruimschoots gehaald.
4.1.2 Gevoeligheid
In de grafiek waarin de frequentie is uitgezet tegen de kracht (grafiek 4.7), zien we dat bij een lage
kracht de periode veel meer verandert dan bij een grote kracht. De gevoeligheid is daardoor bij kleine
krachten veel groter dan bij grote krachten.
2.80
2.75
2.70
2.65
2.60
2.55
0 5 10 15 20 25 30
Grafiek 4.7 Periode van de relaxatie-oscillator uitgezet tegen de kracht. (bij 18 ˚C)
4.1.3 Meetfrequentie
Om een duidelijk beeld te krijgen van het krachtverloop tijdens het spelen, dienen er voldoende metingen
per tijdseenheid uitgevoerd te worden. De meetfrequentie is (bij 18˚C) ingesteld op 370 Hz. Deze
meetwaarden worden per 10 gemiddeld, en het gemiddelde verschijnt op de MIDI-uitgang.
4.1.4 Omgevingsinvloeden
De invloeden waarmee we te maken hebben zijn zowel invloeden van het meetapparaat op de proefpersoon
als invloeden van de proefpersoon op het meetapparaat.
• Stoorgeluiden: Omdat de relaxatie-oscillator de sensor in beweging zet tijdens het meten, wekt
de sensor stoorgeluiden op. Deze zijn tot een afstand van ongeveer 30 centimeter nog net hoorbaar.
Tijdens het spelen zijn deze geluiden onhoorbaar omdat het instrument de sensor overstemt.
• Mechanische trillingen: Als de mechanische trillingen van het instrument lager dan de meetfrequentie
zijn, is de kans veel groter dat de schakeling verkeerd getriggerd wordt. Omdat de
altviool lager gestemd is, en de mechanische trillingen groter zijn dan bij de viool, is het bij lage
tonen nodig de trillingen van de altviool te dempen met een zwaar blok op de kam.
• Omgevingstemperatuur: Omdat de temperatuur invloed heeft op de meetsensor, dient de omgevingstemperatuur
te liggen tussen 18 en 22˚C
4.1.5 Massa van het meetapparaat
Ondanks de toegevoegde functionaliteit is het meetapparaat, vanwege de gebruikte materialen, niet
zwaarder dan een gewone kinhouder. Zonder aansluitdraden voor de voedingsspanning is de massa 94
gram
45

5. Meetresultaten
s
e
i
l
r
a
M
t
i
m
0
4
s
e
i
l
r
a
M
e
n
h
o
0
4
s
e
i
l
r
a
M
t
i
m
0
6
s
e
i
l
r
a
M
e
n
h
o
0
6
s
e
i
l
r
a
M
t
i
m
0
8
s
e
i
l
r
a
M
t
i
m
0
0
1
figuur 5.1 Kindrukmeting van proefpersoon 1
c
r
a
M
Bij acht musici hebben we met behulp
van het apparaat metingen verricht.
Speciaal hiervoor hebben we een
oefening uitgezocht waarbij specifieke
houdings- en bewegingskenmerken
van belang zijn, zodat bepaalde
spanningen en afwijkingen daarvan
gemeten kunnen worden. In de muzieknotatie
leggen we vast met welke
vinger en op welke snaar gespeeld
moet worden. Bij de resultaten hebben
we in de muzieknotatie bovendien
een speciaal teken met vertikale lijnen
aangebracht, die aangeeft waar in ieder
geval kindruk noodzakelijk is. Op de
horizontale as van de grafieken staat
de tijd afgezet, die afhankelijk is van
het tempo waarin gespeeld wordt. We
drukken deze uit in het metronoomcijfer,
vooraan de grafieken. Op de verticale
as staat de kindruk. De schaling
is bij alle personen dezelfde, zodat we
de meetwaarden kunnen vergelijken.
Vooraan de verticale as staat tenslotte
ook nog geschreven of de test met of
zonder een schoudersteun is uitgevoerd.
We kiezen twee personen uit
waarvan we de serie metingen hier
afbeelden (figuur 5.1 en 5.2). Omdat
een uitgebreid inzicht in deze materie
buiten het bestek valt van dit afstudeerverslag,
verwijzen we voor de
overige metingen naar het internet 11 .
Als eerste tonen we de meetresultaten
van persoon 1. Deze persoon heeft een
korte nek, speelt gewoonlijk met een
schoudersteun, maar probeert soms
ook zonder te spelen. Omdat haar linkerhand
relatief klein is, lukt het haar
niet in hoge posities te spelen, zonder
dat de duim onder de hals van het
instrument blijft. Dit verklaart waarom
of waarvoor zij de schoudersteun
nodig heeft. Deze neemt de dragende
functie van de duim over. Het instrument
steunt op het sleutelbeen. Duidelijk
is te zien dat ze het instrument heel
gelijkmatig vastklemt, hoewel dat op
veel momenten niet noodzakelijk is.
46
t
i
m
0
4
Marc
40
ohne
Marc
60
mit
Marc
60
ohne
Marc
80
ohne
c
r
a
M
e
n
h
o
0
0
1

co
r
a
M
t
i
m
0
4
co
r
a
M
e
n
h
o
0
4
co
r
a
M
t
i
m
0
6
co
r
a
M
e
n
h
o
0
6
co
r
a
M
e
n
h
o
0
8
co
r
a
M
e
n
h
o
0
0
1
figuur 5.2 Kindrukmeting van proefpersoon 2
Proefpersoon 2 heeft een tamelijk
lange nek, waardoor we de kinhouderhoogte
hieraan moeten aanpassen.
In vergelijking met proefpersoon
1 is de linkerhand groot
genoeg om ook in hoge posities de
duim onder de hals van het instrument
te houden. Omdat de linkerhand
het instrument in de meeste
gevallen kan dragen kan proefpersoon
2 zonder problemen zonder
schoudersteun spelen. De afwezigheid
van een permanente kracht in
de meetresultaten bevestigd dat er
op de juiste manier gespeeld wordt.
Voor een iets beter houvast gebruikt
deze persoon een zeemleren doekje
tussen de kin en de kinhouder. De
reden dat de meetresultaten ook bij
verschillende tempi goed reproduceerbaar
zijn, is dat deze persoon
de oefening uitgebreid geoefend
heeft. De meetresultaten zijn zoals
verwacht: Op de plaatsen waar we
druk verwachten, zien we dit ook
terug.
47

5.1 Inzichten uit de meetresultaten
Door meetresultaten tussen spelers onderling te vergelijken, kan de violist (of altviolist) een objectiever
inzicht krijgen in zijn eigen speelwijze dan voorheen. Immers, als de vraag gesteld wordt of hij
of zij met veel spanning speelt, wordt dat gewoonlijk door iedereen verschillend beantwoord. Of de
speler moet overwegen zijn speelwijze te veranderen om mogelijke problemen te voorkomen, kan niet
eenduidig hierdoor aangegeven worden, omdat iedere speler een andere mate van tolerantie heeft.
Een belangrijk inzicht aan de hand van de meetresultaten is of de violist spieren wellicht efficiënter
kan benutten. De instrumentalist kan nagaan of het vastklemmen van het instrument op alle momenten
werkelijk noodzakelijk is geweest. Als het instrument op het sleutelbeen rust en aan de andere kant
met de linkerhand wordt gedragen, kan het zijn dat de hand teveel gehinderd wordt om tegelijkertijd
te bewegen. Met bepaalde oefeningen kan het mogelijk zijn de linkerhand meer vrijheden te geven,
zonder zijn dragende functie te verliezen.
Bij de uitgevoerde metingen waren we er ook in geïnteresseerd op wat voor manier bij het spelen
van een passage, het tempo invloed heeft op de spanning. Komen er bijvoorbeeld bij passages die in
een hoog tempo gespeeld worden paniekreacties voor, waardoor het instrument steviger wordt vastgeklemd?
Uit de resultaten zien we hiertussen geen duidelijk verband. Bij sommige violisten is de
kindruk bij een hoog tempo voortdurend aanwezig. Bij andere violisten lijkt het erop dat juist bij een
langzaam tempo vaker met de kin gedrukt wordt.
Problemen die zich kunnen voordoen, vinden we met name bij altviolisten. Voor hen geldt dat relatief
gezien de meeste lichamelijke klachten bij de nek en de schouders zich manifesteren 12 . (Tabel 5.1).
Bovendien komen de klachten meer aan de linkerkant voor dan aan de rechterkant.
Schoudergewricht
Bovenarm
Elleboog
Onderarm
Pols
Vinger
10
10
12
11
13
12
14
15
11
0 5 10
13
15 20 25 30 %
Tabel 5.1 Overzicht lokalisatie van lichaamsklachten bij
altviolisten met een verhouding links tegen rechts van 2:1.
Uit een groep van 311 altviolisten
18
25
Altviool ≤ 40 cm
Altviool > 40 cm
Als een altviolist klachten heeft en uit de meetresultaten ziet dat er met meer spanning gespeeld wordt
dan nodig is, zou hij of zij dit kunnen verminderen door andere hulpmiddelen te nemen, zoals een
kinhouder met een andere hoogte en/of vorm of een andere schoudersteun die de schouders meer ontlast
of zelfs zonder schoudersteun. Meestal valt er ook wel iets aan de speelwijze te veranderen. Door
bijvoorbeeld de linkerhand een aktievere rol te geven het instrument te dragen tijdens het spelen.
De kinhouder zorgt met name voor een bewustwording van de speelwijze, waardoor uiteindelijk de
expressie in de muziek beter beheersbaar is.
48

6. Conclusies en aanbevelingen
6.1 Conclusies
We kunnen met succes kindruk meten met het meetapparaat tijdens het spelen op de viool of altviool.
De ontwikkeling van het apparaat en de verwerking van de meetgegevens heeft inzichten gegeven in
zowel elektrotechnische als muziektechnische aspekten. Op de muziektechnische aspekten zijn we in
hoofdstuk 5 nader ingegaan.
Wat het meetapparaat en de meetresultaten betreft kunnen we het volgende concluderen:
• Het apparaat geeft een goed beeld van de momenten waarop op de kinhouder gedrukt wordt en
hoe die kracht verloopt tijdens het spelen.
• Het apparaat is door gebruik te maken van een PZT-sensor in combinatie met een microcontroller
zeer klein gebleven. Het apparaat kan daardoor op het eigen instrument van proefpersonen
geplaatst worden. De afmetingen van het meetapparaat zijn te vergelijken met die van een standaard
kinhouder. Hierdoor wordt het normale vioolspel niet beinvloed. Ook de bijgeluiden van
de meting zijn onhoorbaar voor de proefpersoon.
• Het apparaat is volledig inzetbaar in een muziekomgeving, omdat de meetdata in een standaard
MIDI-formaat zijn. Hierdoor kan met de meeste sequencers probleemloos het meetsignaal, gecombineerd
met het muzieksignaal (het vioolspel) geregistreerd worden, om later geanalyseerd
te worden.
• Door de meetresultaten te analyseren kan de instrumentalist inzien op welke wijze er aan de manier
van spelen verbeteringen kunnen worden aangebracht. Een uitgebreid rapport valt te zien
op het internet 11 .
De gekozen sensor in het meetapparaat en de aansturing daarvan leidt tot de volgende conclusies:
•Door het gebruik van een microcontroller is het meetsysteem automatisch calibreerbaar.
•De kindruk is zeer goed met een PZT-sensor te meten. In tegenstelling tot wat werd verwacht, is
niet de resonantiefrequentie van de sensor afhankelijk van de kracht, maar de impedantie van de
sensor (hierna te noemen capaciteit). Deze capaciteit kan eenvoudig met een relaxatie-oscillator
worden bepaald. In ons geval was de capaciteit in onbelaste toestand 7.4 nF. Bij een kracht van
25 N nam deze af tot 6.7 nF.
•De capaciteitsverandering is niet te verklaren vanuit een model van een condensator waarbij
twee platen met een gegeven oppervlak met daartussen een diëlektrikum een bepaalde afstand
van elkaar afstaan. Hiervoor varieert de afstand te weinig, daar het kristal nauwelijks samendrukbaar
is.
•De relatie tussen opgelegde kracht en capaciteit blijkt uit de metingen a-lineair te zijn. Bij geringe
massa’s is de capaciteitsverandering veel groter dan bij grote massa’s. Dit is gunstig voor
metingen bij kleine krachten. Deze a-lineariteit wordt in de software gecompenseerd.
6.2 Aanbevelingen
Ondanks het succesvolle ontwerp van de kindrukmeter, zijn er toch nog enkele vragen en kan men op
een aantal onderdelen verbeteringen doorvoeren.
•De resonantiefrequentie van de sensor verandert, zoals bepaald binnen dit onderzoek, niet met
de opgelegde druk; tegen onze verwachting in. Men zou een betere schakeling kunnen gebruiken
die de resonantiefrequentie van de sensor meet. Daarvoor zou de sensor opgenomen kunnen
worden in een brugschakeling. Een andere manier om nauwkeuriger de resonantiefrequentie te
kunnen meten, is met behulp van een circuit waarin over een groot frequentiebereik de fase met
49

90° wordt verschoven 13 . De lage Q-factor van de PZT-sensor versterkt het vermoeden dat er een
betere schakelingen moet worden gebruikt. Mogelijk is de invloed van de temperatuur op de
resonantiefrequentie veel kleiner dan op de capaciteit.
•Temperatuurafhankelijkheid. Als men nauwkeuriger wil meten, en dan voornamelijk grote
krachten (omdat daar de relatieve verandering van de frequentie gering is), moet er geprobeerd
worden te voorkomen dat het temperatuurverloop de meetwaarden teveel beïnvloedt. Hiervoor
kan gedurende het meten van de frequentie dit verloop ook in de gaten gehouden worden, en de
gemeten capaciteit met de gemeten temperatuur compenseren. Een tweede mogelijkheid is de
temperatuur van de sensor constant te houden.
Zonder correctie/compensatie is het noodzakelijk om binnen niet te grote tijdsafstanden een
calibratie uit te voeren, echter de meettijd wordt hierdoor wel beperkt.
•Bij krachtuitoefening op een PZT-sensor, verandert niet alleen de capaciteit, maar wordt ook een
spanning opgewekt. Deze spanning kan een storende werking hebben op de relaxatie-oscillator,
omdat deze spanning de NAND-poorten kan triggeren, zodat deze van toestand wisselen. Een
remedie hiertegen zou kunnen zijn het filteren van deze frequenties.
•Mechanische trillingen van het instrument storen meetwaarden, dit kan opgelost worden door
een mechanische ontkoppeling (Bijvoorbeeld demping met behulp van rubber). Daarnaast kan
het (mechanische) systeem mogelijk geoptimaliseerd worden door de plaatsing en de constructie
rond de sensor te verbeteren.
• Met een ander type sensor, waarbij direct, zonder omwegen, de (statische) kracht kan worden
omgezet in een uitgangsspanning, zou men de software aanmerkelijk kunnen vereenvoudigen.
Met de juiste microcontroller (bijvoorbeeld de ATMEL ATtiny26) met ingebouwde AD-converter
kan direct de uitgangsspanning van de sensor omgezet en verwerkt worden.
• Op basis van de meetresultaten van hoofdstuk 5 zou men naast het inzicht op welke momenten
er gedrukt wordt en hoe sterk, ook moeten onderzoeken op wat voor manier er gedrukt wordt.
Te denken valt daarbij aan het inzicht in de snelheid van de krachtverandering tijdens het spelen.
50

Sourcecode van het stuurprogramma voor de AT89C2051
Voor een stroomdiagram waarin de hoofdlijn van het programma wordt uitgelegd, verwijzen we naar
hoofdstuk 5. De sourcecode, die uitgebreid van commentaar is voorzien, begint met een kort overzicht
te geven van alle geheugenadressen, variabelen, constanten, gebruikte registers en functies en interrupt
vectoren. Deze opzet heeft ook een nadeel, omdat we altijd op twee plaatsen een verandering moeten
aanbrengen, namelijk in het overzicht aan het begin en bij de code zelf. Functies laten we meestal
voorafgaan door een blok commentaar, waarin onder andere de naam en de werking staan beschreven.
Voor zover van toepassing hebben we ook door middel van de tekens -> en (wvmem): 000bh (interrupt vector for overflow in timer0)
; (jmps to wavectrl: process: modificate sensctrl)
51

; EXTI1->(sens_stamp): 0013h (interrupt vector for saving pos. of timer0)
; (jmps to sens_stamp)
; TIMER1 001bh (interrupt vector for overflow in timer1)
; (process: carry timer overflow to OP_1)
;************************* functions ***********************************
; main: (main program starts here)
; initsys: (initializes system: ports, interrupts, variables)
; sett0_cnt: (initializes timer0 for counting)
; sett1_cnt: (initializes timer1 for counting)
; sett1_midi: (initializes timer1 for midi)
; calc_t0: (calculates setup timer values for signal)
; calib: (loads prd with proper values)
; freqcap: (measures frequency on _int0
; wavectrl(wvmem): (processes generated waveform)
; sens_stamp(tmp_TH0,tmp_TL0) (stamps position of TH0 and TL0, when sensor)
; Mul_16( (OP_0..3) * (R2,R3) ) (Performs multiply between long and int)
; Div_16( (OP_0..3) / (R2,R3) ) (Performs division between long and int)
;************************* constants ***********************************
clk equ 12000 ;system clock in kHz
baud equ 31250 ;bits/s on midi output
sigpw equ 35 ;pulsewidth of lo state in µsec
ccpins equ 12 ;#clockcycles per instruction
proc_tm equ 20 ;est. processing time, interrupt routine
num_per equ 10 ;#periods to calculate average
shift_wv equ 25 ;force sensor to run in phase with wave (in µsec)
sens_tm equ 46 ;sensor reaction is valid during 42% of hi-wave
sensctrl bit P1.0 ;output port, controls sensor
sensor bit P3.2 ;input port, sensor feed back signal
midictrl equ 0d0h ;coding for general aftertouch with midi
;************************** variables ***********************************
wvmem equ 20h.0 ;bit adres for hi or lo state of output signal
vldsns equ 20h.1 ;bit adres for valid sensor measurement (1=valid)
np_flag equ 20h.2 ;flag for avialability of enough data from int. routine
tmp_C equ 20h.3 ;flag for temporary storing Carry
tmp_A equ 43h ;register is faster than stack
prd_h equ 44h ;target period MSB in timer counting rate
prd_l equ 45h ;target period LSB in timer counting rate
lo_TH0 equ 46h ;duration lo state MSB timer0
lo_TL0 equ 47h ;duration lo state LSB timer0
hi_TH0 equ 48h ;duration hi state MSB timer0
hi_TL0 equ 49h ;duration hi state LSB timer0
hivdTH0 equ 4ah ;duration hi state, during which sensor may respond
hivdTL0 equ 4bh ;duration hi state, during which sensor may respond
OP_0 equ 4ch ;Operand1 (Highest byte unsigned long)
OP_1 equ 4dh ;
OP_2 equ 4eh ;
OP_3 equ 4fh ;
;R2 ;Operand2 (Highest byte unsigned ‘long’
;R3 ;functions implement uptill now only int size
TMP_0 equ 50h ;Highest byte unsigned long
TMP_1 equ 51h ;
TMP_2 equ 52h ;
TMP_3 equ 53h ;
tmp_TH0 equ 54h ;memory for position of TH0
tmp_TL0 equ 55h ;memory for position of TL0
wndwTH0 equ 56h ;size of valid window where sensor may respond
wndwTL0 equ 57h ;size of valid window where sensor may respond
case equ 58h ;task dispatcher in main
midival equ 59h ;pressure (0..127) into control midivalue
52

;******************* from here the assembly starts ***************************
org RESET
ajmp main ;continue at main
;*****************************************************************************
;* EXTI0 -> R3 *
;* interrupt from EXTI0 occurred, so there had been a hi->lo transition *
;* wvmem *
;* interrupt from timer0 occurred, so there’s some work to do. Precalculated *
;* values for TH0 & TL0 determine how long the hi-state (in hi_TH0 & hi_TL0) *
;* and the lo-state (in lo_TH0 & lo_TL0) on output port sensctrl will last. *
;* TH0, TL0 *
;* interrupt from EXTI1 occurred, so sensor measures pressure *
;* tmp_TH0,tmp_TL0) *
;*****************************************************************************
org EXTI1
clr TR0 ;1 stop timer 0 during processing
ajmp sens_stamp ;process routine there further
;*****************************************************************************
;* TIMER1 -> *
;* interrupt from timer1 occurred during measuring frequency. Overflow from *
;* TH1 causes a carry to variable OP_1 *
;* op_1++
reti
;******************************** M A I N ************************************
main: mov SP,#020h ;init stack;starts now at 020h+1=021h
acall initsys ;setup system ports and variables
acall sett1_cnt ;set timer1 for counting system clock (with EXT1)
acall calib ;calibrate piezo sensor frequency
acall sett1_midi ;set timer1 for midi transmission (and for debug)
acall calc_t0 ;converts prd_h,prd_l,sigpw into lo/hi_t0/hivd
mov A,#0 ;clear OP_0..3, to start sum from 0
mov OP_0,A ;with accumulator I save 2 bytes, and speeds up!
mov OP_1,A
mov OP_2,A
mov OP_3,A
mov R2,A ;R2 with next R3 forms the divider
mov R3,#num_per ;for fillbuf, R3 must be initialized
mov case,A ;set task dispatcher with initial value 0
acall sett0_cnt ;init timer0, initiate signal generating
inccase: inc case ;case 1 is the first case
loop: mov DPTR,#jmp_tbl
mov ACC,case
rl A
jmp @A+DPTR
jmp_tbl: ajmp loop
ajmp cptfull
ajmp convert
ajmp sendmd1
ajmp waittx
53

ajmp sendmd2
ajmp waittx
ajmp caseovr
;*****************************************************************************
;* cptfull -> np_flag, OP_0..3, R2, R3 *
;* from interrupt proces there might be enough captured date, to proces *
;* further here: calculate average. When finished next task *
;* OP_0..3 *
;* The summing must be converted to a proper midi value (0..127) *
;* midival is only stored if it is different from calculated value in acc. *
;* If they’re equal, the dispatcher starts from beginning, so byte will not *
;* be transmitted. *
;* (OP_2..3) *
;* 256 multiply: (OP_2..3) -> (OP_1..2) *
;* division: (OP_0..3)/(wndwTH/L0) (creates value 0..255) *
;* linearisation: array[0..255] -> 0..127 *
;*****************************************************************************
convert: clr C ;substr. ffffh -
mov A,#0ffh
subb A,OP_3 ;LSB
mov OP_3,A
mov A,#0ffh ;MSB
subb A,OP_2
mov OP_1,A ;store result in OP_1..2
mov OP_2,OP_3 ;perform 256*multiply
mov OP_3,#0
mov R2,wndwTH0
mov R3,wndwTL0
acall Div_16 ;result in OP_0..3 (0..255)
mov DPTR,#lintbl ;in lintbl is a table to linearizate output
mov A,OP_3 ;index to accumulator
movc A,@A+DPTR ;move array value to accumulator
cjne A,midival,newmdi ;continue only if value is different
ajmp caseovr ;in the beginning there was...
newmdi: mov midival,A ;new value, so save value in midival
ajmp inccase
;*****************************************************************************
;* sendmd1 -> *
;* transmits first control byte midictrl *
;* *
;* transmits second midi value byte *
;* *
;* waits till byte is transmitted *
;* *
54

;* case has reached maximum, so now it is reset with value 1 *
;* nothing *
;* initializes port sensctrl and its flag wvmem *
;* initializes syst.variable sigpw with a startup value *
;* enable overflow interrupt timer0 and timer1 *
;* set serial port to 8-bit UART *
;* hi_TH0 & hi_TL0 *
;* initializes timer 0 for the pulse generator. overflow *
;* generates an interrupt to vector 000bh, routed to the *
;* service routine for generating the pulses *
;* nothing *
;* initializes the timer1 for counting the system clock *
;* nothing *
55

;* initializes timer1 for generating baud rate for the *
;* serial port, needed for midi *
;* prd_h,prd_l,sigpw,sens_tm *
;* calculates counter rate, needed for *
;* keeping sensctrl alternating high or low, *
;* using timer0 with an interrupt service *
;* routine. Stores the calc. values in *
;*

mov OP_2,#((sens_tm*256)/100) / 256 ;MSB sens_tm
mov OP_3,#((sens_tm*256)/100) and 255 ;LSB sens_tm
mov R2,hi_TH0 ;MSB hi_tmr0
mov R3,hi_TL0 ;LSB hi_tmr0
acall Mul_16
mov hivdTH0,OP_1 ;MSB of result, which is factor 256 too hi
mov hivdTL0,OP_2 ;LSB of result, so just shift byte
mov wndwTH0,OP_1 ;MSB function convert uses the max. size
mov wndwTL0,OP_2 ;LSB
pop hi_TH0 ;calculate hi_tmr0 = hi_tmr0 - hivdtmr0
pop hi_TL0
clr C
mov A,hi_TL0 ;hi_TL0 - hivdTL0
subb A,hivdTL0
mov hi_TL0,A
mov A,hi_TH0 ;borrow in MSB?
subb A,hivdTH0
mov hi_TH0,A
jnc ca_corl ;no borrow, so result still pos.
mov hi_TL0,#001 ;timing is too short, so take minimum
mov hi_TH0,#000 ;value, and store temp. in hi_t0
ca_corl: clr C ;timing correction for lo_tmr0
mov A,lo_TL0 ;lo_TL0 - proc_tm
subb A,#proc_tm
mov lo_TL0,A
mov A,lo_TH0 ;borrow in MSB?
subb A,#000
mov lo_TH0,A
jnc ca_crh ;no borrow, so result still pos.
mov lo_TL0,#001 ;timing is too short, so take minimum
mov lo_TH0,#000 ;value, and store temp. in lo_t0
ca_crh: clr C ;timing correction for hi_tmr0
mov A,hi_TL0 ;hi_TL0 - proc_tm
subb A,#proc_tm
mov hi_TL0,A
mov A,hi_TH0 ;borrow in MSB?
subb A,#000
mov hi_TH0,A
jnc ca_crhv ;no borrow, so result still pos.
mov hi_TL0,#001 ;timing is too short, so take minimum
mov hi_TH0,#000 ;value, and store temp. in hi_t0
ca_crhv: clr C ;timing correction for hivdtmr0
mov A,hivdTL0 ;hivdTL0 - proc_tm
subb A,#proc_tm
mov hivdTL0,A
mov A,hivdTH0 ;borrow in MSB?
subb A,#000
mov hivdTH0,A
jnc ca_conv ;no borrow, so result still pos.
mov hivdTL0,#001 ;timing is too short, so take minimum
mov hivdTH0,#000 ;value, and store temp. in hivdt0
ca_conv: clr A ;convert timer0 clk cycles to load values.
mov B,A ;So do substraction 0-lo_t0
clr C ;for lo_t0
subb A,lo_TL0
mov lo_TL0,A
mov A,B
subb A,lo_TH0
mov lo_TH0,A
clr C ;and same for hi_t0
mov A,B
subb A,hi_TL0
mov hi_TL0,A
mov A,B
subb A,hi_TH0
mov hi_TH0,A
clr C ;and same for hivdtmr0
mov A,B
subb A,hivdTL0
57

mov hivdTL0,A
mov A,B
subb A,hivdTH0
mov hivdTH0,A
ret
;*************************************************
;* calib -> shift_wv *
;* Calculates the proper counter rate for sensor *
;* nothing *
;* measures period on external interrupt input (sensor), during *
;* sensctrl in hi-state *
;* lo transition on _INT0 or sensor *
;* At EXTI0 #samples (in R3) are counted downwards *
;* 2: Int. call to TIMER1 happens when TH1 has an overflow *
;* At TIMER1 #overflows are counted in OP_1 *
;* Timer0 keeps counting from 0 upwards *
;* measurement is ready when R3 reaches 0 *
;* *
;* prd is in timer counting rate *
;* timer1 counts in clk/ccpins *
;* prd is till where counter1/num_per reached when R3:=0 *
;* *
;* uses EXT0 and TIMER1 interrupt (and of course timer1 itself) *
;******************************************************************
freqcap:
clr EA ;disable all interrupts
setb sensctrl ;put piezo into free running frequency
fr_1: jnb sensor,fr_1 ;stabilise free running oscillation
fr_2: jb sensor,fr_2 ;loop during sensor is hi
fr_3: jnb sensor,fr_3 ;loop during sensor is lo
fr_4: jb sensor,fr_4 ;loop during sensor is hi
fr_5: jnb sensor,fr_5 ;loop during sensor is lo
58

fr_6: jb sensor,fr_6 ;loop during sensor is hi
mov R3,#num_per ;temporarily counter for number of captures
mov OP_0,#000 ;not used
mov OP_1,#000 ;possible carry from TH1 (updated in TIMER1)
setb EX0 ;enable EX0 (but not yet EA)
setb ET1 ;enable interrupt from timer1 overflow
fr_strt: jnb sensor,fr_strt ;loop during sensor is lo
fr_h2l: jb sensor,fr_h2l ;loop during sensor is hi
setb TR1 ;timer1 runs: start with measuring
clr IE0 ;no hardware to reset, so software does this task now
setb EA ;enable interrupts (vectored to EXT0)
fr_loop: cjne R3,#000,fr_loop ;wait for num_rep captured timingdata
;R3 is decreased through int. routine EXTI0
clr EA ;finished measuring, disable all interrupts
clr TR1 ;stop timer1
clr EX0 ;disable _INT0
clr ET1 ;disable interrupt from timer1
mov OP_2,TH1 ;timer1 MSB result in OP_2
mov OP_3,TL1 ;timer1 LSB result in OP_3
mov R2,#000 ;MSB of divider
mov R3,#num_per ;LSB of divider
acall Div_16 ;calc.: OP_(0..3) \ num_per =
mov prd_h,OP_2 ;store result counting in prd
mov prd_l,OP_3 ;store result counting in prd
mov C,wvmem ;put port sensctrl through carry in original state
mov sensctrl,C
setb EA ;enable interrupts
ret ;ready with measuring & calculating
;*******************************************************************************
;* wavectrl -> wvmem,vldsns *
;* interrupt from timer0 occurred, so there’s some work to do. Precalculated *
;* values for TH0 & TL0 determine how long the hi-state (in hi_TH0 & hi_TL0) *
;* for vldsns=0 and (hivdTH0 & hivdTL0) for vldsns=1 lasts, followed by how *
;* long lo-state (in lo_TH0 & lo_TL0) on output port sensctrl will last. *
;*

setb TR0 ;1 timer 0 runs, but enough time till int. comes
jb np_flag,ti_nnow ;2 if main is processing data, skip summing
mov tmp_A,A
mov tmp_C,C
mov A,OP_3 ;now enough time to perform 24 bits addition
add A,tmp_TL0 ;LSB
mov OP_3,A
mov A,OP_2
addc A,tmp_TH0 ;MSB
mov OP_2,A
jnc ti_fmty ;if there is no carry, routine is ready
inc OP_1 ;I say: 24 bits is really enough!
ti_fmty: djnz R3,ti_reta ;decrease counter for #num_per, jmp if not zero
setb np_flag ;flag to tell main interrupt routine is ready
ti_reta: mov C,tmp_C
mov A,tmp_A
ti_nnow: reti
;**** part I **** wvmem:=lo, vldsns no change ****
;put sensctrl and flag wvmem in low state, disable EX1 (no _int1), set timer0
ti_dolo: clr wvmem ;1 flag of sensctrl
clr sensctrl ;1 sensctrl goes lo
mov TH0,lo_TH0 ;2 timer 0 hi-byte
mov TL0,lo_TL0 ;2 timer 0 lo-byte
setb TR0 ;1 timer 0 runs
clr EX1 ;1 no _int1 allowed during lo state
reti
;*******************************************************************************
;* sens_stamp -> (from EXTI1) TH0, TL0 *
;* interrupt from _int1 occurred, so there’s some work to do. Sensor produced *
;* an transistion from hi to lo, so it’s position where that happened, rela- *
;* ted to the pos. of timer0, generating a control signal, must be stamped. *
;* (OP_0..3) * (R2,R3) *
;* *
;* Performs a multiply between a 32 and a 16 bit integer *
;* *
;*

;Now generate the next higher order byte
MOV B,OP_2
MOV A,R3
MUL AB
ADD A,TMP_2 ;low-order result
MOV TMP_2,A ;save
MOV A,B ;get high-order result
ADDC A,TMP_1 ;add now ACC with TMP_1 (was 0) with carry
MOV TMP_1,A ;save
JNC Mul_noCl
INC TMP_0 ;carry is set and ACC is FF, so TMP_0++
Mul_noCl:
;Now start working on the 3rd byte
MOV B,OP_1
MOV A,R3
MUL AB
ADD A,TMP_1 ;low-order result
MOV TMP_1,A ;save
MOV A,B ;get high-order result
ADDC A,TMP_0 ;include carry from previous operation
MOV TMP_0,A ;save
;Now finish off the highest order byte
MOV B,OP_0
MOV A,R3
MUL AB
ADD A,TMP_0 ;low-order result
MOV TMP_0,A ;save
;Forget about the high-order result, this is only 32 bit math!
MOV B,OP_3
MOV A,R2
MUL AB
ADD A,TMP_2 ;low-order result
MOV TMP_2,A ;save
MOV A,B ;get high-order result
ADDC A,TMP_1 ;include carry from previous operation
MOV TMP_1,A ;save
JNC Mul_noCh
INC TMP_0 ;carry is set and ACC is FF, so TMP_0++
Mul_noCh:
;Now the other half
MOV B,OP_2
MOV A,R2
MUL AB
ADD A,TMP_1 ;low-order result
MOV TMP_1,A ;save
MOV A,B ;get high-order result
ADDC A,TMP_0 ;include carry from previous operation
MOV TMP_0,A ;save
;The next one
MOV B,OP_1
MOV A,R2
MUL AB
ADD A,TMP_0 ;low-order result
;Now we are all done, move the TMP values back into OP
MOV OP_0,A ;save finally OP_0
MOV OP_1,TMP_1
MOV OP_2,TMP_2
MOV OP_3,TMP_3
RET
;********************************************************************
;* Div_16 -> (OP_0..3) / (R2,R3) *
;* *
;* Performs a division between a 32 and a 16 bit integer *
;* *
;*

;* *
;* R6 ;MSB, Remainder *
;* R7 ;LSB *
;* *
;* TMP_0 ;MSB *
;* TMP_1 ; *
;* TMP_2 ; *
;* TMP_3 ;LSB *
;* *
;* A and B registers are used in routine *
;********************************************************************
Div_16:
;This divides the 32 bit OP register by the value supplied
MOV R6,#0
MOV R7,#0 ;zero out partial remainder
MOV TMP_3,R6
MOV TMP_2,R6
MOV TMP_1,R6
MOV TMP_0,R6
MOV B,#32 ;loop count
;This begins the loop
Div_loop:
CALL Shift_D ;shift the dividend and return MSB in C
MOV A,R7 ;shift carry into LSB of partial remainder
RLC A
MOV R7,A
MOV A,R6
RLC A
MOV R6,A
;now test to see if R6:R7 >= R2:R3
CLR C
MOV A,R6 ;subtract R2 from R6 to see if R2 < R6
SUBB A,R2 ;A = R6 - R2, carry set if R6 < R2
JC Cant_sub
;at this point R6>R2 or R6=R2
JNZ Can_sub ;jump if R6>R2
;if R6 = R2, test for R7>=R3
CLR C
MOV A,R7
SUBB A,R3 ;A = R7 - R3, carry set if R7 < R3
JC Cant_sub
Can_sub:
;subtract the divisor from the partial remainder
CLR C
MOV A,R7
SUBB A,R3 ;A = R7 - R3
MOV R7,A
MOV A,R6
SUBB A,R2 ;A = R6 - R2 - Borrow
MOV R6,A
SETB C ;shift a 1 into the quotient
JMP Quot
Cant_sub:
;shift a 0 into the quotient
CLR C
Quot:
;shift the carry bit into the quotient
CALL Shift_Q
;Test for completion
DJNZ B,Div_loop
;Now we are all done, move the TMP values back into OP
MOV OP_3,TMP_3
MOV OP_2,TMP_2
MOV OP_1,TMP_1
MOV OP_0,TMP_0
RET
Shift_D:
;shift the dividend one bit to the left and return the MSB in C
CLR C
62

Shift_Q:
MOV A,OP_3
RLC A
MOV OP_3,A
MOV A,OP_2
RLC A
MOV OP_2,A
MOV A,OP_1
RLC A
MOV OP_1,A
MOV A,OP_0
RLC A
MOV OP_0,A
RET
;shift the quotient one bit to the left and shift the C into LSB
MOV A,TMP_3
RLC A
MOV TMP_3,A
MOV A,TMP_2
RLC A
MOV TMP_2,A
MOV A,TMP_1
RLC A
MOV TMP_1,A
MOV A,TMP_0
RLC A
MOV TMP_0,A
RET
;*****************************************************************************
;* linearization table *
;* array of 256 elements *
;* converting to linear output *
;*****************************************************************************
lintbl: DB 000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000
DB 000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000
DB 000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000
DB 000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000
DB 000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000
DB 000,000,000,000,000,000,001,001,001,001,002,002,002,003,003,003
DB 003,004,004,004,005,005,005,006,006,006,006,007,007,007,008,008
DB 008,009,009,009,010,010,010,011,011,011,012,012,012,013,013,014
DB 014,014,015,015,015,016,016,017,017,017,018,018,018,019,019,020
DB 020,020,021,021,022,022,023,023,023,024,024,025,025,026,026,027
DB 027,028,028,029,029,029,030,030,031,031,032,032,033,034,034,035
DB 035,036,036,037,037,038,039,039,040,040,041,042,042,043,043,044
DB 045,045,046,047,047,048,049,050,050,051,052,053,053,054,055,056
DB 056,057,058,059,060,061,062,063,064,064,065,066,067,068,069,071
DB 072,073,074,075,076,077,079,080,081,083,084,085,087,088,090,091
DB 093,095,097,098,100,102,104,106,108,111,113,116,118,121,124,127
END
63

Sourcecode van het midifile-conversieprogramma
Voor het conversieprogramma hebben we gebruik gemaakt van een programma dat we eerder geschreven
hadden op een Atari ST in Pure-C (Borland C). Voor de PC moesten we de functies die specifiek
te maken hadden met vensters en de afhandeling van de muis omzetten, zodat deze aan MS-Windows
voldeed. Daarnaast hebben we bepaalde functies omgezet in methoden behorend bij de class CMyDlg.
In vergelijking met Ansi-C hebben we hier een groot voordeel, doordat we functionaliteit van bijelkaar
horende methodes kunnen samenvoegen. Bovendien blijft het programmeren van de grafische schil
daaromheen overzichtelijk. We programmeren in Microsoft Visual C++ (2003).
Het stroomdiagram waarin we de methode Convert beschrijven, behandelen we in hoofdstuk 5.
Een overzicht van alle methoden die in de class CMyDlg voorkomen:
Methoden voor de uitvoer naar het scherm GetMsg, SaveMsg
Methoden voor het vragen van een filenaam voor de invoer- en uitvoerfile FileODlg, FileSDlg
Methode voor het converteren van een MIDI File naar een textbestand Convert
Alle constanten en ‘#define’-waarden staan in de bijbehorende headerfile ‘MyDlg.h’:
#pragma once // just a compiler directive
#define MHDR 0 // different kind of headers
#define MSIG 1
#define MTRK 2
#define HDR 0 // kind of metaevents (META_TP)
#define HBL 1
#define FMT 2
#define NTB 3
#define RES 4
#define SHDR 5
#define SHL 6
#define STAIL 7
#define THDR 8
#define TRKL 9
#define TTAIL 10
#define FINISH 11
#define ERR 12
#define MIDIEVNT 0 // kind of events, nb. second is running status
#define SYSEXEVNT 2
#define MTAEVNT 4
#define META_FF 0 // order to parse metaevent
#define META_TP 1
#define META_LEN 2
#define META_DATA 3
#define SQN 0 // kind of metaevents (META_TP)
#define TXT 1
#define COPY 2
#define SQTRNM 3
#define INSTRNM 4
#define LYRIC 5
#define TXTMRK 6
#define TXTCPT 7
#define EOTR 0x2f
#define TEMPO 0x51
#define SMPTE 0x54
#define TMSIG 0x58
#define KEYSG 0x59
#define SEQSP 0x7f
#define AFTER_TOUCH 0x0d // kind of midi channel commands with 1 data byte
#define PRG_CHNG 0x0c
#define NOTE_ON 0x09 // kind of midi channel commands with 2 data byte
64

#define NOTE_OFF 0x08
//***************************************************************************
// class CMyDlg
// this class uses five or so methods:
// GetMsg(int) Delivers message nr...
// SaveMsg(CString) Stores message in list. Last list item is nr. maxL-1
// FileODlg Asks user for filename to read from
// FileSDlg Asks user for filename to write to
// Convert Converts a MIDI File to TXT File
class CMyDlg
{
public:
CMyDlg(void); // constructor
CString GetMsg(int i); // ALWAYS DO A FULL REBUILD AFTER MODIFYING A CONST!!!
const static int maxL=16; // maximum number of rows in the text output dialog
const static int maxP=260; // maximum number of characters in a path+filename
const static int xOD=10; // x- left top coordinate output dialog
const static int yOD=144; // y- left top coordinate output dialog
const static int hSZ=461; // x- right bot coordinate output dialog
const static int vSZ=421; // y- right bot coordinate output dialog
void SaveMsg(CString msg);
bool FileODlg(void); // filename->FONm, return=succes
bool FileSDlg(void); // filename->FSNm, return=succes
CString FONm; // Member with path+filename+extension input file
CString FOLp; // Member with filename+extension
CString FOFn; // Member with filename
CString FOEx; // Member with extension
CString FSNm; // Member with path+filename output file
CString FSPt; // Member with path only
CString FSLp; // Member with filename+extension
CString FSFn; // Member with filename
CString FSEx; // Member with extension
bool Convert(void); // Do Conversion midifile 2 Txt
private:
int MsgCount;
CString Msgs[maxL+1];
};
De class CMyDlg met ondermeer de methode Convert die de conversie van een MIDI File afhandelt:
//********************************************************
// Class MyDlg.cpp
//
#
#include “StdAfx.h”
#include “MyDlg.h”
CMyDlg::CMyDlg(void)
{
MsgCount=0;
for (int i=0;i

ool CMyDlg::FileODlg(void)
{
bool os; // os records succes of GetOpenFileName
char tmp[maxP]; // temporary store for Path+Filename+Extension
OPENFILENAME ofn; // structure to FILE ofn
}
ZeroMemory(&ofn, sizeof(ofn));
ofn.lStructSize = sizeof(ofn);
ofn.lpstrFilter = “Standard MIDI files\0*.MID\0ALL\0*.*\0”;
ofn.lpstrFile = tmp;
ofn.lpstrFile[0] = ‘\0’; // Set lpstrFile[0] to ‘\0’ so that GetOpenFileName
// does not use contents of szFile to initialize
ofn.nMaxFile = maxP; // Max. length of filename. Must be declared!!
ofn.Flags = OFN_EXPLORER | OFN_FILEMUSTEXIST | OFN_HIDEREADONLY;
os=(GetOpenFileName(&ofn)==TRUE);
if (os)
{
FONm=tmp; // see declaration for explanation of these members
FOLp=tmp+ofn.nFileOffset;
FOFn=FOLp.Left(ofn.nFileExtension-ofn.nFileOffset-1);
FOEx=tmp+ofn.nFileExtension;
}
return (os); // check if file was selected. If selected, nResult=True
bool CMyDlg::FileSDlg(void) // char array for path + file name
{
bool os; // os records succes of GetOpenFileName
char tmp[maxP]; // temporary store for Filename
OPENFILENAME ofn; // structure to FILE ofn
ZeroMemory(&ofn, sizeof(ofn));
ofn.lStructSize = sizeof(ofn);
ofn.lpstrFilter = “Text Files (*.txt)\0*.txt\0ALL\0*.*\0”;
ofn.lpstrFile = tmp;
ofn.lpstrFile[0] = ‘\0’; // Set lpstrFile[0] to ‘\0’ so that GetOpenFileName
// does not use the contents of szFile to initialize
ofn.nMaxFile = maxP;
ofn.Flags = OFN_EXPLORER | OFN_PATHMUSTEXIST | OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT;
os=(GetSaveFileName(&ofn)==TRUE);
if (os)
{
FSNm=tmp; // see declaration for explanation of these members
FSLp=tmp+ofn.nFileOffset;
FSFn=FSLp.Left(ofn.nFileExtension-ofn.nFileOffset-1);
FSEx=tmp+ofn.nFileExtension;
FSPt=FSNm.Left(ofn.nFileOffset);
}
return (os); // check if file was selected. If selected, nResult=True
}
bool CMyDlg::Convert(void)
{
SaveMsg(“Analyzing File...”+FOLp);
FILE *fp,*o;
CString bsenm; // basename for output files
CString outnm; // name for output files
CString ascnum; // name for ascii extension
int c; // readed byte always stored in c
int i; // counter to order the readed bytes
int head; // kind tells function whether header or track
int track; // every time a new track comes, track ++
char what2do; // what2do tells function what to do with the byte
char mfmt; // file tells type of midi file (0,1 or 2)
int mres; // resolution of the delta-time, in ticks/quarter note
unsigned long chunkl; // length of chunk (4 bytes max.)
char dtm; // flag for status of reading. TRUE: read delta time
unsigned long vrl; // result of variable length calculation
unsigned long sdtm; // savereg. for temporarily storing delta time
unsigned long cumdtm; // cumulative deltatime
66

char evtdsp; // flag for valid event or invalid. FALSE means invalid
char evtknd; // tells function what kind of event. see #define
unsigned long mvrl; // length of specific meta event
char meta; // meta tells function what2do with byte from meta event
char metaevnt; // type of meta event
CString stri; // temporary holder for string converted integer
char mcmd; // tells function what kind of midi command
char mch; // with channel commands, this gives the channel
char cmdsize; // tells function of many bytes midi command consists
char data1; // first byte after midi command
char data2; // second byte after midi command
char tmp[]=”MThd0006MTrk”; // Reserved keywords in a standard midi file
i = 0; // increased when next byte belongs, when not: reset
chunkl = 0;
vrl = 0;
mvrl = 0;
metaevnt= 0; // see #define
cmdsize = 0;
cumdtm = 0;
what2do = HDR; // begin with analysing MThd
head = MHDR; // difference between format 0, 1 and 3; see #define
track = 0; // first track will be track 0
if ((fp = fopen(FONm, “rb”)) == NULL) return(FALSE);
//
bsenm=FSFn+”_0”;
while ( ( c=getc(fp)) != EOF)
switch (head)
{
case MHDR:
{
if (what2do!=ERR) // process header data if head == TRUE
switch (what2do)
{
case HDR:
{
if ( tmp[i] == (char)c ) i++;
else
{
SaveMsg(“Sorry, header is not midi file standard”);
what2do=ERR;
}
if (i==4) // MThd had been found succesfully
{
SaveMsg(“Header found”);
i=0;
what2do++;
}
break;
}
case HBL:
{
if ( tmp[i + 4]-’0’==(char)c ) i++; // search for numbers 0006 in header
else
{
SaveMsg(“Sorry, header length is not midi file standard”);
what2do=ERR;
}
if (i==4) // header length had been found succesfully
{
SaveMsg(“Header length found”);
i=0;
what2do++;
}
break;
}
case FMT:
{
if (i==0) {i++; break;}
67

if (i==1)
{
(char)mfmt=c;
i=0;
what2do++;
SaveMsg(“midi file format: “+mfmt);
}
break;
}
case NTB:
{
if (i==0) {i++; break;}
if (i==1)
{
i=0;
what2do++;
stri.Format(“number of tracks: %d”,c);
SaveMsg(stri);
}
break;
}
case RES:
{
if (i==0) {mres=c; i++; break;}
if (i==1)
{
mres=256*mres+c;
i=0;
what2do++;
if (mfmt==0) head=MTRK;
if (mfmt==1) head=MSIG; // in format 1 exist time/signature track
stri.Format(“number of ticks per quarter-note: %d”,mres);
SaveMsg(stri);
}
break;
}
} // escape from switch (what2do)
// endif (what2do!=ERR)
break; // escape from case MHDR
}
case MSIG:
{
if (mfmt==1 && what2do!=ERR) // process time/signature tempo track data in format 1
{
switch (what2do)
{
case SHDR:
{
if ( tmp[i + 8] == (char)c ) i++;
else
{
SaveMsg(“Sorry, time/signature trackheader is not according to midi file standard”);
what2do=ERR;
}
if (i==4) // MTrk had been found succesfully
{
SaveMsg(“time/signature trackheader found”);
i=0;
what2do++;
}
break;
}
case SHL:
{
chunkl=(chunkl

dtm=TRUE;
vrl=0;
what2do++;
}
break;
}
case STAIL: // need only tempo,if more needed,change case META_DATA
{
if (chunkl) chunkl--;
if (dtm) // read delta time
{
if (c & 0x80) vrl=(vrl

else
{
SaveMsg(“error, meta event type “+stri+” is bigger than 127”);
what2do=ERR;
}
break;
}
case META_LEN:
{
if (c & 0x80) mvrl=(mvrl

what2do++;
}
break;
}
case TRKL:
{
chunkl=(chunkl

switch(evtknd)
{
case MIDIEVNT: //(in running status vrl is initialized with cmdsize)
{
if (!vrl) // if 1st byte is midi cmd, init. variables cmdsize,mcmd
{
cmdsize=2; // most midi channel commands have 2 data bytes
// in midi-file only sys excl and common are supported
// ; no sys. realtime!
mch=c & 0x0f; // get midi channel
mcmd=c >> 4; // filter out midi channel, shift 4 places to the right
switch( mcmd ) // test for commands with only 1 byte data
{
case AFTER_TOUCH: cmdsize=1; break;
case PRG_CHNG: cmdsize=1; break;
} // endswitch (c)
vrl=cmdsize; // initialize vrl
} // end if (!vrl)
else // proces following byte(s) after midi command byte
{
if(cmdsize==1)data1=c; // need only this byte with command mcmd
if(cmdsize==2)
{
if (vrl==2) data1=c;
else data2=c;
}
vrl--;
if (!vrl) dtm=TRUE; // ready with event, find delta time
} // end else if(!vrl)
break; // end case MIDIEVNT
}
case SYSEXEVNT:
break;
case MTAEVNT:
{
switch (meta)
{
case META_FF:
{
meta++; // ignore this byte ff, next byte will be type
break;
}
case META_TP:
{
(char)metaevnt=c;
if ( metaevnt

}
{
if (mvrl) mvrl--;
switch (metaevnt)
{
case SQTRNM:
{
putc((char)c,o); // write text meta evnt
break;
}
}
if (!mvrl) // start again with finding delta-time before event
{
dtm=TRUE;
vrl=0;
evtdsp=FALSE;
switch (metaevnt) // finish of with CR/LF etc.
{
case SQTRNM:
putc(10,o); // finish off with CR/LF
ascnum.Format(“%d”,mres);
fputs(ascnum,o);
putc(10,o); // finish off with CR/LF
break;
}
} // end switch (metaevnt)
break; // end case META_DATA
}
} // end switch(meta)
break; // end case MTAEVNT
}
} // end switch evntknd
if(dtm && (evtknd==MIDIEVNT)) // show package of data; only be checked if !dtm
{
switch (cmdsize) // cmdsize 0 is not specified in midi files
{
case 1: // command with 1 byte data: mcmd, data1
{
sdtm+=cumdtm;
cumdtm=sdtm;
sdtm=250*sdtm/mres; // value range: [0,10000>
ascnum.Format(“%d”,sdtm);
fputs(ascnum,o);
putc(‘,’,o); // put division marker
ascnum.Format(“%d”,data1);
fputs(ascnum,o);
putc(10,o); // finish off with CR/LF
break;
}
case 2: // command with 2 bytes data
{
mch=mch;
data2=data2;
break;
}
} // end switch (cmdsize)
} // end if (dtm && ....)
} // end else (dtm)
if (!chunkl)
{
stri.Format(“finish with track %d”,track);
SaveMsg(stri);
i=0;
vrl=0;
cumdtm=0;
track++;
dtm=TRUE;
fclose(o); // ready with file
what2do=THDR;
}
break; // end case TTAIL
73

} // end switch (what2do)
break;
} // escape from case MTRK
}
} // end switch (head)
// end while
fclose(fp);
return(what2do!=ERR);
}
74

MIDI File standaard
Het beheer van ondermeer de MIDI- en de MIDI File-standaard wordt door de MIDI Manufacturers
Association 1 gedaan. Een gedrukt document waarin de MIDI File-standaard beschreven wordt kan bij
die organisatie tegen betaling worden verkregen. Op het internet is er op verschillende lokaties echter
al voldoende informatie te vinden, over hoe MIDI Files zijn opgebouwd en hoe die kunnen worden
geanalyseerd. Een van die bronnen 15 voeg ik hier bij.
Standard MIDI Files 1.0 July, 1988
•Introduction
•Sequences, Tracks, Chunks: File Block Structure
•Chunk Descriptions
•Meta-Events
•Program Fragments and Example MlDI Files
Introduction
The document outlines the specification for MIDI Files. The purpose of MIDI Files is to provide a way
of interchanging time-stamped MIDI data between different programs on the same or different computers.
One of the primary design goals is compact representation, which makes it very appropriate for a
disk-based file format, but which might make it inappropriate for storing in memory for quick access
by a sequencer program. (It can be easily converted to a quickly-accessible format on the fly as files
are read in or written out.) It is not intended to replace the normal file format of any program, though it
could be used for this purpose if desired.
MIDI Files contain one or more MIDI streams, with time information for each event. Song, sequence,
and track structures, tempo and time signature information, are all supported. Track names and other
descriptive information may be stored with the MIDI data. This format supports multiple tracks and
multiple sequences so that if the user of a program which supports multiple tracks intends to move a
file to another one, this format can allow that to happen.
This spec defines the 8-bit binary data stream used in the file. The data can be stored in a binary file,
nibbleized, 7-bit-ized for efficient MIDI transmission, converted to Hex ASCII, or translated symbolically
to a printable text file. This spec addresses what’s in the 8-bit stream. It does not address how
a MIDI File will be transmitted over MIDI. It is the general feeling that a MIDI transmission protocol
will be developed for files in general and MIDI Files will used this scheme.
75

Sequences, Tracks, Chunks: File Block Structure
Conventions
In this document, bit 0 means the least significant bit of a byte, and bit 7 is the most significant. Some
numbers in MIDI Files are represented in a form called a variable-length quantity. These numbers are
represented 7 bits per byte, most significant bits first. All bytes except the last have bit 7 set, and the
last byte has bit 7 clear. If the number is between 0 and 127, it is thus represented exactly as one byte.
Here are some examples of numbers represented as variable-length quantities:
Number (hex) Representation (hex)
00000000 00
00000040 40
0000007F 7F
00000080 81 00
00002000 C0 00
00003FFF FF 7F
00004000 81 80 00
00100000 C0 80 00
00lFFFFF FF FF 7F
00200000 81 80 80 00
08000000 C0 80 80 00
0FFFFFFF FF FF FF 7F
The largest number which is allowed is 0FFFFFFF so that the variable-length representation must fit in
32 bits in a routine to write variable-length numbers. Theoretically, larger numbers are possible, but 2
x 108 96ths of a beat at a fast tempo of 500 beats per minute is four days, long enough for any deltatime!
Files
To any file system, a MIDI File is simply a series of 8-bit bytes. On the Macintosh, this byte stream
is stored in the data fork of a file (with file type ‘Midi’), or on the Clipboard (with data type ‘Midi’).
Most other computers store X-bit byte streams in files -- naming or storage conventions for those computers
will be defined as required.
Chunks
MIDI Files are made up of chunks. Each chunk has a 4-character type and a 32-bit length, which is
the number of bytes in the chunk. This structure allows future chunk types to be designed which may
easily be ignored if encountered by a program written before the chunk type is introduced. Your programs
should Expect alien chunks and treat them as if they weren’t there.
Each chunk begins with a 4-character ASCII type. It is followed by a 32-bit length, most significant
byte first (a length of 6 is stored as 00 00 00 06). This length refers to the number of bytes of data
which follow: the eight bytes of type and length are not included. Therefore, a chunk with a length of 6
would actually occupy 14 bytes in the disk file.
This chunk architecture is similar to that used by Electronic Arts’ IFF format, and the chunks described
herein could easily be placed in an IFF file. The MIDI File itself is not an IFF file: it contains no nested
chunks, and chunks are not constrained to be an even number of bytes long. Converting it to an IFF
file is as easy as padding odd-length chunks, and sticking the whole thing inside a FORM chunk.
MIDI Files contain two types of chunks: header chunks and track chunks. A header chunk provides a
minimal amount of information pertaining to the entire MIDI file. A track chunk contains a sequential
stream of MIDI data which may contain information for up to 16 MIDI channels. The concepts of
76

multiple tracks, multiple MIDI outputs, patterns, sequences, and songs may all be implemented using
several track chunks.
A MIDI file always starts with a header chunk, and is followed by one or more track chunks.
MThd
MTrk
MTrk
...
Chunk Descriptions
Header Chunks
The header chunk at the beginning of the file specifies some basic information about the data in the
file. Here’s the syntax of the complete chunk:
=
As described above, is the four ASCII characters ‘MThd’; is a 32-bit representation
of the number 6 (high byte first).
The data section contains three 16-bit words, stored most-significant byte first. The first word, format,
specifies the overall organisation of the file. Only three values of format are specified:
0 the file contains a single multi-channel track
1 the file contains one or more simultaneous tracks (or MIDI outputs) of a sequence
2 the file contains one or more sequentially independent single-track patterns
More information about these formats is provided below.
The next word, ntrks, is the number of track chunks in the file. It will always be 1 for a format 0 file.
The third word, division, specifies the meaning of the delta-times. It has two formats, one for metrical
time, and one for time-code-based time:
========================================
| 0 | ticks per quarter-note |
========================================
========================================
| 1 | neg SMPTE format| ticks per frame|
========================================
15 14 8 7 0
If bit 15 of division is a zero, the bits 14 thru 0 represent the number of delta-time ticks” which make
up a quarter-note. For instance, if division is 96, then a time interval of an eighth-note between two
events in the file would be 48.
If bit 15 of division is a one, delta-times in a file correspond to subdivisions of a second, in a way
consistent with SMPTE and MIDI time code. Bits 14 thru 8 contain one of the four values -24, -25,
-29, or -30, corresponding to the four standard SMPTE and MIDI time code formats (-29 corresponds
to 30 drop frame), and represents the number of frames per second. These negative numbers are stored
in two’s complement form. The second byte (stored positive) is the resolution within a frame: typical
77

values may be 4 (MIDI time code resolution), 8, 10, 80 (bit resolution), or 100. This system allows
exact specification of time- code-based tracks, but also allows millisecond-based tracks by specifying
25 frames/sec and a resolution of 40 units per frame. If the events in a file are stored with bit resolution
of thirty-frame time code, the division word would be E250 hex.
Formats 0, 1, and 2
A Format 0 file has a header chunk followed by one track chunk. It is the most interchangeable representation
of data. It is very useful for a simple single-track player in a program which needs to make
synthesisers make sounds, but which is primarily concerned with something else such as mixers or
sound effect boxes. It is very desirable to be able to produce such a format, even if your program is
track-based, in order to work with these simple programs. On the other hand, perhaps someone will
write a format conversion from format 1 to format 0 which might be so easy to use in some setting that
it would save you the trouble of putting it into your program.
A Format 1 or 2 file has a header chunk followed by one or more track chunks. Programs which support
several simultaneous tracks should be able to save and read data in format 1, a vertically one-dimensional
form, that is, as a collection of tracks. Programs which support several independent patterns
should be able to save and read data in format 2, a horizontally one-dimensional form. Providing these
minimum capabilities will ensure maximum interchangeability.
In a MIDI system with a computer and a SMPTE synchroniser which uses Song Pointer and Timing
Clock, tempo maps (which describe the tempo throughout the track, and may also include time signature
information, so that the bar number may be derived) are generally created on the computer. To
use them with the synchroniser, it is necessary to transfer them from the computer. To make it easy
for the synchroniser to extract this data from a MIDI File, tempo information should always be
stored in the first MTrk chunk. For a format 0 file, the tempo will be scattered through the track and
the tempo map reader should ignore the intervening events; for a format 1 file, the tempo map must
be stored as the first track. It is polite to a tempo map reader to offer your user the ability to make a
format O file with just the tempo, unless you can use format 1.
All MIDI Files should specify tempo and time signature. If they don’t, the time signature is assumed to
be 4/4, and the tempo 120 beats per minute. In format 0, these meta-events should occur at least at the
beginning of the single multi-channel track. In format 1, these meta-events should be contained in the
first track. In format 2, each of the temporally independent patterns should contain at least initial time
signature and tempo information.
We may decide to define other format IDs to support other structures. A program encountering an
unknown format ID may still read other MTrk chunks it finds from the file, as format 1 or 2, if its user
can make sense of them and arrange them into some other structure if appropriate. Also, more parameters
may be added to the MThd chunk in the future: it is important to read and honour the length, even
if it is longer than 6.
Track Chunks
The track chunks (type MTrk) are where actual song data is stored. Each track chunk is simply a
stream of MIDI events (and non-MIDI events), preceded by delta-time values. The format for Track
Chunks (described below) is exactly the same for all three formats (O, 1, and 2: see “Header Chunk”
above) of MIDI Files.
Here is the syntax of an MTrk chunk (the + means “one or more”: at least one MTrk event must be
present):
=
78

The syntax of an MTrk event is very simple:
=
is Stored as a variable-length quantity. It represents the amount of time before the following
event. If the first event in a track occurs at the very beginning of a track, or if two events occur
simultaneously, a delta-time of zero is used. Delta-times are always present. (Not storing delta-times
of 0 requires at least two bytes for any other value, and most delta-times aren’t zero.) Delta-time is
in some fraction of a beat (or a second, for recording a track with SMPTE times), as specified in the
header chunk.
= | |
is any MIDI channel message. Running status is used: status bytes of MIDI channel
messages may be omitted if the preceding event is a MIDI channel message with the same status. The
first event in each MTrk chunk must specify status. Delta-time is not considered an event itself: it is an
integral part of the syntax for an MTrk event. Notice that running status occurs across delta-times.
is used to specify a MIDI system exclusive message, either as one unit or in packets, or
as an “escape” to specify any arbitrary bytes to be transmitted. A normal complete system exclusive
message is stored in a MIDI File in this way:
FO
The length is stored as a variable-length quantity. It specifies the number of bytes which follow it, not
including the F0 or the length itself. For instance, the transmitted message F0 43 12 00 07 F7 would
be stored in a MIDI file as F0 05 43 12 00 07 F7. It is required to include the F7 at the end so that the
reader of the MIDI file knows that it has read the entire message.
Another form of sysex event is provided which does not imply that an F0 should be transmitted. This
may be used as an “escape” to provide for the transmission of things which would not otherwise be
legal, including system realtime messages, song pointer or select, MIDI Time Code, etc. This uses the
F7 code:
F7
Unfortunately, some synthesiser manufacturers specify that their system exclusive messages are to be
transmitted as little packets. Each packet is only part of an entire syntactical system exclusive message,
but the times they are transmitted at are important. Examples of this are the bytes sent in a CZ
patch dump, or the FB-01’s “system exclusive mode” in which microtonal data can be transmitted.
The F0 and F7 sysex events may be used together to break up syntactically complete system exclusive
messages into timed packets.
An F0 sysex event is used for the first packet an a series -- it is a message in which the F0 should be
transmitted. An F7 sysex event is used for the remainder of the packets, which do not begin with F0.
(Of course, the F7 is not considered part of the system exclusive message).
A syntactic system exclusive message must always end with an F7, even if the real-life device didn’t
send one, so that you know when you’ve reached the end of an entire sysex message without looking
ahead to the next event in the MIDI file. If it’s stored in one complete F0 sysex event, the last byte
must be an F7. If it is broken up into packets, the last byte of the last packet must be an F7. There also
must not be any transmittable MIDI events in between the packets of a multi-packet system exclusive
message. This principle is illustrated in the paragraph below.
Here is an example of a multi-packet system exclusive message: suppose the bytes F0 43 12 00 were
79

to be sent, followed by a 200-tick delay, followed by the bytes 43 12 00 43 12 00, followed by a 100tick
delay, followed by the bytes 43 12 00 F7, this would be in the MIDI File:
F0 03 43 12 00
81 48 200-tick delta-time
F7 06 43 12 00 43 12 00
64 100-tick delta-time
F7 04 43 12 00 F7
When reading a MlDI File, and an F7 sysex event is encountered without a preceding F0 sysex event
to start a multi-packet system exclusive message sequence, it should be presumed that the F7 event is
being used as an “escape” In this case, it is not necessary that it end with an F7, unless it is desired that
the F7 be transmitted.
specifies non-MIDI information useful to this format or to sequencers, with this syntax:
FF
All meta-events begin with FF, then have an event type byte (which is always less than 128), and then
have the length of the data stored as a variable-length quantity, and then the data itself. If there is no
data, the length is 0. As with chunks, future meta-events may be designed which may not be known to
existing programs, so programs must properly ignore meta-events which they do not recognise, and
indeed, should expect to see them. Programs must never ignore the length of a meta-event which they
do recognise, and they shouldn’t be surprised if it’s bigger than they expected. If so, they must ignore
everything past what they know about. However, they must not add anything of their own to the end of
a meta-event.
Sysex events and meta-events cancel any running status which was in effect. Running status does not
apply to and may not be used for these messages.
Meta-Events
A few meta-events are defined herein. It is not required for every program to support every meta-event.
In the syntax descriptions for each of the meta-events a set of conventions is used to describe parameters
of the events. The FF which begins each event, the type of each event, and the lengths of events
which do not have a variable amount of data are given directly in hexadecimal. A notation such as dd
or se, which consists of two lower-case letters, mnemonically represents an 8-bit value. Four identical
lower-case letters such as wwww refer to a 16-bit value, stored most-significant-byte first. Six identical
lower-case letters such as tttttt refer to a 24-bit value, stored most-significant-byte first. The notation
len refers to the length portion of the meta-event syntax, that is, a number, stored as a variable- length
quantity, which specifies how many data bytes follow it in the meta-event. The notations text and data
refer to however many bytes of (possibly text) data were just specified by the length.
In general, meta-events in a track which occur at the same time may occur in any order. If a copyright
event is used, it should be placed as early as possible in the file, so it will be noticed easily. Sequence
Number and Sequence/Track Name events, if present, must appear at time 0. An end-of-track event
must occur as the last event in the track.
Meta-events initially defined include:
80

FF 00 02 ssss Sequence Number
This optional event, which must occur at the beginning of a track, before any nonzero deltatimes,
and before any transmittable MIDI events, specifies the number of a sequence. In a
format 2 MIDI file, it is used to identify each “pattern” so that a “song” sequence using the Cue
message to refer to the patterns. If the ID numbers are omitted, the sequences’ locations in order
in the file are used as defaults. In a format 0 or 1 MIDI file, which only contain one sequence,
this number should be contained in the first (or only) track. If transfer of several multitrack
sequences is required, this must be done as a group of format 1 files, each with a different sequence
number.
FF 01 len text Text Event
Any amount of text describing anything. It is a good idea to put a text event right at the beginning
of a track, with the name of the track, a description of its intended orchestration, and any
other information which the user wants to put there. Text events may also occur at other times
in a track, to be used as lyrics, or descriptions of cue points. The text in this event should be
printable ASCII characters for maximum interchange. However, other character codes using
the high-order bit may be used for interchange of files between different programs on the same
computer which supports an extended character set. Programs on a computer which does not
support non- ASCII characters should ignore those characters. Meta event types 01 through
0F are reserved for various types of text events, each of which meets the specification of text
events(above) but is used for a different purpose:
FF 02 len text Copyright Notice
Contains a copyright notice as printable ASCII text. The notice should contain the characters
(C), the year of the copyright, and the owner of the copyright. If several pieces of music are in
the same MIDI file, all of the copyright notices should be placed together in this event so that it
will be at the beginning of the file. This event should be the first event in the first track chunk,
at time 0.
FF 03 len text Sequence/Track Name
If in a format 0 track, or the first track in a format I file, the name of the sequence. Otherwise,
the name of the track.
FF 04 len text Instrument Name
A description of the type of instrumentation to be used in that track. May be used with the MIDI
Prefix meta-event to specify which MIDI channel the description applies to, or the channel may
be specified as text in the event itself.
FF 05 len text Lyric
A lyric to be sung. Generally, each syllable will be a separate lyric event which begins Bt the
event’s time.
FF 06 len text Marker
Normally in a format 0 track, or the first track in a format 1 file. The name of that point in the
sequence, such as a rehearsal letter or section name (“First Verse”, etc.).
FF 07 len text Cue Point
A description of something happening on a film or video screen or stage at that point in the musical
score (“Car crashes into house”, “curtain opens”, “she slaps his face”, etc.)
FF 20 01 cc MIDI Channel Prefix
The MIDI channel (0-15) contained in this event may be used to associate a MIDI channel with
all events which follow, including System Exclusive and meta-events. This channel is “effective”
until the next normal MIDI event (which contains a channel) or the next MIDI Channel
Prefix meta-event. If MIDI channels refer to “tracks”, this message may help jam several tracks
into a format 0 file, keeping their non-MIDI data associated with a track. This capability is also
present in Yamaha’s ESEQ file format.
81

FF 2F 00 End of Track
This event is nor optional. It is included so that an exact ending point may be specified for the
track, so that it has an exact length, which is necessary for tracks which are looped or concatenated.
FF 51 03 tttttt Set Tempo, in microseconds per MIDI quarter-note
This event indicates a tempo change. Another way of putting “microseconds per quarter-note”
is “24ths of a microsecond per MIDI clock Representing tempos as time per beat instead of beat
per time allows absolutely exact long-term synchronisation with a time-based sync protocol
such as SMPTE time code or MIDI time code. This amount of accuracy provided by this tempo
resolution allows a four- minute piece at 120 bears per minute to be accurate within 500 usec at
the end of the piece. Ideally, these events should only occur where MIDI clocks would be located
- this convention is intended to guarantee, or at least increase the likelihood, of compatibility
with other synchronisation devices so that a time signature/tempo map stored in this format
may easily be transferred to another device.
FF 54 05 hr mn se fr ff SMPTE Offset
This event, if present, designates the SMPTE time at which the track chunk is supposed to start.
It should be present at the beginning of the track, that is, before any nonzero delta-times, and
before any transmittable MIDI events. The hour must be encoded with the SMPTE format, just
as it is in MIDI Time Code. In a format 1 file, the SMPTE Offset must be stored with the tempo
map, and has no meaning in any of the other tracks. The ff field contains fractional frames, in
l00ths of a frame, even in SMPTE-based tracks which specify a different frame subdivision for
delta-limes.
FF 58 04 nn dd cc bb Time Signature
The time signature is expressed as four numbers. nn and dd represent the numerator and denominator
of the time signature as it would be notated. The denominator is a negative power of
two: 2 represents a quarter-note, 3 represents an eighth-note, etc. The cc parameter expresses
the number of MIDI clocks in a metronome click. The bb parameter expresses the number of
notated 32nd-notes in a MIDI quarter-note (24 MIDI Clocks). This was added because there are
already multiple programs which allow the user to specify that what MIDI thinks of as a quarter-note
(24 clocks) is to be notated as, or related to in terms of, something else. Therefore, the
complete event for 6/8 time, where the metronome clicks every three eighth-notes, but there are
24 clocks per quarter-note, 72 to the bar, would be (in hex): FF 58 04 06 03 24 08
That is, 6/8 time (8 is 2 to the 3rd power, so this is 06 03), 36 MIDI clocks per dotted- quarter
(24 hex!), and eight notated 32nd-notes per MIDI quarter note.
FF 59 02 sf mi Key Signature
sf = -7: 7 flats
sf = -1: 1 flat
sf = 0: key of C
sf = 1: 1 sharp
sf = 7: 7 sharps
mi = 0: major key
mi = 1: minor key
82

FF 7F len data Sequencer-Specific Meta-Event
Special requirements for particular sequencers may use this event type: the first byte or bytes
of data is a manufacturer ID (these are one byte, or, if the first byte is 00, three bytes). As with
MIDI System Exclusive, manufacturers who define something using this meta-event should publish
it so that others may know how to use it. After all, this is an interchange format. This type
of event may be used by a sequencer which elects to use this as its only file format; sequencers
with their established feature-specific formats should probably stick to the standard features
when using this format.
Program Fragments and Example MlDI Files
Here are some of the routines to read and write variable-length numbers in MIDI Files. These routines
are in C, and use getc and putc, which read and write single 8-bit characters from/to the files infile and
outfile. An long is assumed to be 32 bits.
#define TRUE 1
WriteVarLen( long value ) {
long buffer;
buffer = value & 0x7f;
while ((value = 7) 0) {
buffer

Delta Time
(decimal)
Event Code
(hex)
Other Bytes
(decimal)
Comment
0 FF 58 04 04 02 24 08 4 bytes: 4/4 time, 24 MIDI clocks/click,
8 32nd notes/24 MIDI clocks
0 FF 51 03 500000 3 bytes: 500,000 μsec per quarter-note
0
0
0
0
0
96
96
192
0
0
0
0
C0
C1
C2
92
92
91
90
82
82
81
80
FF
05
46
70
48 96
60 96
67 64
76 32
48 64
60 64
67 64
76 64
2F 00
Ch. 1, Program Change 5
Ch. 2, Program Change 46
Ch. 3, Program Change 70
Ch. 3 Note On C2, forte
Ch. 3 Note On C3, forte
Ch. 2 Note On G3, mezzo-forte
Ch. 1 Note On E4, piano
Ch. 3 Note Off C2, standard
Ch. 3 Note Off C3, standard
Ch. 2 Note Off G3, standard
Ch. 1 Note Off E4, standard
Track End
The entire format 0 MIDI file contents in hex follow. First, the header chunk:
4D 54 68 64
00 00 00 06
00 00
00 01
00 60
MThd
chunk length
format 0
one track
96 per quarter-note
Then, the track chunk. Its header, followed by the events (notice that running status is used in places):
00
00
00
00
00
00
00
60
60
81 40
00
00
00
00
FF
FF
C0
C1
C2
92
91
90
82
81
80
FF
4D 54 72 6B
00 00 00 3B
58 04 04 02 18 08
51 03 07 Al 20
05
2E
46
30 60
3C 60
43 40
4C 20
30 40
3C 40
43 40
4C 40
2F 00
MTrk
chunk length (59)
time signature
tempo
running status
two-byte delta-time
running status
end of track
A format 1 representation of the file is slightly different. Its header chunk:
4D 54 68 64
00 00 00 06
00 01
00 04
00 60
MThd
chunk length
format 1
four tracks
96 per quarter-note
84

First, the track chunk for the time signature/tempo track. Its header, followed by the events:
00
00
83 00
FF
FF
FF
4D 54 72 6B
00 00 00 14
58 04 04 02 18 08
51 03 07 Al 20
2F 00
MTrk
chunk length (20)
time signature
tempo
end of track
Then, the track chunk for the first music track. The MIDI convention for note on/off running status is
used in this example:
00
81 40
81 40
00
C0
90
FF
4D 54 72 6B
00 00 00 10
05
4C 20
4C 00
2F 00
Then, the track chunk for the second music track:
00
60
82 20
00
C1
91
FF
4D 54 72 6B
00 00 00 0F
2E
43 40
43 00
2F 00
Then, the track chunk for the third music track:
00
00
00
83 00
00
00
C2
92
4D 54 72 6B
00 00 00 15
46
30 60
3C 60
30 00
3C 00
FF 2F 00
MTrk
chunk length (16)
Running status: note on, vel = 0
end of track
MTrk
chunk length (15)
running status
end of track
MTrk
chunk length (21)
running status
two-byte delta-time, running status
running status
end of track
85

Lijst van literatuur en andere bronnen
1. MIDI Manufacturers Association, http://www.midi/org
2. Elektuur, E-Inside , 6/2001, applications of ceramics in electronics, p.30 (Engelse versie)
3. http://www.pi.ws “Tutorial PZT Theory” P.4, Dynamic behavior.
4. “Kristall Kochbuch”, manuscript, Harald Albrecht, NDK Europe Ltd.
5. National Semiconductor, Application Note AN-400, a Study of the Crystal Oscillator for CMOS-
COPS
6. “Kristall Kochbuch”, manuscript, 06 - Oszillatorschaltungen mit Schwingquarzen, p. 18, Harald
Albrecht, NDK Europe Ltd.
7. “Kristall Kochbuch”, manuscript, Harald Albrecht, NDK Europe Ltd, activity dips p. 233
8. Oscillators for Microcontrollers, Intel Application Note AP-155, p.11
9. “Elektronische implementatiekunde”, p.227, dr. ir. G.C.M. Meyer, ISBN 90-407-1245-X
10. MCS51 Microcontroller Family User’s Manual, External Interrupts, p. 3-25, Order No.:272383-
002, Feb. 1994.
11. “Stützenloses Spiel auf der Bratsche”, p. 35-38, http://www.violavirtuoso.de/chinrest/stzeart.pdf,
Marc Nijdam
12. Medizinische Probleme bei Instrumentalisten, Ursache & Prävention, Christoph Wagner, 1995,
Verlag Laaber
13. H.Geschwinde, “Einführung in die PLL-Technik”, Vieweg, eerste druk 1978 en Th. Mollinga,
“De Phase Locked Loop, theorie en zijn toepassingen”, ‘n Educaboek, 1980
14. ASEM-51, W.W. Heinz, http://plit.de/asem-51/
15. MIDI File specification, http://www.omega-art.com/midi/mfiles.html
86