Analyse von Kraftsensor-Messwerten mit MATLAB zur Orts ... - Brichzin

2.1 Einführung - Aufbau und Funktion 1
Gymnasium Ottobrunn
Seminarfach Informatik
im Schuljahr 2006/07
Analyse von Kraftsensor-Messwerten
mit MATLAB ® zur Orts- und
In Kooperation mit der
Impulsbestimmung
Vorgelegt von:
Martin Pfaller
Waldparkstraße 39c
85521 Riemerling
am 17.08.2007
Prüfer: Peter Brichzin, StR
Fakultät für Elektrotechnik und Informationstechnik,
Institut für Mathematik und Datenverarbeitung
Betreuung: Prof. Dr.-Ing. Werner Wolf

2.1 Einführung - Aufbau und Funktion 2
Hiermit erkläre ich, Martin Pfaller, geboren am 19.08.1989 in München, dass ich
die vorliegende Seminararbeit selbst und nur unter Verwendung der angegebenen
Quellen verfasst habe.
……………………………………….….…. …………………………..
Datum, Ort Martin Pfaller
Besonderer Dank gilt Herrn Prof. Dr.-Ing. habil. Werner Wolf, Herrn Josef
Dochtermann und Herrn Wolfgang Weber, die durch ihre Unterstützung diese
Arbeit überhaupt erst ermöglicht haben.
II.

2.1 Einführung - Aufbau und Funktion 3
Zusammenfassung
Diese Seminararbeit stellt einen Arbeitsverlauf dar, der beschreibt, wie, aus den
sechs Kraftsensor-Messwerten einer Degenfechtstation der Ort und die Stärke
eines darauf einwirkenden Impulses bestimmt werden kann. Um dieses zu
bewerkstelligen, wurden zuerst sowohl statische als auch dynamische Messungen
durchgeführt. Die Messwerte wurden mit dem Programm MATLAB ® analysiert
und ausgewertet, um daraus Rückschlüsse auf dieses System zu ziehen. Aus den
Messwerten wurde durch die Informationen der Auswertung ein mathematisches
Modell des Systems erstellt, das es ermöglicht, dieses zu berechnen. Die
Ergebnisse dieser Arbeit sind verschiedene MATLAB ® -Programme zur
automatischen Auswertung von Messungen und ein Programm zur Berechnung
der oben gestellten Anforderungen.
III.

2.1 Einführung - Aufbau und Funktion 4
Inhaltsverzeichnis
1. Einführung ....................................................................................................... 5
2. Der Versuch ..................................................................................................... 6
2.1. Aufbau und Funktion ......................................................................................... 6
2.2. Vorgehensweise bei der Problemstellung ........................................................ 10
3. Statische Messung ......................................................................................... 12
3.1. Durchführung der Messung ............................................................................. 12
3.2. Auswertung und Ergebnisse der Messung ....................................................... 16
3.3. Erklärung des Programms zur automatischen Messauswertung ...................... 35
4. Dynamische Messung .................................................................................... 44
4.1. Durchführung der Messung ............................................................................. 44
4.2. Auswertung und Ergebnisse der Messung ....................................................... 44
4.3. Probleme bei der Berechnung .......................................................................... 49
5. Die Ortberechnung ........................................................................................ 50
5.1. Berechnung durch zwei Sensorgleichungen .................................................... 50
5.2. Berechnung durch mehrere Sensorgleichungen ............................................... 53
5.3. Berechnung bei variabler aufgebrachter Kraft ................................................. 54
5.4. Berechnung mit einer Linearkombination ....................................................... 55
6. Ergebnisse und Ausblick ............................................................................... 57
7. Anhang .......................................................................................................... 59
7.1. Abbildungsverzeichnis ..................................................................................... 59
7.2. Quelltext MATLAB ® -Programme ................................................................... 61
7.2.1. pfaller_auswertung_dynamisch.m ........................................................................... 61
7.2.2. pfaller_auswertung_messdaten.m ............................................................................ 71
7.2.3. pfaller_auswertung_statisch.m ................................................................................ 93
7.2.4. pfaller_flaechengleichung_2_funktionen.m ............................................................ 99
7.2.5. pfaller_gleichung_lin.m ......................................................................................... 102
7.2.6. pfaller_gleichung_pol.m ........................................................................................ 102
7.2.7. pfaller_linearkombination_felder.m ...................................................................... 103
7.2.8. pfaller_ortberechnung_impuls.m ........................................................................... 113
7.2.9. pfaller_solve_linearkombination.m ....................................................................... 125
7.2.10. pfaller_solve_sensorgleichungen.m .................................................................. 131
7.2.11. pfaller_solve_sensorgleichungen_felder.m ....................................................... 134

2.1 1.
Einführung - Aufbau und Funktion 5
1. Einführung
Gegenstand dieser Seminararbeit ist die Messdurchführung und Auswertung von
Messwerten aus Kraftsensoren. Hintergrund dieser Aufgabe ist eine Apparatur der
Universität der Bundeswehr München, deren Aufgabe es ist, Degenfechter auf
ihre Reaktionsschnelligkeit und Treffgenauigkeit zu trainieren. Die
Degenfechtstation wurde bereits im Rahmen einer Diplomarbeit erstellt, jedoch
besaß sie bislang ungenutzte Kraftsensoren, die für die Versuchsdurchführung
nicht benötigt wurden. Für die Auswertung des Fechtversuches werden zum einen
der Ort des Eintreffens, zum anderen der Impuls des Degenschlags benötigt. Diese
beiden Werte nur mit Hilfe der Kraftsensoren zu bestimmen war die Anforderung
an das Ergebnis dieser Seminararbeit. Diese Aufgabe verlangte als ersten Schritt
mittels selbst durchgeführter Messungen zunächst Informationen über das System
zu sammeln, sie in einem zweiten Schritt auszuwerten und darzustellen, und
letztendlich die oben genannten Anforderungen durch das Erstellen eines eigenen
Programms in MATLAB ® zu erfüllen. Die Themenstellung verbindet die Inhalte
der Fachgebiete der Physik, der Mathematik und der Informatik. Die Physik stellt
die Grundlagen des Versuches, wie die eines Hebelarmes oder eine Impulses, zur
Verfügung. Zum Lösen dieser Grundlagen greift die Physik wiederum auf die
Werkzeuge der Mathematik zurück, die damit genauso zur Analyse und
Berechnung der Messdaten beiträgt. Bewerkstelligt werden diese Aufgaben aber
erst durch die Informatik, hier durch das Programm MATLAB ® , das mit seiner
matrizenorientierten Arbeitsweise genau für Probleme dieser Art ausgelegt ist und
auch in der Praxis für diese Zwecke angewandt wird.

2.1 Der Versuch - Aufbau und Funktion 6
2. Der Versuch
2.1. Aufbau und Funktion
11
Abbildung 2-1: Die Degenfechtstation
7
5 6
3 4
9
1
2
1) Sensor ll
2) Sensor lr
3) Sensor ml
4) Sensor mr
5) Sensor ul
6) Sensor ur
7) horizontales
Lichtgitterpaar
8) vertikales
Lichtgitterpaar
9) Laser
10) Ultraschall-
sensor
11) Videoprojektor
Das Kernstück der Degenfechtstation ist eine ca. 80 cm breite und ca. 190 cm
hohe Plexiglasplatte, die in einen Aluminiumrahmen eingepasst ist (siehe
Abbildung 2-1). Sie hat die Aufgabe, die Schläge eines Fechters auf ein, mit
einem Videoprojektor (11) aufprojiziertes Ziel aufzunehmen und ist zu diesem
Zweck in einem senkrecht stehenden Stahlrahmen über sechs Kraftsensoren
aufgehängt. Vier dieser Sensoren befinden sich an den kurzen Seiten der
rechteckigen Platte, jeweils zwei an den oberen und unteren Seiten, ca. 15 cm von
den Ecken entfernt. Die restlichen beiden Sensoren befinden sich in der Mitte der
langen Seiten des Rechtecks, sind jedoch um 180° um ihre Längsachse verdreht
eingebaut und werden deshalb bei der Messaufzeichnung automatisch invertiert.
Die im folgenden verwendeten Sensorbezeichnungen lauten „ll“ („lower left“) (1),
für den Sensor in der Nähe der linken unteren Ecke, „lr“ („lower right“) (2), für
den Sensor in der Nähe der rechten unteren Ecke, „ml“ („middle left“) (3), für den
Sensor in der Mitte der linken langen Rechteckseite, „mr“ („middle right“) (4), für
den Sensor in der Mitte der rechten langen Rechteckseite, „ul“ („upper left“) (5),
8
10

2.1 Der Versuch - Aufbau und Funktion 7
für den Sensor in der Nähe der linken oberen Ecke und „ur“ („upper right“) (6),
für den Sensor in der Nähe der rechten oberen Ecke.
Abbildung 2-2: Eine Wägezelle (Sensor mr)
Die Art der Kraftsensoren ist eine Wägezelle (siehe Abbildung 2-2). Sie hat diese
Bezeichnung durch die Anwendung in Waagen, wo die Schwerkraft einer Masse
ermittelt wird, und besteht aus einem Kraftaufnehmer aus Aluminium, der sich bei
der Einwirkung eines Gewichts minimal verformt. Diese Verformung wird über
einen Dehnungsmessstreifen, der bei einer Deformation seinen elektrischen
Widerstand verändert, gemessen und damit in ein elektrisches Signal
umgewandelt.
Auf dem äußeren Stahlrahmen sind an jeder Seite Infrarotlichtgitter montiert ((7)
und (8)), die jeweils auf die gegenüberliegende Seite ausgerichtet sind. Die
einzelnen Fotodioden werden ständig mit einer Frequenz von 100Hz abgetastet,
um zu registrieren, ob diese das Lichtsignal der gegenüberliegenden Leuchtdioden
erhalten oder dieses durch einen Gegenstand im Lichtstrahl blockiert ist. Für das
Verständnis der nachfolgenden Diagramme ist es wichtig, sich in Erinnerung zu
behalten, dass der Ursprung des Koordinatensystems des Lichtgitters auf der dem
Fechter zugewandten Seite rechts unten liegt. Schlägt nun der Fechter mit seinem
Degen auf die Platte, wird der Lichtstrahl eines horizontalen und vertikalen
Diodenpaares unterbrochen, was von der Hardware des Gitters registriert und als
Ort des Eintreffens ausgegeben wird. Zusätzlich ist oben auf dem Stahlrahmen
mittig ein Ultraschall Abstandssensor angebracht (10), des Weiteren gibt es unten
in der Mitte, knapp über dem Fußboden, einen Laser (9) zur Erfassung des
Ausfallschrittes, den der Fechter beim Angriff auf die Platte ausführt. Auf der
dem Fechter abgewandten Seite der Apparatur ist ein lichtempfindlicher Sensor
angebracht, der den Zeitpunkt registriert, zu dem das Bildsignal für den Fechter
sichtbar wird. Dies ist nötig, da es auf dem Weg des Bildsignals durch die
Grafikkarte des angeschlossenen Computers bis hin zum Videoprojektor

2.1 Der Versuch - Aufbau und Funktion 8
Verzögerungen geben kann, und diese somit die Messung der Reaktionszeit des
Fechters verfälschen würden.
Um einen stabilen Stand der Apparatur zu gewährleisten und ein Nachgeben des
Rahmens bei einwirkenden Impulsen zu verhindern, ist der Stahlrahmen, an dem
die Plexiglasplatte aufgehängt ist, mit einem zum Unterboden parallelen
Stahlrahmen, der durch vier Saugnäpfe an den Ecken am Boden befestigt ist,
verschweißt und zusätzlich zweifach daran abgestrebt. Auf diesem Bodenrahmen
befindet sich auf der Seite hinter der Plexiglasplatte eine Holzplatte mit der
Messelektronik.
5 4 1 3
6
Abbildung 2-3: Die Messelektronik
Die Anschlusskabel der sechs Sensoren werden zunächst über BNC-
Verbindungen in zwei Messverstärker (siehe Abbildung 2-3 (1) und (2)) geführt
(ein Verstärker verarbeitet vier Kanäle), wo über zwei Potentiometer (6) pro
Kanal zum einen „Offset“, die Nullstellung des Sensors, und zum anderen „Gain“,
der Grad der Verstärkung des Signals, reguliert werden können. Diese Verstärker
wurden jedoch während der Messarbeiten durch einen neuen ersetzt, mehr dazu in
Kapitel 3.1. Weiterhin gibt es eine Hardware zur Verarbeitung der
Lichtgittersignale (4) und einen Lautsprecher (5) zur Signalisierung eines
Treffers. Alle Sensorkanäle laufen aus den Verstärkern in einem
Computerinterface (3) zusammen, welches über eine Schmittstelle mit dem
Computer verbunden ist. Dort ist das Programm DIAdem ® von National
Instruments installiert, das es ermöglicht, per Drag-and-Drop eine Oberfläche und
die dahinter stehende Verarbeitung der Messkanäle für die Durchführung von
Messungen zu erstellen. Verwendet wurden zwei verschiedene Messprogramme,
2
1) Messverstärker 1
2) Messverstärker 2
3) Computerinterface
4) Lichtgitterhardware
5) Lautsprecher
6) Potentiometer

2.1 Der Versuch - Aufbau und Funktion 9
für statische und dynamische Messungen, mehr dazu in dem Kapitel 3.1 bzw. 4.1.
Diese Programme sind nicht Teil der Seminararbeit, sondern wurden bereits fertig
vom Labor zur Verfügung gestellt.

2.2 Der Versuch - Vorgehensweise bei der Problemstellung 10
2.2. Vorgehensweise bei der Problemstellung
Bei Aufgabenstellungen, die, wie in diesem Fall, ein völlig unbekanntes System,
die Degenfechtstation, behandeln, ist es essentiell für die weitere Arbeit, zunächst
möglichst viele Informationen über das System aus Messungen zu erhalten. Zu
diesem Zweck wurde zunächst versuchsweise die obere Hälfte der Platte mit einer
konstanten Kraft vermessen, auch mit dem Nebeneffekt besser mit dem
Messvorgang und der Apparatur vertraut zu werden und diese gegebenenfalls zu
modifizieren, wie dies bei der späteren Einführung eines Messverstärkers mit
automatischer Offsetkorrektur geschehen ist. Die nächste Aufgabe bestand darin,
die große Menge an gesammelten Daten nach den gewünschten Gesichtspunkten,
die Messwerte der Mess- und Ruhepunkte, zu filtern und auszugeben. Aufgrund
leichter Bedienbarkeit, einfachem Umgang mit den Messdaten und Erfahrungen
im Umgang mit dem Programm wurden die Daten zunächst in verschiedensten
Formen in Microsoft Office Excel 2003 dargestellt und ausgewertet. Für den
weiteren Weg, mit dem Ziel den Ort aus den Kraftwerten berechnen zu können,
boten sich zwei Lösungsmöglichkeiten an: Zum einen ein theoretisches
physikalisches Grundmodell zusammenzustellen und anhand der Messungen nur
noch die plattenspezifischen Konstanten zu ermitteln, oder aber selbst zu
versuchen, die gemessenen Daten in ein oder mehrere mathematische Modelle zu
fassen. Die Entscheidung fiel auf den zweiten Weg, da die erste Methode nach
längeren Recherchen aufgrund ihrer Komplexität ausschied und den Umfang einer
Facharbeit weit übersteigen würde, bzw. generell die Möglichkeit einer
analytischen Lösung des Problems, eine Platte mit sechs beliebig verteilten
Auflagepunkten, nicht garantiert werden konnte, da Problemstellungen dieser Art
in der Praxis üblicherweise mit der Finiten Elemente Methode gelöst werden. Die
Herausforderung war nun, die einzelnen Sensorkurven in Gleichungen zu fassen,
genaueres dazu in Kapitel 3.2. Als es möglich war, den Ort aus den vorher
gesammelten Messdaten zu berechnen, war der nächste Schritt, diese Berechnung
auch bei verschiedenen einwirkenden Kräften möglich zu machen, weswegen die
Platte erneut, aber diesmal jedoch komplett, mit einem anderen Raster und vier
verschiedenen Kräften, vermessen wurde. Die letzte Erweiterung des Programms
bestand schließlich darin, vor die Ortberechnung einen Algorithmus
hinzuzufügen, der aus dem Zeit-Kraft-Verlauf der Sensoren bei einem, auf die
Platte einwirkenden Impuls eines Hubmagneten dessen Kraft ausliest, weshalb

2.2 Der Versuch - Vorgehensweise bei der Problemstellung 11
noch einmal vier Reihen der Platte mit verschiedenen Impulsen vermessen
wurden. Während der Arbeit wurden die einzelnen Methoden zur Ortsberechnung
immer wieder auf ihre Genauigkeit analysiert und verbessert. Zur einfacheren
bzw. automatischen Messauswertung wurden mit fortschreitender Arbeit und
fortschreitender Erfahrung im Umgang mit MATLAB ® immer mehr Aufgaben
von Excel in MATLAB ® verlegt, bis letztendlich ein Programm zum
automatischen Auswerten von Messungen entstand.

3.1 Statische Messung - Durchführung der Messung 12
3. Statische Messung
3.1. Durchführung der Messung
Vor Beginn der Messung muss anfangs ein Raster aus abzutastenden
Messpunkten festgelegt werden. Wichtig hierbei sind selbstverständlich
Messpunkte in einem regelmäßigen Abstand voneinander und gleiche Abstände
der äußeren Messpunkte zum Rand der Platte. Auch bedeutet ein zu feines Raster
einen erhöhten Zeitaufwand, ein zu grobes Raster lässt die Messung womöglich
zu ungenau werden. Als Extrema, also die äußersten noch auf der Plexiglasplatte
befindlichen Punkte, ließen sich in horizontaler Richtung die Punkte 5 und 81, in
vertikaler 1 und 187 messen. Die oben genannten Bedingungen werden am besten
mit einem 10 mal 10 Raster erfüllt, wobei in horizontaler Richtung 3, in vertikaler
Richtung 8 Einheiten vom Rand abgetrennt werden. Dies ergibt bei 8 Spalten und
18 Reihen eine Anzahl von 144 Messpunkten, von denen allerdings nur die obere
Hälfte gemessen wurde.
Abbildung 3-1: Die Messtechnik
1
4
3
2
1) Messgestell
2) Metallschiene
3) Schlitten
4) Kraftmesser

3.1 Statische Messung - Durchführung der Messung 13
Zur Messung selbst (siehe Abbildung 3-1) wird vor die Platte ein Gestell (1)
gesetzt, an dem eine Metallschiene (2) in verschiedenen Höhen festgeschraubt
werden kann. Auf dieser Schiene lässt sich ein horizontal auf der Schiene
bewegbarer Schlitten (3) anbringen, auf dem ein Kraftmesser (4) (siehe Abbildung
3-2) montiert ist, welcher zum Einstellen des gewünschten Gewichts über eine
Präzisionsschraube senkrecht zur Plattenoberfläche nach vorne und hinten
verschiebbar ist. Zum Messen wird die Schiene in die gewünschte Höhe gebracht,
mit dem Schlitten alle horizontalen Messpunkte von links nach rechts abgetastet
und die Schiene in der nächsten Höhe befestigt, bis damit alle vertikalen
Messpunkte erfasst sind.
Abbildung 3-2: Der Kraftmesser
Vor der Messung wurde bereits festgestellt, dass sich die Platte schon bei kleinen
Temperaturschwankungen verzieht, verursacht beispielsweise durch eine
Raumheizung oder eine offene Türe, und die Offset-Werte der Sensoren dadurch
ständigen Schwankungen unterliegen. Aus diesem Grund wurde folgender
Messablauf festgelegt:
Zu Beginn einer neuen Reihe, also einer neuen vertikalen Position der Schiene,
wird die Messaufzeichnung gestartet und der Schlitten mit dem Kraftmesser zum
ersten Messpunkt bewegt, wo zuerst die Platte in Ruhe, also ohne eine äußere
einwirkende Kraft, gemessen wird. Danach wird über die Präzisionsschraube,
durch Andrücken des Kraftsensors an die Platte, das Gewicht von 1000g
eingestellt und die Platte unter dieser Last gemessen. Zum Schluss wird die Last
wieder entfernt und die Platte noch einmal in Ruhe gemessen, bevor der
Kraftmesser zum nächsten Punkt bewegt wird. Sind alle Punkte einer Reihe

3.1 Statische Messung - Durchführung der Messung 14
vermessen, wird die Messaufzeichnung beendet, abgespeichert und für die nächste
Reihe wieder neu gestartet. Dies soll zu große Messdateien verhindern und bei
Defekten im System den Schaden begrenzen.
Während der Messung werden kontinuierlich die sechs Sensorspannungen und der
Ort (x- und y-Koordinate) mit DIAdem ® aufgezeichnet. Um aus dieser
Datenmenge wieder die Zeitpunkte der Messungen und Ruhepunkte zu finden,
werden zusätzlich die Kanäle „Ruhe vor“, „Messung“ und „Ruhe nach“
aufgezeichnet. Mittels eines Buttons auf der Messoberfläche für jeden dieser
Kanäle werden dort bei Betätigung Ausschläge mit der Amplitude eins und der
Dauer einer Sekunde aufgezeichnet und dadurch der Zeitpunkt der Messung für
die kommende Auswertung der Daten markiert.
Der Zeitaufwand für diese Messung betrug ca. vier Stunden. Den größten Anteil
daran hatte das Aufbringen des Gewichts auf die Messpunkte, da der am
Kraftmesser abgelesene Wert, bedingt durch die zu geringe Steifigkeit des
Messgestells in den oberen Bereichen, ständig variiert und mehrmals
nachkorrigiert werden muss, bis der Wert insofern konstant ist, dass er sich in der
Zeit bis zur Betätigung des „Mess“-Buttons nicht zu stark verändert. Angestrebt
wurde eine Genauigkeit von +/- 10g, jedoch stieg diese an manchen Punkten auf
+/- 20g. Schwierigkeiten bereitete auch die hohe Sensibilität des Messsystems,
das schon bei kleinen Bewegungen auf dem Fußboden sichtbare Veränderungen
der Werte zeigte, weshalb es während des Messens einer Last nicht möglich war,
seinen Standpunkt zu verändern.
Nach Auswertung dieser Messung (siehe Kapitel 3.2) war der nächste Schritt eine
Messung mit den Kräften 500g, 1000g, 2500g und 4000g pro Messpunkt, um das
Verhalten der Sensoren bei verschiedenen Kräften zu untersuchen. Auch wurde
ein Raster gewählt, dessen Ränder näher an den Plattenrändern liegen: die Punkte
haben horizontal einen Abstand von 9, das Raster geht von 7 bis 79, und vertikal
einen Abstand von 14, mit einem Raster von 184 bis 2. Dies ergibt eine Anzahl
von 126 Messpunkten, mit den verschiedenen Kräften sind es insgesamt 504
Messungen.
Mittlerweile wurden die beiden Messverstärker durch einen solchen mit einer
automatischen Korrektur des Offsets der Sensoren ersetzt. Über einen
Eingangskanal kann vom Computer aus im Verstärker zwischen den Zuständen
„hold off“, der Verstärker regelt mit einer Regelspannung den Offset ständig auf
Null herunter, und „hold on“, die Regelspannung wird gehalten und die

3.1 Statische Messung - Durchführung der Messung 15
Sensorkanäle werden mit der an einem Potentiometer eingestellten Verstärkung
ausgegeben, gewechselt werden. Durch den neuen Messverstärker mussten die
Sensoren über die Verstärkung ihrer Kanäle neu kalibriert werden. Dazu wurde
auf der Platte, möglichst nahe der Befestigung jedes Sensors, eine Last von 4000g
angebracht und die Verstärkung so eingestellt, dass der Sensor eine Spannung von
8V ausgab. Diese Kalibrierung wurde gewählt, da das Computerinterface
maximal 10V verarbeiten kann und der Kraftmesser Gewichte bis 5000g misst.
Jedoch ist dies eine sehr ungenaue Art der Kalibrierung, da die Sensoren
weiterhin mit der Platte verbunden sind und sich so ein Teil des zur Kalibrierung
verwendeten Gewichts auch auf die anderen Sensoren verteilt. Theoretisch
müssten die Sensoren zur Kalibrierung ausgebaut und anschließend wieder in das
System eingebaut werden, jedoch käme es auch hier durch den Aus- und Einbau
zu Verfälschungen. Auf diese Verfälschung wird in Kapitel 3.2 näher
eingegangen.
Als die erste Folge an Messungen nach ca. sechs Stunden und neun vermessenen
Spalten abgeschlossen war, stellte sich heraus, dass die Dateien der einzelnen
gemessenen Reihen teilweise exakt die gleiche Dateigröße hatten. Man stellte fest,
dass DIAdem ® die Messungen nur bis zu einer bestimmten Länge aufzeichnete,
Messungen die über diesen Zeitpunkt hinausgingen, wurden ab diesem dort
abgeschnitten. Aufgrund des Einsatzes des neuen Messverstärkers wurde bei
dieser Messung auch auf das Messen von Ruhepunkten verzichtet. Allerdings
zeigte sich, dass der Verstärker den Offset nicht komplett auf Null reduzierte,
sondern immer zwischen +/- 0,2V schwankte, was die Messung für eine
Auswertung unbrauchbar machte. Diese Messung wurde daraufhin mit den
gleichen Parametern, diesmal unter Verwendung von Ruherpunkten, für die
gesamte Platte wiederholt.

3.2 Statische Messung - Auswertung und Ergebnisse der Messung 16
3.2. Auswertung und Ergebnisse der Messung
Um sich einen Überblick über das Verhalten der Sensoren zu verschaffen, bestand
die erste Maßnahme beim Auswerten der aus der ersten statischen Messungen
gesammelten Daten darin, die Daten der einzelnen gemessenen Reihen in Excel-
Tabellen zu schreiben und zu versuchen, die Daten möglichst aussagekräftig
darzustellen.
Bei der Analyse der Ruhewerte zeigte sich, dass ein direkter Zusammenhang
zwischen dem Offset der Sensoren und der Raumtemperatur des Labors bestehen
muss. Diagramm 3-1 und Diagramm 3-2 (berechnet in
auswertung_zeile1_statisch.xls und auswertung_zeile9_statisch.xls) zeigen jeweils den
Mittelwert aus Ruhe-vor und Ruhe-nach, einmal der ersten gemessenen Reihe zu
Beginn der Messung und einmal der, vier Stunden später gemessenen, letzten
Reihe, in Abhängigkeit des horizontalen Ortes. Da diese Punkte der Reihe nach,
von links nach rechts, gemessen wurden, ist die umgekehrte x-Koordinate (Zur
Erinnerung: der Ursprung des Koordinatensystems liegt rechts unten) in etwa
direkt proportional zum Zeitverlauf. Zu Beginn und zwei weitere Male während
der Messung wurde der Messung wurde der Offset von Hand auf Null korrigiert.
Man erkennt nun in Diagramm 3-1, dass sich der Offset, nach der anfänglichen
Korrektur, während der Messreihe stark verändert. Dies liegt daran, dass vor dem
Start der Messung der Raum mit der Versuchsanordnung auf eine bestimmte
Temperatur aufgeheizt wurde. Mit Beginn der Messung wurde die Türe dieses
Raumes geöffnet, was zu einem Absinken der Temperatur führte. Zu der Zeit, als
der Verlauf von Diagramm 3-2 gemessen wurde, war die Temperatur des Raumes
bereits wieder ausgeglichen, die Offsetwerte dieser Reihe sind deswegen an-
nähernd konstant. Hierdurch wird auch deutlich, durch welche augenscheinlich
minimale äußere Manipulation das Messsystem merklich beeinflusst werden
kann.

3.2 Statische Messung - Auswertung und Ergebnisse der Messung 17
Mittelwert RVor u. RNach
Diagramm 3-1: Offset bei y=179: Beginn der Messreihe (t=0)
Mittelwert RVor u. RNach
0,7
0,6
0,5
0,4
0,3
0,2
0,1
0,7
0,6
0,5
0,4
0,3
0,2
0,1
Diagramm 3-2: Offset bei y=99: Ende der Messreihe (t=4h)
Eine weitere Untersuchung galt den Unterschieden zwischen dem Ruhewert vor
und nach einem Messpunkt. Würden zwischen den beiden Werten starke
Differenzen auftreten, wäre dies ein Anzeichen dafür, dass sich die Platte während
des Aufbringens einer Kraft plastisch verformt. Die in Diagramm 3-3 (berechnet
in auswertung_zeile7_statisch.xls) dargestellte prozentuale Abweichung von der
Differenz aus Ruhe-vor und Ruhe-nach vom Mittelwert der beiden Werte in
Abhängigkeit des horizontalen Ortes zeigt zwar, dass Abweichungen vorhanden
sind. Jedoch sieht man in
Zeitliche Veränderung des Offset
0
0
-0,1
10 20 30 40 50 60 70 80 90
Ort horizontal (~ Zeit)
Zeitliche Veränderung des Offset
0
0
-0,1
10 20 30 40 50 60 70 80 90
Ort horizontal (~ Zeit)
Zeit
ForceIn_ll
ForceIn_lr
ForceIn_ul
ForceIn_ur
ForceIn_ml
ForceIn_mr
Diagramm 3-4 (berechnet in auswertung_zeile7_statisch.xls), das die prozentuale
Abweichung von der Differenz aus Ruhe-nach und Ruhe-vor des nächsten
Messpunktes vom Mittelwert der beiden Werte in Abhängigkeit des horizontalen
Ortes darstellt, dass sich die Abweichungen dieser beiden Ruhemessungen in etwa
in der gleichen Größenordnung wie in Diagramm 3-3 befinden, obwohl zwischen
diesen Punkten nur ein minimaler Zeitabstand liegt und somit theoretisch bei
Zeit
ForceIn_ll
ForceIn_lr
ForceIn_ul
ForceIn_ur
ForceIn_ml
ForceIn_mr

3.2 Statische Messung - Auswertung und Ergebnisse der Messung 18
beiden Messungen der selbe Wert gemessen werden müsste. Zu begründen ist
dieses Verhalten durch die bei der Messung herrschende Messungenauigkeit,
verursacht durch leichte Berührung der Platte oder Ruhemessungen, bei denen
sich die Platte noch nicht vollständig wieder in Ruhe befindet.
%
Diagramm 3-3: Prozentuale Abweichung von RVor und RNach (y=119)
%
15
10
5
Prozentuale Abweichung von RVor und RNach
0
0 10 20 30 40 50 60 70 80 90
-5
-10
-15
15
10
5
Ort horizontal
Prozentuale Abweichung von RNach und RVor des nächsten Punktes
0
0
-5
10 20 30 40 50 60 70 80 90
-10
-15
-20
-25
Ort horizontal
Diagramm 3-4: Prozentuale Abweichung von RNach und RVor des nächsten Punktes (y=119)
Zur weiteren Berechnung muss bei den gemessenen Kraftwerten noch eine
Offsetkorrektur durchgeführt werden. Dies geschieht dadurch, dass von dem
jeweiligen Kraftwert der Mittelwert aus den Ruhemessungen vor und nach der
Kraftmessung abgezogen wird. Man kann nun die gemessenen Kraftwerte der
sechs Sensoren entweder nach ihrer x-, wie beispielsweise in Tabelle 3-1, oder y-
Koordinate sortieren und aus den dadurch entstandenen Wertetabellen für jede
Spalte, zu sehen in Diagramm 3-6, bzw. Reihe, zu sehen in Diagramm 3-5, (beide
erstellt in kraftverteilung.xls) Diagramme mit den Sensorwerten in Abhängigkeit
von y bzw. x erstellen, jeweils für ein konstantes x bzw. y.
ForceIn_ll
ForceIn_lr
ForceIn_ul
ForceIn_ur
ForceIn_ml
ForceIn_mr
ForceIn_ll
ForceIn_lr
ForceIn_ul
ForceIn_ur
ForceIn_ml
ForceIn_mr

3.2 Statische Messung - Auswertung und Ergebnisse der Messung 19
Tabelle 3-1: Wertetabelle für die Reihe y=179
X Y ForceIn_ll ForceIn_lr ForceIn_ul ForceIn_ur ForceIn_ml ForceIn_mr
78 179 -0,046838379 -0,017270508 2,13677002 0,001293945 0,554602051 -0,001325684
68 179 -0,052434082 -0,017912598 1,838000488 0,304672852 0,47423584 0,069477539
58 179 -0,042678223 -0,020163574 1,54534668 0,614719238 0,386362305 0,131384277
48 179 -0,039382324 -0,028017578 1,315427246 1,026054688 0,327460938 0,21739502
38 179 -0,024309082 -0,030473633 0,90395752 1,283503418 0,216911621 0,26387207
28 179 -0,020935059 -0,038554688 0,558427734 1,631867676 0,134697266 0,344797363
18 179 -0,018225098 -0,050922852 0,266477051 1,887695313 0,070852051 0,417790527
8 179 -0,017214355 -0,068400879 -0,024118652 2,186950684 0,003852539 0,517070313
Sensorspannung
2,5
2
1,5
1
0,5
-0,5
Kraftwerte in Abhängigkeit von x (bei y=179)
0
0 10 20 30 40 50 60 70 80
Ort horizontal
Diagramm 3-5: Kraftwerte in Abhängigkeit von x (bei y=179), Werte aus Tabelle 3-1
Der genauere Verlauf der Kurven wird später anhand der Messdaten der zweiten
statischen Messung erklärt, da diese, durch die höheren gemessenen Kräfte,
ausgeprägter sind und auch die komplette Platte vermessen wurde. Die spalten-
und reihenweise Darstellung lassen jedoch schon einen linearen Zusammenhang
zwischen der x- und y-Koordinate und der Kraft an einem Sensor vermuten, da
alle Kurven annähernd die Form einer Gerade haben.
ForceIn_ll
ForceIn_lr
ForceIn_ul
ForceIn_ur
ForceIn_ml
ForceIn_mr

3.2 Statische Messung - Auswertung und Ergebnisse der Messung 20
Sensorspannung
2,5
2
1,5
1
0,5
Diagramm 3-6: Kraftwerte in Abhängigkeit von y (bei x=68)
Die Idee, den Ort zu berechnen war nun, motiviert durch die Linearität der
Sensoren, für jeden Sensor eine Gleichung zu erstellen, die die Sensorspannung
eines Sensors in Abhängigkeit des Ortes ausgibt. Somit hat man für jeden
Messpunkt ein Gleichungssystem aus sechs Gleichungen mit zwei Unbekannten,
x und y. Durch Einsetzen der sechs, an dem Messpunkt gemessenen, Kraftwerten
und Lösen dieses überbestimmten Gleichungssystems lassen sich x und y
ermitteln.
Kraftwerte in Abhängigkeit von y (bei x=68)
0
90 100 110 120 130 140 150 160 170 180
-0,5
Ort vertikal
Der nächste Schritt in der Auswertung war nun, diese Gleichungen zu finden. Da
die Funktion die Form Sensorspan nung(
x,
y)
haben soll, also die
Sensorspannung in Abhängigkeit von x und y, wurde versucht, die Daten in genau
dieser Form darzustellen, anders als in den bisherigen Graphen, in denen die Kraft
nur jeweils in Abhängigkeit einer Koordinate dargestellt wurde, während die
andere konstant war. Da dieses Diagramm aber einen Wert in Abhängigkeit von
zwei Eingabewerten darstellen soll, ist ein dreidimensionales Diagramm, bzw.
zuerst eine dreidimensionale Wertetabelle wie in Tabelle 3-2, erforderlich.
Diagramm 3-7 besitzt als Grundfläche die obere Plattenhälfte, die Achsen sind so
angeordnet, dass ein Blickwinkel von oben senkrecht auf das Diagramm dem
Blick des Fechters von vorne auf die Platte entspricht (beide erstellt in
kraftverteilung_3D.xls). Alle Diagramme auf den folgenden Seiten zeigen
stellvertretend für alle Sensoren die Werte des Sensors „ul“.
ForceIn_ll
ForceIn_lr
ForceIn_ul
ForceIn_ur
ForceIn_ml
ForceIn_mr

y-Koordinaten
3.2 Statische Messung - Auswertung und Ergebnisse der Messung 21
Tabelle 3-2: Dreidimensionale Wertetabelle von Sensor ul (Kraft in Abhngigkeit vom Ort)
78 68 58
x-Koordinaten
48 38 28 18 8
179 2,13677002 1,838000488 1,54534668 1,315427246 0,90395752 0,558427734 0,266477051 -0,024118652
169 1,827155762 1,577092285 1,332094727 1,045107422 0,783081055 0,503664551 0,234985352 -0,015395508
159 1,560952148 1,36105957 1,142224121 0,914135742 0,669887695 0,459733887 0,20342041 -0,006672363
149 1,28888916 1,110581055 0,935251465 0,753098145 0,565334473 0,363227539 0,180661621 -0,018632813
139 1,027348633 0,889680176 0,747316895 0,615407715 0,465898438 0,303942871 0,149501953 -0,009213867
129 0,804643555 0,69034668 0,583535156 0,48001709 0,373081055 0,247141113 0,133041992 0,003278809
119 0,583894043 0,495939941 0,424453125 0,35137207 0,284536133 0,204597168 0,113439941 0,004602051
109 0,406765137 0,337541504 0,294516602 0,252355957 0,210734863 0,163911133 0,092663574 0,012958984
99 0,22963623 0,205949707 0,187849121 0,168493652 0,154572754 0,126640625 0,082211914 0,028508301
Sensorspannung
2,5
2
1,5
1
0,5
0
-0,5
78
Kraft an Sensor ul in Abhängigkeit vom Ort
68
58
48
Ort horizontal
38
Diagramm 3-7: Kraft an Sensor ul in Abhängigkeit vom Ort (erzeugt aus Tabelle 3-2)
Die Fläche des Graphen hat die Form eines Geflechts aus lauter Strecken, denn
sowohl in Richtung der Abszisse als auch der Ordinate besteht immer ein
(annähernd) linearer Verlauf der Sensorspannung. Diese Strecken, hier die
horizontalen, wurden zur Verdeutlichung in Diagramm 3-8 (erstellt in
kraftverteilung.xls) eingezeichnet und, für die verschiedenen y, in Diagramm 3-9
(erstellt in kraftverteilung_3D_interpoliert_ul.xls) zusammengefasst. Man erkennt,
dass die einzelnen Strecken einen gemeinsamen Startpunkt haben und die
Endpunkte in einem gleichmäßigen vertikalen Abstand zueinander liegen, was auf
eine Regelmäßigkeit der Strecken schließen lässt. Diese „Regelmäßigkeit“ muss
eine Funktion sein, die angibt, wie sich die Parameter m und t der horizontalen
Geradengleichung F = m * x + t von Spalte zu Spalte verändern. Um diese
28
18
8
99
119
139
Sensorposition
159
179
Ort vertikal
2-2,5
1,5-2
1-1,5
0,5-1
0-0,5
-1-0

3.2 Statische Messung - Auswertung und Ergebnisse der Messung 22
herauszufinden, wurden zuerst die einzelnen Strecken aus Diagramm 3-9 für jede
Spalte interpoliert und dann die Parameter m und t in Abhängigkeit von y
gezeichnet.
Sensorspannung
Diagramm 3-8: Wie Diagramm 3-7, zusätzlich mit eingezeichneten horizontalen Geraden
2,5
2
1,5
1
0,5
-0,5
2,5
2
1,5
1
0,5
0
-0,5
78
Kraft an Sensor ul in Abhängigkeit vom Ort
68
58
48
Ort horizontal
38
28
Diagramm 3-9: Die in Diagramm 3-8 eingezeichneten Geraden
Man erkennt, dass sowohl die Steigung in Diagramm 3-10, als auch der y-
Abschnitt in Diagramm 3-11 ebenfalls linear von y abhängen. Somit sind die
Parameter m und t der horizontalen Geradengleichung ebenfalls Geraden:
18
8
99
119
139
159
179
Ort vertikal
0
0 10 20 30 40 50 60 70 80
ForceIn_ul (y=179)
ForceIn_ul (y=169)
ForceIn_ul (y=159)
ForceIn_ul (y=149)
ForceIn_ul (y=139)
ForceIn_ul (y=129)
ForceIn_ul (y=119)
ForceIn_ul (y=109)
ForceIn_ul (y=99)
2-2,5
1,5-2
1-1,5
0,5-1
0-0,5
-1-0

3.2 Statische Messung - Auswertung und Ergebnisse der Messung 23
m +
= m1
* y t1
und t m2
* y + t2
= . Setzt man diese beiden Gleichungen in
F = m * x + t ein, erhält man für die Flächengleichung:
F = ( m * y + t ) * x + m * y + t
1
1
2
2
Die Parameter m 1 , m 2 , t 1 und t 2 müssen für jeden Sensor ermittelt werden.
Steigung
Diagramm 3-10: Abhängigkeit der Steigung (der horizontalen Geradengleichungen) von y
y-Abschnitt
Abhängigkeit der Steigung (der horizontalen Geradengleichungen) von y
0,035
0,03
0,025
m = 0,0004y - 0,0344
0,02
Steigung
0,015
0,01
0,005
0
Linear (Steigung)
90 100 110 120 130 140 150 160 170 180
Ort vertikal
Abhängigkeit des y-Abschnitts (der horizontalen Geradengleichungen) von y
0,1
0,05
0
-0,05 90 100 110 120 130 140 150 160 170 180
-0,1
-0,15
-0,2
-0,25
-0,3
y
Ort vertikal
Diagramm 3-11: Abhängigkeit des y-Abschnitts (der horizontalen Geradengleichungen) von y
Um die Parameter der Flächengleichung zu finden, wurde der in Excel integrierte
„Solver“ („Extras“ -> „Solver…“) verwendet. Dem Solver wird eine Zielzelle
angegeben, deren Wert er durch angegebene veränderbare Zellen entweder
maximieren, minimieren oder einem bestimmten Wert annähern kann. Zur
Berechnung der Parameter wurden drei (dreidimensionale) Wertetabellen erstellt:
Eine mit den Messwerten, eine mit den über die Parameter aus der Funktion
berechneten Sensorwerten und eine mit den quadrierten Differenzen der
Messwerte und der Funktion. Als veränderbare Zellen werden dem Solver die
Felder mit den Gleichungsparametern angegeben, die Zielzelle enthält die Summe
der in der Wertetabelle berechneten Fehlerquadrate, die natürlich minimiert
werden soll. Diagramm 3-13 zeigt die damit gefundene Funktion für den Sensor
ul, als Vergleich daneben Diagramm 3-12 mit den Messwerten. (Die Optimierung
wurde einzeln für jeden Sensor in den Tabellen optimierung_ForceIn_ll.xls,
optimierung_ForceIn_lr.xls, optimierung_ForceIn_ml.xls, optimierung_ForceIn_mr.xls,
optimierung_ForceIn_ur.xls und optimierung_ForceIn_ur.xls durchgeführt)
t = -0,0039y + 0,4281
y-Abschnitt
Linear (y-Abschnitt)

3.2 Statische Messung - Auswertung und Ergebnisse der Messung 24
Kraft
3
2,5
2
1,5
1
0,5
-0,5
78
Diagramm 3-12: Kraftverlauf des Sensors ul (Messwerte)
Kraft
0
3
2,5
2
1,5
1
0,5
0
-0,5
78
68
58
48
Ort horizontal
68
Kraftverlauf des Sensors ul (Messwerte)
58
48
38
38
28
Diagramm 3-13: Kraftverlauf des Sensors ul (Funktion)
In Diagramm 3-14 zeigt sich, dass die Abweichung von Funktion und Messwerten
zwar nur gering ist, die Werte aber nach einem bestimmten Muster abweichen, ein
Merkmal dafür, dass die Funktion nicht komplett linear ist. In der Mitte der
oberen Plattenhälfte passt die Funktion am besten zu den Messwerten, kleine
positive Abweichungen gibt es an den Rändern in horizontaler Richtung, jedoch
gibt es größere negative Abweichungen an den Rändern in vertikaler Richtung die
auf einen dort nicht linearen Verlauf hinweisen, was auch durch die zweite Folge
28
18
18
8
99
8
119
99
139
119
159
Kraftverlauf des Sensors ul (optimierte Funktion)
Ort horizontal
179
Ort vertikal
139
159
179
Ort vertikal
2,5-3
2-2,5
1,5-2
1-1,5
0,5-1
0-0,5
-1-0
2,5-3
2-2,5
1,5-2
1-1,5
0,5-1
0-0,5
-1-0

3.2 Statische Messung - Auswertung und Ergebnisse der Messung 25
von Messungen bestätigt wird. Bei dem extrem negativen Wert an der Stelle
y=179 handelt sich es um einen „Ausreißer“, vermutlich verursacht durch einen
Messfehler.
Funktion - Messwert
0,1
0,05
0
-0,05
-0,1
-0,15
99
Abweichung Funktion - Messwert an Sensor ul
109
119
129
Ort vertikal
139
Diagramm 3-14: Abweichung Funktion - Messwert an Sensor ul
Im Folgenden werden die Sensorkurven der zweiten statischen Messung erklärt.
149
Diagramm 3-15: Kraft in Abhängigkeit von x an Sensor lr; F=4000g
159
169
179
8
68
48
Ort horizontal
28
0,05-0,1
0-0,05
-0,05-0
-0,1--0,05
-0,15--0,1

3.2 Statische Messung - Auswertung und Ergebnisse der Messung 26
Diagramm 3-15 zeigt den horizontalen Kraftverlauf aller Spalten für den Sensor
„lr“ bei einem Gewicht von 4000g (als Vergleich: die erste statische Messung
wurde mit 1000g vermessen). Man erkennt, dass der Verlauf annähernd linear ist,
abgesehen von Messungenauigkeiten in den oberen Reihen, da diese am weitesten
von dem unten rechts befindlichen Sensor entfernt sind und dadurch mehr
Gewicht für die Verformung der Platte aufgewendet werden kann. Die Geraden
schneiden sich alle in einem gemeinsamen Nullpunkt, der ungefähr der Position
des Sensors „ll“ entspricht. Bewegt man ein Gewicht von „lr“ ausgehend zu „ll“,
so nimmt die an „lr“ gemessene Kraft linear bis zur Position von „ll“ und „ul“ ab.
Wird das Gewicht genau an der horizontalen Position von „ll“ angebracht, ist an
„lr“ keine Kraft zu messen, da das Gewicht genau auf dem Angelpunkt des Hebels
angebracht wird. Bewegt man das Gewicht nun weiter bis zum Rand der Platte,
wird an „lr“ eine negative Kraft gemessen, da das Gewicht von „lr“ aus gesehen
an der gegenüberliegenden Seite des Angelpunktes aufgebracht wird, die Platte
wird an der Position von „lr“ also nach vorne gedrückt. Trotz des linearen
horizontalen Kraftverlaufs sind die Kurven der einzelnen Spalten nicht
gleichmäßig angeordnet. Auch ist die Kurve der obersten Spalte nicht, wie man
vermuten würde, die Spalte mit den kleinsten Werten, sondern die Spalten in der
Mitte der oberen Hälfte. Um dies zu erklären, benötigt man ein neues Diagramm,
das den vertikalen Kraftverlauf der einzelnen Spalten darstellt.
Diagramm 3-16: Kraft in Abhängigkeit von y an Sensor ur; F=4000g

3.2 Statische Messung - Auswertung und Ergebnisse der Messung 27
Diagramm 3-16 zeigt dies am Beispiel von Sensor ur. Hier gibt es diesmal zwei
gemeinsame Nullpunkte der Sensoren, die sich auf der vertikalen Position des
mittleren und unteren Sensorpaares befinden. Die ab dem Überschreiten des
mittleren Auflagepunktes an „ur“ gemessene negative Kraft nimmt nun bis zur
Mitte zwischen dem mittleren und unteren Sensorpaar ab, wo sie ihren Tiefpunkt
erreicht. Von dort aus steigt die Kraft wieder fast bis Null, während sie sich dem
unteren Sensorpaar nähert. Dieser, durch die drei vertikalen Auflagepunkte
verursachter Kraftverlauf ist nicht linear, bis auf ca. das Drittel der Platte in der
Nähe des Sensors. Hier übt der dritte, am weitesten vom Sensor entfernte
Auflagepunkt noch einen geringen Einfluss auf den Kraftverlauf aus, der sich dort
wie der aus zwei Auflagepunkten bestehende, horizontale Kraftverlauf verhält.

3.2 Statische Messung - Auswertung und Ergebnisse der Messung 28
Diagramm 3-17: Kraft in Abhängigkeit von y; F=500g
Diagramm 3-18: Kraft in Abhängigkeit von y; F=1000g

3.2 Statische Messung - Auswertung und Ergebnisse der Messung 29
Diagramm 3-19: Kraft in Abhängigkeit von y; F=2500g
Diagramm 3-20: Kraft in Abhängigkeit von y; F=4000g
Diagramm 3-17, Diagramm 3-18, Diagramm 3-19 und Diagramm 3-20 stellen den
vertikalen Kraftverlauf aller Sensoren bei 500g, 1000g, 2500g und 4000g dar.
Man erkennt in etwa, dass trotz des nichtlinearen Verlaufes die an jedem Punkt
gemessene Kraft proportional zur angebrachten Kraft ist.

3.2 Statische Messung - Auswertung und Ergebnisse der Messung 30
Diagramm 3-21: Kraft in Abhängigkeit vom Ort (ur); F=500g
Diagramm 3-22: Kraft in Abhängigkeit vom Ort (ur); F=1000g

3.2 Statische Messung - Auswertung und Ergebnisse der Messung 31
Diagramm 3-23: Kraft in Abhängigkeit vom Ort (ur); F=2500g
Diagramm 3-24: Kraft in Abhängigkeit vom Ort (ur); F=4000g
Gleiches zeigen Diagramm 3-21, Diagramm 3-22, Diagramm 3-23 und Diagramm
3-24. Hier ist dreidimensional die Kraft an dem Sensor „ur“ in Abhängigkeit vom
Ort dargestellt, für 500g, 1000g, 2500g und 4000g.
Zur Überprüfung dieser Proportionalität wurden in Diagramm 3-25 die Kraftwerte
von Sensor „ul“ an jedem Punkt bei 4000g durch die von 2500g dividiert. Bei
vorliegender Proportionalität müsste sich für jeden Messpunkt dieselbe
Proportionalitätskonstante ergeben.

3.2 Statische Messung - Auswertung und Ergebnisse der Messung 32
Diagramm 3-25: Untersuchung der Proportionalität von 4000g und 2500g an Sensor ul
Dies wird auch von Diagramm 3-25 bestätigt. Abweichungen gibt es an den
Randbereichen, da hier kleine Kräfte, die nahe bei Null liegen, gemessen werden
und es dadurch schon bei kleinsten Abweichungen, durch immer vorhandene
Messungenauigkeiten, zwischen beiden Messungen zu großen Unterschieden bei
der Division gegenüber den anderen Messpunkten gibt.
Diagramm 3-26: Angebrachte Kraft in Abhängigkeit der Summe der Sensorwerte
Um bei der Auswertung die Sensorspannung in ein Gewicht bzw. eine Kraft
umrechnen zu können, wurde untersucht, wie sich die Summe der sechs
Sensorwerte an einem Messpunkt zu der dort angebrachten Kraft verhält. Die

3.2 Statische Messung - Auswertung und Ergebnisse der Messung 33
Summe aus den Sensoren wird deshalb verwendet, weil sich beim Anbringen
einer Kraft diese sich komplett auf alle Sensoren verteilen muss, ähnlich wie
wenn man sich zum Wiegen der Körpermasse auf zwei Waagen stellt und das
Gewicht der beiden addiert. In Diagramm 3-1 sind nun alle diese Summen für
jeden Messpunkt mit der jeweiligen angebrachten Kraft eingetragen. Zusätzlich
wurde in das Diagramm eine Ausgleichsgerade für den Verlauf eingezeichnet. Die
Art der Geraden ist, wie zu erwarten, annähernd eine Ursprungsgerade, denn
wenn alle Sensorwerte Null sind, kann auch keine Kraft anliegen. Allerdings gibt
es für höhere Kräfte ein breiteres Feld an verschiedenen gemessenen
Sensorsummen, d.h. es gibt größere Differenzen zwischen den Sensorsummen der
einzelnen Messpunkte. Zurückzuführen ist dies auf die zu Beginn erwähnte
ungenaue Kalibrierung. Die Sensoren wurden vor der Messung so kalibriert, dass
2V 1000g entsprechen, jedoch ergibt sich aus der Geradengleichung, dass 2V ca.
800g entsprechen. Die Differenzen zwischen den Sensorsummen sind darauf
zurückzuführen, dass die Sensoren, eben durch diese ungenaue Kalibrierung,
verschieden kalibriert sind und deswegen verschieden stark verstärkt werden, was
bei höheren Kräften umso mehr sichtbar wird.
Diagramm 3-27: Summe der Sensorwerte in Abhängigkeit vom Ort; F=4000g
Diagramm 3-27 zeigt wieder die Summe der Sensorwerte, diesmal in
Abhängigkeit des Ortes, für das angebrachte Gewicht von 4000g. Dies bestätigt

3.2 Statische Messung - Auswertung und Ergebnisse der Messung 34
noch einmal die unterschiedliche Kalibrierung der Sensoren, da es einen
deutlichen Trend, neben den üblichen Abweichungen durch die
Messungenauigkeit, gibt, dass die Werte zum Sensor oben links hin ansteigen.
Dies lässt darauf schließen, dass dieser Sensor gegenüber den anderen Sensoren
zu stark verstärkt wird.

3.3 Statische Messung - Erklärung des Programms zur automatischen Messauswertung 35
3.3. Erklärung des Programms zur automatischen Messauswertung
Das Programm pfaller_auswertung_messdaten.m ermöglicht es, aus einer Messung,
mit einem beliebigen Raster an Messpunkten und beliebiger Anzahl an Sensoren
und aufgebrachten Kräften, automatisch die zur Auswertung benötigten
Diagramme zu erstellen
Mess = xlsread('...\statisch_Mess_neue_messungen_korrigiert.xls');
RVor = xlsread('...\statisch_RVor_neue_messungen_korrigiert.xls');
Zu Beginn der Auswertung werden die zuvor mit pfaller_auswertung_statisch.m
oder pfaller_auswertung_dynamisch.m erzeugten Matrizen der Mess- und Ruhewerte
mittels der Funktion xlsread eingelesen und in den Matrizen Mess und RVor
gespeichert. Dieser Umweg über eine externe Datei, anstatt einer direkten
Übergabe der Variablen, ist notwendig, da längere Messungen meist Fehler
enthalten, die nur per Hand korrigiert werden können, wie beispielsweise das
doppelte Messen eines Punktes oder eine Verfälschung der Koordinaten des
Messpunktes, verursacht durch Gegenstände innerhalb des Lichtgitters. Die
Excel-Tabellen müssen zuerst nach der y- und dann nach der x-Koordinate sortiert
werden.
rows = 14;
cols = 9;
forces_v = [500, 1000, 2500, 4000];
sensors_v = {'ll', 'lr', 'ul', 'ur', 'ml', 'mr'};
colors = {'b', 'm', 'y', 'c', 'g', 'r'};
Weiterhin werden zur Auswertung Informationen über das Messverfahren
benötigt. Diese sind die Anzahl der abgetasteten Reihen rows und Spalten cols,
ein Vektor forces_v mit den verschiedenen Kräften, die auf einen Punkt
aufgebracht wurden, sortiert in der Reihenfolge in der sie gemessen wurden, ein
String-Array sensors_v mit den Bezeichnungen der Sensoren in alphabetischer
Ordnung und ein String-Array colors mit den Farben zur Kennzeichnung der
Kurven der einzelnen Sensoren.
forces = length(forces_v);
sensors = length(sensors_v);
Zu Beginn des eigentlichen Programms werden zunächst die Anzahl der Kräfte
forces und der Sensoren sensors mittels der Funktion length über die Länge
der vorher definierten Vektoren bestimmt.

3.3 Statische Messung - Erklärung des Programms zur automatischen Messauswertung 36
x_max = round((max(Mess(:, 1)) + 10) / 10) * 10;
y_max = round((max(Mess(:, 2)) + 10) / 10) * 10;
F_max = round((max(max(Mess(:, 3:(sensors + 2)))) + 1));
F_min = round((min(min(Mess(:, 3:(sensors + 2)))) - 1));
Anschließend werden für die nachfolgenden Diagramme die Grenzen festgelegt,
zu der die jeweiligen Achsen, der x- und y-Koordinate und der Kraft, angezeigt
werden. Die oberen Grenzen der Koordinaten-Achsen x_max und y_max werden
berechnet, indem zur höchsten in der Messung enthaltenen x- und y-Koordinate
zehn addiert und anschließend auf die Zehnerstelle gerundet wird. Da die
Funktion round auf ganze Integer-Werte, d.h. auf die Einerstelle, rundet, wird der
Wert vor dem Runden durch zehn dividiert und danach wieder mit zehn
multipliziert. Die Begrenzungen der Kraft-Achse F_max und F_min ergeben sich
durch den maximalen bzw. minimalen bei den Kraftsensoren auftretenden Wert,
zu bzw. von dem eins addiert bzw. subtrahiert und anschließend auf eine ganze
Zahl gerundet wird.
Im nächsten Abschnitt wird aus den beiden Matrizen Mess und RVor zunächst
eine Matrix ForceIn mit folgender Form erzeugt:
Tabelle 3-3: Aufbau der Matrix ForceIn
x y Sensor 1 Sensor 2 … Sensor sensors
( O f f s e t k o r r i g i e r t )
x1 y1 F1-1 F1-2 … F1-sensors ∑
k = 1
x2 y2 F2-1 F2-2 … F2-sensors ∑
k=
1
∑ Kraft an
Sensoren
sensors
sensors
F
F
angebrachte Kraft
1 −k
Force 1
2 −k
Force 2
… … … … … … … …
Xcols Yrows Fcols*rows*forces-1 Fcols*rows*forces-2 … Fcols*rows*forces-sensors ∑
k = 1
Spaltennummer
sensors
F
cols rows*
forces−k
* Force forces
1 2 3 + sensors 4 + sensors
ForceIn = zeros(rows * cols * forces, sensors + 4);
Der erste Schritt besteht darin für ForceIn eine mit Nullen gefüllte Matrix zu
erstellen. Tabelle 3-3 zeigt, dass es zum einen vier Spalten zusätzlich zur Anzahl
der Sensoren sensors, und zum anderen so viele Reihen wie Messpunkte geben
muss. Die Anzahl der Messungen lässt sich aus dem Produkt der gemessenen
Reihen rows, der gemessenen Spalten cols und der verschiedenen Kräfte
forces berechnen.

3.3 Statische Messung - Erklärung des Programms zur automatischen Messauswertung 37
ForceIn(:, 1) = Mess(:, 1);
ForceIn(:, 2) = Mess(:, 2);
Die Spalten eins und zwei von ForceIn mit den x- und y-Koordinaten der
Messpunkte werden aus der zu Beginn eingelesenen Matrix Mess kopiert.
for sen = 1:sensors
ForceIn(:, 2 + sen) = Mess(:, 2 + sen) - RVor(:, 2 + sen);
ForceIn(:, sensors + 3) = ForceIn(:, sensors + 3) + ForceIn(:,
2 + sen);
end
Die for-Schleife hat nun die Aufgabe, bei den an den Sensoren gemessenen
Kraftwerten eine Offset-Korrektur durchzuführen und alle Sensorwerte einer
Messung in einer eigenen Spalte aufzuaddieren. Dazu zählt die Schleife mit der
Variablen sen der Reihe nach alle Sensoren durch. Für die Offsetkorrektur wird
bei jedem Durchlauf in ForceIn in die Spalte des aktuellen Sensors die Differenz
aus den entsprechenden Spalten in Mess und in RVor geschrieben.
Im nächsten Schritt wird in die Spalte nach den Sensorenwerten, die Spalte mit
der Nummer sensors + 3, zu dieser Spalte selbst bei jedem Durchlauf die Spalte
das aktuellen Sensors addiert, um dort nach dem Ende der Schleife die Summe
aller Spalten mit Sensorwerten zu erhalten.
for c = 1:forces:(rows * cols * forces)
for n = 1:forces;
ForceIn(c+n-1, sensors + 4) = forces_v(1, n);
end
end
Mit Hilfe der nächsten beiden Schleifen wird hinter jede Messung, in die letzte
Spalte von ForceIn, die dort angebrachte Kraft geschrieben. Die äußere Schleife
zählt die Variable c in Schritten von forces bis zur gesamten Anzahl aller
Messpunkte bzw. Spalten von ForceIn hoch (d.h. sie macht rows * cols
Durchläufe), das bedeutet sie geht der Reihe nach alle Messpunkte durch. An
jedem Messpunkt gibt es wiederum eine Messung für jede Kraft. Die innere
Schleife zählt nun an jedem Messpunkt alle angebrachten Kräfte forces_v durch
und schreibt sie nacheinander hinter die Messungen, bevor die äußere Schleife
wieder zum nächsten Messpunkt geht.
Zur Weiterverarbeitung muss die listenförmige Matrix in mehrere
dreidimensionale Wertetabellen zerlegt werden. Es wird eine Matrix jeweils für
jeden Sensor (zusätzlich die Summe aller Sensoren) und jede angebrachte Kraft
erstellt. Diese einzelnen Wertetabellen, mit dem in Tabelle 3-4 dargestellten

3.3 Statische Messung - Erklärung des Programms zur automatischen Messauswertung 38
Aufbau, werden zusammen nach dem Muster aus Abbildung 3-3 in die Matrix
Werte geschrieben.
Sensor 1
Kraft 1
Sensor 2
Kraft 1
Sensor sensors
Kraft 1
∑ Sensoren
Kraft 1
Sensor 1
Kraft 2
Sensor 2
Kraft 2
Tabelle 3-4: Eine einzelne dreidimensionale Wertetabelle
0 x1 x2 x3 … xcols
y1 F(x1, y1) F(x2, y1) F(x3, y1) … F(xcols, y1)
y2 F(x1, y2) F(x2, y2) F(x3, y2) … F(xcols, y2)
y3 F(x1, y3) F(x2, y3) F(x3, y3) … F(xcols, y3)
… … … … … …
yrows F(x1, yrows) F(x2, yrows) F(x3, yrows) … F(xcols, yrows)
Zum Erzeugen der Werte-Matrix werden die folgenden vier ineinander
verschachtelten for-Schleifen benötigt:
Sensor 1
Kraft forces
Sensor 2
Kraft forces
… … … …
Sensor sensors
Kraft 2
∑ Sensoren
Kraft 2
Abbildung 3-3: Aufbau der Matrix Werte
Sensor sensors
Kraft forces
for sen = 1:(sensors + 1)
for f = 1:forces
n = (sen-1) * (rows + 2);
m = (f-1) * (cols + 2);
for j = 2:(rows+1)
for i = 2:(cols+1)
reihe = ((i-1) * rows - (j-2)) * forces;
x_wert = ForceIn(reihe, 1);
y_wert = ForceIn(reihe, 2);
…
…
…
…
∑ Sensoren
Kraft forces
Werte(1 + n, i + m) = x_wert;
Werte(j + n, 1 + m) = y_wert;
Werte(j + n, i + m) = ForceIn((reihe - 4 + f), 2 + sen);
end
end
end
end
Die innersten beiden Schleifen geben, mit dem Schleifezähler j für die Spalte
und mit i für die Reihe in der Matrix, die Position des zu schreibenden

3.3 Statische Messung - Erklärung des Programms zur automatischen Messauswertung 39
Messwertes in einer einzelnen Wertetabelle an, sie tasten dort also den kompletten
Bereich mit den Kraftwerten ab. Die Variable reihe stellt das Bindeglied
zwischen listenförmiger und dreidimensionaler Wertetabelle dar. Mit ihr wird
berechnet, in welcher Zeile der Liste ForceIn der Kraftwert mit der Position
(j, i) in der dreidimensionalen Wertetabelle steht. Die x- und y-Koordinate
dieses Kraftwertes, gespeichert in den Variablen x_wert und y_wert, ergibt sich
aus der ersten bzw. zweiten Spalte dieser Zeile, welche dann in die erste Reihe
bzw. Spalte der dreidimensionalen Wertetabelle geschrieben wird.
Da dieser Vorgang aber für jeden Sensor und jede angebrachte Kraft wiederholt
werden muss, gibt es die äußerste Schleife, die mit der Variablen sen die
Sensoren und zusätzlich die Summer aller Sensoren durchgeht, und die nächst
innere Schleife, die mit der Variablen f die verschiedenen Kräfte durchzählt. Aus
ihnen werden die Variablen n und m berechnet, die den vertikalen bzw.
horizontalen Anfangspunkt einer einzelnen Wertetabelle innerhalb von Werte
angeben, wobei zwischen den einzelnen Wertetabellen in jeder Richtung ein
Abstand von eins besteht, der automatisch mit Nullen gefüllt wird.
Später werden die Einzelmatrizen aus Werte für eventuelle Weiterverarbeitungen
in Excel-Tabellen exportiert.
Im nächsten Abschnitt wird ein Diagramm erstellt, das die Summe aller
Sensorwerte einer Messung in Abhängigkeit der bei dieser Messung angebrachten
Kraft darstellt. Dies soll es später bei der Ortberechnung ermöglichen, von der
Sensorspannung in eine Kraft umzurechnen.
Forces_x = ForceIn(:, sensors + 4)
Forces_y = ForceIn(:, sensors + 3);
plot(Forces_x, Forces_y, ...);
Hiermit wird zuerst ein Diagramm mit der Spalte aus ForceIn mit der
angebrachten Kraft entlang der Abszisse, Forces_x, und die Summe der Kräfte
entlang der Ordinate, Forces_y, erstellt.
Anschließend soll für die spätere Berechnung eine Ausgleichsgerade der Form
Kraft ( Sensorwert)
= m * Sensorwert + t * 1
über die Messwerte gelegt werden.
for n = 1:rows * cols * forces
links(n, :) = [Forces_x(n, 1), 1];
end

3.3 Statische Messung - Erklärung des Programms zur automatischen Messauswertung 40
Zur Berechnung der Parameter der Geradengleichung m und t muss zunächst das
Gleichungssystem aus Formel 3-1 mit allen Kräften und Sensorwerten erstellt
werden. Die Matrix links enthält die Koeffizienten der „linken Seite“ der
Gleichungen.
Formel 3-1: Aufbau des Gleichungssystems
⎛
⎜
⎜
⎜
⎜
⎜
⎜
⎝
∑
∑
∑
∑
F(
x , y )
F(
x , y )
F(
x , y )
F(
x
...
cols
1
2
3
, y
1
2
3
rows
solution = links\Forces_y;
m = solution(1, 1);
t = solution(2, 1);
)
1 ⎞ ⎛ Force _1
⎞
⎟ ⎜
⎟
1 ⎟ ⎜ Force _ 2 ⎟
⎟ ⎜
⎟ ⎛m
⎞
1 = Force _ 3 * ⎜ ⎟
⎟ ⎜
⎟ ⎝ t
...
⎠
⎟ ⎜ ... ⎟
⎟
1 ⎜
⎟
⎠ ⎝ Force _ forces⎠
links Forces_y solution
Man erhält nun durch linke Matrixdivision von links durch Forces_y die Matrix
solution mit den Gleichungskoeffizienten m und t. Da es sich hierbei um ein
überbestimmtes Gleichungssystem handelt, nähert MATLAB die Lösung
automatisch mit der Methode der kleinsten Fehlerquadrate an.
x = 0:0.1:(F_max+1);
y = m * x + t;
Anschließend wird ein Vektor x als Eingabe für die Funktion erstellt und diese
mit den oben gefundenen Parametern in dem Vektor y berechnet.
if t > 0
t_string = ['+ ' num2str(t)];
end
if t < 0
t_string = num2str(t);
end
if t == 0
t_string = '';
end
Um die Gleichung später in dem Diagramm anzeigen zu können, muss der
Parameter t in einen String umgewandelt werden. Wenn t negativ ist, geschieht
diese Umwandlung direkt über die in MATLAB integrierte Funktion num2str. Ist
t aber positiv, muss noch ein „+“ vor dem String hinzugefügt werden, um die

3.3 Statische Messung - Erklärung des Programms zur automatischen Messauswertung 41
Gleichung in der Form „y = m * x + t“ anzeigen zu können. Sollte t gleich Null
sein, d.h. die Gerade ist tatsächlich eine Ursprungsgerade, fällt t weg.
string = ['f(x) = ' num2str(m) ' * x ' t_string];
In string werden die einzelnen Segmente des Strings der Geradengleichung
zusammengesetzt. Im weiteren Quelltext wird die Gerade gezeichnet, die
Achsengbeschriftungen gesetzt, der Text mit der Geradengleichung platziert, die
Achsenbegrenzungen gesetzt und das Diagramm als .png-Bilddatei gespeichert.
Das so erzeugte Diagramm ist in Diagramm 3-26 dargestellt.
Der nächste Schritt im Programmablauf ist es, ein Diagramm mit den
Sensorwerten aller Sensoren in Abhängigkeit der x-Koordinate (bzw. y-
Koordinate) zu erstellen, wobei die y-Koordinate (bzw. x-Koordinate) und die
angebrachte Kraft in dem jeweiligen Diagramm konstant sind. Hierfür werden
zwei Schleifen benötigt, um zum einen Diagramme für jede Reihe, also die Kraft
in Abhängigkeit von x, bei verschiedenen y, und zum anderen für jede Spalte, also
die Kraft in Abhängigkeit von y, bei verschiedenen x, zu zeichnen, alle
Diagramme jeweils für alle verschiedenen angebrachten Kräfte. (siehe Diagramm
3-15 bzw. Diagramm 3-16)
Die folgende Beschreibung des Programms befasst sich mit der spaltenweisen
Darstellung, die reihenweise Darstellung erfolgt analog dazu.
for col_nr = 1:(rows*forces):(rows * cols * forces)
for force_nr = 1:forces
end
...
end
Die eigentliche Plot-Funktion wird umgeben von zwei for-Schleifen, die diese auf
alle Spalten, angegeben durch die Variable col_nr, und alle Kräfte, angegeben
durch die Variable force_nr, anwenden, d.h. ein Durchlauf einer dieser
Schleifen bedeutet die Erstellung eines neuen Diagramms bzw. einer neuen Datei.
for sen = 1:sensors
...
end
Da das Diagramm die Kurven aller Sensoren enthalten soll, muss die Plot-
Funktion für jeden Sensor, bei aktiviertem hold, wiederholt werden.

3.3 Statische Messung - Erklärung des Programms zur automatischen Messauswertung 42
row = 1;
for n = 1:forces:(forces * rows)
Plot (row, 1) = ForceIn (n + force_nr + col_nr - 2, 2);
Plot (row, 2) = ForceIn (n + force_nr + col_nr - 2, 2 + sen);
row = row + 1;
end
Für den Plot wird hier eine Wertetabelle Plot erstellt, indem eine weitere for-
Schleife mit der Variablen n alle Reihen, d.h. alle y-Koordinaten in ForceIn,
durchgeht. Zusätzlich verschieben die Variablen force_nr, für die Nummer der
aktuellen Kraft, und col_nr, für die Position der aktuellen Spalte in ForceIn, die
Position des zu schreibenden x-Werts. Mit der Variable sen wird die Spalte in
ForceIn des aktuellen Sensors, bei der aus den obigen drei Variablen errechneten
Spalte in ForceIn, ermittelt. Der so gefundene Kraftwert wird in die zweite
Spalte der Plot-Matrix geschrieben, unter der, aus Spalte zwei von ForceIn
gefundenen, y-Koordinate.
line = 1.5;
marker = 15;
color = char(colors(sen));
style = [color, '.-'];
plot(Plot(:,1), Plot(:,2), ...);
Für das Zeichnen der Graphen wird im Folgenden die Linien- und
Markierungsdicke gesetzt, der Farbwert des aktuellen Sensors aus der zu Beginn
eingegebenen Matrix colors ausgelesen und in einen String color
umgewandelt, ein String style für den Linientyp aus der Farbe und den Zeichen
„.“ für den Markierungstyp „Punkt“ und „-“ für die Linienart „durchgehende
Linie“ zusammengesetzt und der Graph durch die Funktion plot mit diesen
Attributen gezeichnet.
for leg = 1:sensors
legend_forces = [legend_forces; 'Force ' char(sensors_v(leg))];
end
Nachdem die Graphen der einzelnen Sensoren gezeichnet wurden, wird die
Legende des Diagramms in das Character-Array legend_forces geschrieben.
Dies geschieht indem eine Schleife mit der Variablen leg alle Sensoren
durchzählt. Bei jedem Durchlauf wird an das bestehende Array der String
„Force “ plus der Bezeichnung des aktuellen Sensors hinzugefügt, um so nach
dem Ende der Schleife eine Liste mit allen Kurvenbezeichnungen zu erhalten.

3.3 Statische Messung - Erklärung des Programms zur automatischen Messauswertung 43
Zu dem Diagramm werden noch die Abszissen- und Ordinaten-Beschriftungen
festgelegt, der Diagrammtitel hinzugefügt und die Achsenbegrenzungen gesetzt.
if forces_v(force_nr) < 1000
F = ['0' F];
end
Sollte die aktuelle angebrachte Kraft kleiner als Tausend sein, wird vor den String
dieser Kraft, der in der auszugebenden png-Bilddatei Verwendung findet, eine
Null hinzugefügt, um eine sinnvolle Sortierung der Dateien unter Windows zu
gewährleisten.
Anstatt die Werte aller Sensoren in einem Diagramm sowohl für jede gemessene
Spalte (Abschnitt #1), als auch für jede gemessene Reihe (Abschnitt #2) bei jeder
angebrachten Kraft zu zeichnen, lassen sich auch Diagramme jeweils für einen
Sensor erstellen, die jeweils alle gemessenen Spalten (Abschnitt #4) oder alle
gemessenen Reihen (Abschnitt #3) enthalten, wieder jeweils für jede angebrachte
Kraft. Des Weiteren lassen sich zu letzteren beiden Diagrammen auch zusätzlich
Ausgleichsgeraden eines horizontalen (Abschnitt #6) bzw. vertikalen (Abschnitt
#5) Verlaufs in das Diagramm zeichnen, jedoch hat dies aufgrund des
nichtlinearen vertikalen Verlaufs dort keinen Zweck.

4.1 Dynamische Messung - Durchführung der Messung 44
4. Dynamische Messung
4.1. Durchführung der Messung
Ziel der dynamischen Messung war es nicht, noch einmal die komplette Platte mit
Impulsen zu vermessen, sondern eine Sammlung von verschiedenen Kraft-Zeit-
Verläufen für die Auswertung zu sammeln. Für die Messung wurde das gleiche
Raster der zweiten statischen Messung verwendet. Anstatt des Kraftmessers
wurde ein Hubmagnet auf der Messschiene befestigt, der über einen Verstärker
mit einem externen Netzteil mit dem Computer verbunden ist. An dem Magneten
ist ein weiterer Kraftsensor angebracht, der direkt die vom Magneten auf die
Platte aufgebrachte Kraft misst. Der Messablauf konnte vereinfacht werden, da
die einzelnen Messungen nun komplett vom Computer aus steuerbar sind. Zu
Beginn einer Messung wird zunächst über einen Schieberegler die Spannung des
Magneten eingestellt. Bei Betätigung des Buttons für die Messung wird für 1,5s
im Messverstärker „hold“ deaktiviert, um den Offset der Sensoren
herunterzuregeln, und anschließend wieder für die Messung zu aktivieren. Nach
0,5s, dieses Zeitintervall wird bei der Auswertung für den Ruhewert genutzt, wird
für 2s die eingestellte Spannung an dem Magneten angelegt. Dieser Vorgang wird
an jedem Punkt für vier verschiedene Kräfte bzw. Spannungen wiederholt. Um
bei allen Messpunkten Impulse gleicher Stärke zu erhalten, muss der Hubmagnet
immer im gleichen Abstand von der Platte angebracht werden. Dazu wurde bei
diesem Versuch vor einer Messung ein Plastiklineal so zwischen Platte und
Sensor angebracht, dass am Kraftsensor des Hubmagneten gerade keine Kraft
anlag.
4.2. Auswertung und Ergebnisse der Messung
Der Unterschied zwischen dynamischer und statischer Messung, besteht darin,
dass hier keine konstante Kraft gemessen wird, von der bei der Auswertung
einfach ein Mittelwert über dem Messintervall genommen werden kann, sondern
ein ständig variierender Kraftverlauf. Deshalb kam es bei der Auswertung vor
allem darauf an, eine Möglichkeit, aus diesem Kraftverlauf wieder eine konstante
Kraft auszulesen, zu finden und die Stärke des Impulses zu bestimmen. Dazu
wurde anfangs das Muster eines dynamischen Zeit-Kraft-Verlaufs analysiert, um
daraus Kriterien für eine automatische Auswertung zu entwickeln.

4.2 Dynamische Messung - Auswertung und Ergebnisse der Messung 45
t0 t1 t2 t3 t4
Diagramm 4-1: Zeit-Kraft-Verlauf eines Impulses
Diagramm 4-1 zeigt den Zeit-Kraftverlauf eines Sensors mit einer hohen
Amplitude zur Zeit des Eintreffens des Impulses des Hubmagneten, stellvertretend
als Beispiel für die Kurven aller Sensoren. Zu Beginn des dargestellten Intervalls
zum Zeitpunkt t0 befinden sich die Platte in Ruhe, der Hubmagnet ist vollständig
von der Platte entfernt. Gleichzeitig wird an ihm die verstärkte
Ausgangsspannung des Computers angelegt. In dem Intervall von t0 bis t1 trifft
nun die in Bewegung gebrachte Spitze des Magneten auf die Platte auf und
wandelt ihre kinetische Energie in elastische Energie der Platte um. Zum
Zeitpunkt t1 ist die kinetische Energie komplett in elastische Energie
umgewandelt worden, d.h. der Magnet hat die Geschwindigkeit Null und die
Platte ist maximal gespannt, was dazu führt, dass der Magnet wieder leicht in die
entgegengesetzte Richtung beschleunigt wird, aber durch die immer noch
wirkende Kraft auf der Platte gehalten wird, wobei die elastische Energie wieder
in kinetische Energie übergeht. Die Kraft des Magneten sorgt nun dafür, dass der
Magnet wieder abgebremst und auf die Platte zu beschleunigt wird. So findet die
ganze Zeit ein Wechsel zwischen kinetischer Energie und elastischer Energie statt,
der zur im Diagramm sichtbaren Schwingung des Systems führt. Die Schwingung

4.2 Dynamische Messung - Auswertung und Ergebnisse der Messung 46
wird dadurch gedämpft, dass dem System durch Reibung Energie entzogen wird,
was zu einer exponentiellen Abnahme der Amplitude führt. Bei ca. Zeitpunkt t2
hat sich das System stabilisiert, es herrscht ein Kräftegleichgewicht zwischen der
Kraft des Magneten und der Gegenkraft der Platte, das bis Zeitpunkt t3
beibehalten wird. Dann wird nach 2s bei Zeitpunkt t3 die Spannung vom
Hubmagneten entfernt, wodurch dieser schlagartig, beschleunigt durch einen
Gummiring, der an dem Magneten angebracht ist, von der Platte zurückschnellt.
Durch den schnellen Abfall der Kraft des Magneten herrscht nun kein
Kräftegleichgewicht mehr und die Platte wird, da die Masse der Platte konstant
ist, gemäß dem zweiten Newton’schem Axiom nach F = m * a (Kraft ist gleich
Masse mal Beschleunigung), in Bewegung gesetzt, wobei die elastische Energie
der Platte in Bewegungsenergie umgewandelt wird, was, genauso wie schon beim
Eintreffen des Impulses beschrieben, zu einem Ausschwingen der Platte führt, bis
sie sich ca. bei Zeitpunkt t4 auf ihrem Neutralwert stabilisiert.
Ein mechanisches Analogon hierzu ist das vertikal gedämpft schwingende
Federpendel, bei dem ebenfalls die Energie ständig zwischen kinetischer und
elastischer Energie umgewandelt wird. Stabilisiert wird das Pendel an dem Punkt,
wo Federkraft und Gewichtskraft der Masse des Pendelkörpers im Gleichgewicht
sind. Dem Aufbringen des Impulses auf die Platte entspräche das Fallenlassen des
Pendelgewichtes und das anschließende Einpendeln auf der Ruheposition. Dem
schlagartigen Entfernen des Hubmagneten entspräche das Abtrennen des im
Gleichgewicht mit der Feder befindlichen Pendelgewichtes und das anschließende
Ausschwingen der Feder.
P1
P2

4.2 Dynamische Messung - Auswertung und Ergebnisse der Messung 47
Diagramm 4-2: Ermittlung der Kraft des Hubmagneten
Nun ist zunächst das Ziel der Auswertung, die konstante Kraft des Hubmagneten
während dem Kräftegleichgewicht zu ermitteln.
Wie in Diagramm 4-1 gezeigt, sind für die Ermittlung der Kraft des Hubmagneten
die Zeitpunkte t1 und t3 wichtig, da zwischen ihnen diese Kraft aufgebracht wird.
Um diese Punkte automatisch in einer Messung zu finden, wird für jeden
Messpunkt zuerst der Sensor ausgewählt, der bei diesem Zeit-Kraft-Verlauf die
höchste Amplitude besitzt, da dort die Kurve am stärksten ausgeprägt ist. Der
Startpunkt des Kraftintervalls P1 befindet sich in der auf dem mittleren Kraftwert
zwischen dem ersten Hochpunkt und dem ersten Tiefpunkt, also in der Mitte der
ersten Schwingung. Genauso befindet sich der Endpunkt P2 in der Mitte der
letzten Schwingung vor dem Kraftabfall. Der Kraftwert errechnet sich, indem für
jeden Sensor der Mittelwert in dem von den beschriebenen Zeitpunkten
begrenztem Intervall genommen wird.
t1 t2
Diagramm 4-3: Ermittlung des Impulses des Hubmagneten
Diagramm 4-3 zeigt den Ausschnitt aus dem vorherigen Diagramm, auf dem der
Einschlag des Hubmagneten erkennbar ist. Zur Bestimmung der Stärke des
Impulses kommt es auf die Maximalkraft F1 und die Kraft des Hubmagneten F0

4.2 Dynamische Messung - Auswertung und Ergebnisse der Messung 48
bei der Summe aller sechs Sensorkurven an. Die Differenz aus den beiden ist die
Kraft, die durch die zeitliche Impulsänderung des Magneten aufgebracht wird.
Das zweite Newton’sche Axiom sagt auch aus, dass die Kraft die Impulsänderung
pro Zeit ist, also F = p&
, d.h. die Kraft ist die Ableitung des Impulses nach der
Zeit. Integriert man diese Gleichung nach der Zeit, erhält man
t2
∫
t1
F ( t)
dt = p − p , d.h. die Impulsänderung ist das Integral der Kraft über die
2
1
Zeit, wobei der Anfangsimpuls des Magneten p1 gleich Null ist, da dieser in Ruhe
liegt. Die Stärke des Impulses ist also die Fläche unter dem Kraft-Zeit-Verlauf
von F1 bis zu F0, die unten von F0 beschränkt wird. Die Integrationsgrenzen sind
deswegen die Zeitpunkte t1 und t2, zu denen die Kraft der ersten Schwingung
gleich der Kraft des Hubmagneten F0 ist, bzw. am nächsten daran liegt. Von der
Fläche des Integrals wird noch die gesamte Fläche unterhalb von F0 abgezogen.
Mit dieser Berechnung erhält man nun die Fläche, die im Graphen rot markiert ist.
Die Stärke des Impulses ergibt sich folglich aus der Hälfte dieser Fläche.
In
Diagramm 4-4: Zeit-Kraft-Verlauf aller gemessenen Impulse

4.3 Dynamische Messung - Probleme bei der Berechnung 49
Diagramm 4-4 wurden die Zeit-Kraft-Kurven aller 144 gemessenen Messungen
aufeinander gelegt. Es zeigt zum einen, dass der in Diagramm 4-1 gezeigte Ablauf
bei jedem Sensor an jedem Punkt exakt gleich ist und es somit möglich ist, die an
einem Messpunkt bei einem Sensor gefundenen Zeitpunkte auf die anderen
Sensoren anzuwenden. Keine der 144 verschiedenen gemessenen Schwingungen
nach dem Entfernen des Hubmagneten reißt aus dem Schema aus, sie sind alle
gleichphasig. Da es sich um eine freie Schwingung des Systems Platte-Sensoren
handelt, schwingt die dargestellte Schwingung mit der Eigenfrequenz dieses
Systems.
4.3. Probleme bei der Berechnung
Wie Kapitel 2.1 erwähnt, ist das mittlere Sensorpaar verdreht eingebaut und wird
daher von DIAdem invertiert. Jedoch stellte sich nach Abschluss der dynamischen
Messarbeiten heraus, dass wahrscheinlich durch diese Invertierung das Signal der
Messung nur mit 100Hz, d.h. eine Messung alle 10ms, aufgezeichnet wird,
während die vier restlichen Sensoren mit 1000Hz, d.h. eine Messung pro
Millisekunde, aufgezeichnet werden. Das Problem ist nun nicht die
unterschiedliche Messfrequenz für die Sensorsignale, da DIAdem die Daten der
100Hz-Messung automatisch auf zehn Millisekunden ausbreitet (d.h. jedem
wirklich gemessenen Wert neun gleiche Kopien nachfolgen lässt), sondern die
dadurch entstehende Ungenauigkeit. Für die dynamische Messung wurden die
mittlere Reihe, und die drei Reihen über dieser gemessen, also genau auf Höhe
der mittleren Sensoren. Deshalb ist die oben beschriebene Impulsberechnung nur
sehr ungenau, da das Integral zur Impulsberechnung nur eine Länge von ca. 40ms
hat, d.h. die mittleren Sensoren messen während dieser Zeit nur vier Kraftwerte.
Dadurch, dass in dem gemessenen Bereich die mittleren Sensoren die höchste und
die restlichen Sensoren nur eine sehr geringe Amplitude haben, lassen sich auch
die Integrationsgrenzen nur auf 10ms genau bestimmen. Da für die
Impulsberechnung die Summe aus allen sechs Sensoren verwendet wird, breitet
sich diese Ungenauigkeit auf die gesamte Berechnung aus. Um eine genaue
Berechnung zu ermöglichen, müsste diese Messung mit einer durchgängigen
Messfrequenz von 1000Hz wiederholt werden, was leider aus Zeitgründen nicht
durchführbar ist.

5.1 Die Ortberechnung - Berechnung durch zwei Sensorgleichungen 50
5. Die Ortberechnung
5.1. Berechnung durch zwei Sensorgleichungen
Bei der Auswertung der ersten statischen Messung entstanden die in 3.2
beschriebenen Sensorgleichungen. Da zu Beginn der Berechnungen noch wenig
Erfahrung in MATLAB vorlag, wurde vorerst versucht, das Problem der
Ortberechnung mit konventionellen Mitteln zu lösen. Da jede dieser
Sensorgleichungen nur zwei Unbekannte, x und y, besitzt, ist es möglich, dieses
Gleichungssystem auch mit nur zwei Gleichungen zu lösen. Dies kann man
erreichen, indem man eine Gleichung nach x und die andere nach y auflöst und
eine Gleichung jeweils in die andere einsetzt. Man erhält ein Polynom zweiter
Ordnung, das sich mit Hilfe der Lösungsformel für quadratische Gleichungen
(„Mitternachtsformel“) nach x bzw. y auflösen lässt.
Gleichung für ersten Sensor: Q = ( a * y + b)
* x + c * y + d
Gleichung für zweiten Sensor: W = ( e * y + f ) * x + g * y + h
Nach x aufgelöste Gleichung:
− aQ + ah − bg + eW − de + cf +
x =
Nach y aufgelöste Gleichung:
− eW + de − bg + aQ − ah + cf +
y =
( aQ − ah + bg − eW + de − cf )² − 4(
be − af )( −gW
+ cQ − ch + dg)
2(
be − af )
( eW − de + bg − aQ + ah − cf )² − 4(
ag − ce)(
bh − bQ + fW − df )
2(
ag − ce)
Der Nachteil dieser Methode ist, neben der Unübersichtlichkeit, dass der Ort
immer nur aus zwei Sensoren berechnet wird. Allerdings ließen sich dadurch
schon erste Analysen zur Genauigkeit der Berechnung durchführen.
In den folgenden beiden Diagrammen sind die Abweichungen der aus den
Gleichungen von Sensor „ul“ und „ur“ berechneten Koordinaten zu den
tatsächlichen Koordinaten dargestellt. Dort sind jeweils als blaue Quadrate alle
Messpunkte zu sehen, die roten Kreise stellen die berechneten x-Koordinaten, wie
in Diagramm 5-1, bzw. y-Koordinaten, wie in Diagramm 5-2, dar. Zur
Orientierung sind zusätzlich die Positionen der Sensoren markiert.
In Diagramm 5-1 zeigt sich, dass die x-Koordinaten in der Nähe der Sensoren,
also im oberen Viertel der gesamten Platte, mit sehr guter Genauigkeit berechnet
werden. Entfernt man sich immer weiter von den Sensoren, werden die

Platte X
Platte Y
110
90
70
50
30
10
5.1 Die Ortberechnung - Berechnung durch zwei Sensorgleichungen 51
berechneten x-Koordinaten immer weiter gestreut, da durch den weiteren Weg
zum Sensor die am Sensor gemessene Kraft immer mehr verfälscht wird.
Abweichungen MessungFunktion aus ul-ur
90 100 110 120 130 140 150 160 170 180
-10
190
170
150
130
110
Platte Y
Diagramm 5-1: x-Abweichungen Messung - Funktion aus ul-ur
Abweichungen MessungFunktion aus ul-ur
ur ul
90
0 10 20 30 40 50 60 70 80
Platte X
Diagramm 5-2: y-Abweichungen Messung - Funktion aus ul-ur
ul
ur
X-Mess
X-Funktion
Y-Mess
Y-Funktion

5.1 Die Ortberechnung - Berechnung durch zwei Sensorgleichungen 52
Die in Diagramm 5-2 berechneten y-Koordinaten weisen jedoch ein ganz anderes
Abweichungsbild auf. Die berechneten y-Koordinaten scheinen während eines
horizontalen Verlaufs immer in einem Bogen angeordnet zu sein, die größten
Abweichungen gibt es jeweils an den Rändern der Platte. Diagramm 5-3 zeigt
eine übersichtlichere Darstellung dieser Abweichungen. Hier sind die
prozentualen Abweichungen von Funktionswert und Messwert in Abhängigkeit
vom Ort dargestellt.
%
6
5
4
3
2
1
0
-1
-2
-3
-4
99
109
y-Abweichung Messwert Funktion aus ul-ur
119
129
Ort vertikal
139
149
Diagramm 5-3: prozentuale y-Abweichungen dreidimensional
159
Auch hier weist wieder der gleichmäßige Verlauf der Abweichung darauf hin,
dass diese Abweichungen nicht (nur) durch Messungenauigkeiten verursacht
wurden, sondern dass die Funktion eben nicht linear verläuft. Jedoch ergibt sich
für die x-Koordinate eine geringere durchschnittliche Genauigkeit von 6,6%, als
bei der y-Koordinate mit 1,6%. (Berechnet jeweils für jede Zweier-Kombinaten
aus den oberen vier Sensoren: abweichungen_funktion-messwerte-ml_mr.xls,
abweichungen_funktion-messwerte-ml_ul.xls, abweichungen_funktion-messwerte-
ml_ur.xls, abweichungen_funktion-messwerte-mr_ur.xls, abweichungen_funktion-
messwerte-ul_mr.xls und abweichungen_funktion-messwerte-ul_ur.xls)
169
179
68
48
28
8
Ort horizontal
5-6
4-5
3-4
2-3
1-2
0-1
-1-0
-2--1
-3--2
-4--3

5.2 Die Ortberechnung - Berechnung durch mehrere Sensorgleichungen 53
5.2. Berechnung durch mehrere Sensorgleichungen
Die Verwendung von mehreren Gleichungen zur Ortsberechnung, also mehr
Gleichungen als Unbekannte, macht den Einsatz eines Tools zum Lösen dieses
Gleichungssystems nötig, da für dieses Problem keine mathematische Lösung
mehr gibt, sondern eine Lösung, die insgesamt bei allen Gleichungen die
geringste Abweichung aufweist. Die Lösung muss also mit Hilfe der Methode der
kleinsten Fehlerquadrate angenähert werden. Dies kann zum einen mit dem in
Excel integrierten Solver bewerkstelligt werden, jedoch müsste dazu jeder Punkt
einzeln optimiert werden (siehe berechnung_koordinaten_durch_solver.xls).
Zur automatischen Ortsberechnung (siehe Datei DATEI) wird die in MATLAB
integrierte Funktion fsolve zum Lösen nichtlinearer Gleichungssysteme
verwendet. Dazu wird zuerst mit allen Sensoren der Ort eines Messpunktes
berechnet, der anschließend in eines von vier gleich großen Feldern der oberen
Plattenhälfte eingeteilt wird, wo der Ort noch einmal mit den Sensoren berechnet
wird, die für diesen Bereich die besten Ergebnisse erzielen (Genauigkeit: x: 3,4%;
y: 1,9%). Die Genauigkeitsanalyse wurde für jeden Sensor durchgeführt, indem in
jede Sensorgleichung alle gemessenen x- bzw. y-Koordinaten eingesetzt und die
daraus berechneten y- bzw. x-Koordinaten in ein Diagramm mit den tatsächlichen
Koordinaten eingezeichnet wurden. Diagramm 3-1 ist ein Diagramm dieser Art,
für den Sensor „ul“ bei Berechnung der x-Koordinaten.
Diagramm 5-4: x-Abweichungen Messung - Funktion aus ul, y=const

5.3 Die Ortberechnung - Berechnung bei variabler aufgebrachter Kraft 54
5.3. Berechnung bei variabler aufgebrachter Kraft
Wie schon in Diagramm 3-25 gezeigt, verhalten sich alle Kraftwerte eines Sensor
direkt proportional zur angebrachten Kraft, d.h. wird z.B. die doppelte Kraft auf
einen Sensor aufgebracht, verdoppelt sich auch der gemessene Kraftwert an jedem
Messpunkt:
⎛ F1
( x1,
y1)
⎜
⎜ ...
⎜
⎝ F1
( x1,
yrows
)
...
...
...
F1
( xcols
, y1)
⎞ ⎛ F2
( x1,
y1)
⎟ ⎜
... ⎟ = const * ⎜ ...
F ( , ) ⎟ ⎜
1 xcols
yrows
⎠ ⎝ F2
( x1,
yrows
)
...
...
...
F2
( xcols
, y1)
⎞
⎟
... ⎟
F ( , ) ⎟
2 xcols
yrows
⎠
Da dies bei einem einzelnen Sensor zutrifft, gilt dies auch für die Summe aller
Sensoren an einem Messpunkt:
F
F
2−Sensor
2
F
F
1 −Sensor
1 1−Σ
= =
2−Σ
const
Der Programmablauf ist nun folgender: die Ortsberechnung ist für einen
bestimmten Kraftwert F 0−Σ
definiert. Zuerst wird die Summe aller Sensorwerte an
einem Messpunkt F 1−Σ
berechnet, die Kraft die an diesem Punkt auf den Sensor
einwirkt ist F 1.
Gesucht ist der Kraftwert 0 F , der auf dem gleichen Punkt wie F 1
bei einer Gesamtkraft von F 0−Σ
auf den Sensor einwirken würde. Aus der oberen
Gleichung ergibt sich für F 0 :
F
F0
=
F
0−Σ
1−Σ
* F
1

5.4 Die Ortberechnung - Berechnung mit einer Linearkombination 55
5.4. Berechnung mit einer Linearkombination
Bei der Auswertung der zweiten statischen Messung stellte sich heraus, dass die
Fläche der Kraft-Ort-Sensorkurve nicht linear genähert werden kann. Deswegen
war die Idee, die Funktion in vertikaler Richtung aus einem linearen und einem
quadratischen Teil zusammen zu setzen. In Diagramm 5-5 ist in rot der lineare
Verlauf der Gleichung für den oberen Teil der Fläche und in braun der
quadratische Verlauf für den unteren Teil der Fläche in dem Kraft-Ort-Diagramm
für Sensor „ul“ skizziert.
Diagramm 5-5: Kraft-Ort Fläche mit skizzierter vertikaler zusammengesetzter Funktion
Es ist zwar möglich, im zweidimensionalen jeden vertikalen Verlauf wie oben
beschrieben zu optimieren, jedoch funktioniert dies nicht bei dreidimensionalen
Flächen, wie Diagramm 5-6 zeigt.

5.4 Die Ortberechnung - Berechnung mit einer Linearkombination 56
Diagramm 5-6: Kraft-Ort Fläche aus zwei zusammengesetzten Funktionen
Hier wurde die Fläche aus einer linearen Funktion von y=2 bis y=100 und einer
quadratischen von y=100 bis y=184 zusammengesetzt.
Die lineare Funktion (Verlauf horizontal und vertikal linear):
F = ( m * y + t ) * x + m * y + t
1
1
2
2
Die quadratische Funktion (Verlauf horizontal linear, vertikal quadratisch):
F = ( a * y²
+ b * y + c)
* x + d * y²
+ e * y +
Das Problem ist, dass die Optimierung der Gleichungskoeffizienten für jede der
beiden separat durchgeführt wird, d.h. es werden eigentlich zwei verschiedene
Flächen optimiert, die danach zusammengesetzt werden. Dies führt dazu, dass die
Annäherung, im Gesamten betrachtet, sehr ungenau und „eckig“ ausfällt,
besonders an den Nahtstellen.
Da diese Art der Ortsberechnung nun wegfiel, wurde ein alternativer
Lösungsansatz verfolgt. Dieser besteht darin, sowohl die x- als auch die y-
Koordinate als Linearkombination der sechs Sensorenwerte darzustellen:
x = a * F + a * F + a * F + a * F + a * F + a * F
1
1
1
1
2
2
2
2
3
3
y = b * F + b * F + b * F + b * F + b * F + b * F
3
3
4
4
4
4
Dieser Weg ist sehr einfach und schnell zu rechnen, benötigt weniger zu
ermittelnde Gleichungskoeffizienten als der Weg über sechs Sensorgleichungen
und ist teilweise genauer (Abweichung x: 2,4%; y: 2,2%). Auch hier besteht
wieder die Möglichkeit, die Platte in verschiedene Felder zu unterteilen, die mit
verschiedenen Koeffizienten gerechnet werden, jedoch haben Berechnungen
gezeigt, dass sich dadurch nur ein minimal besseres Ergebnis erzielen lässt.
5
5
f
5
5
6
6
6
6

5.4 6.
Ergebnisse und Ausblick - Berechnung mit einer Linearkombination 57
6. Ergebnisse und Ausblick
Diese Seminararbeit zeigt, wie es möglich ist, aus einem unbekannten
Messsystem nur mit Hilfe der Messdaten Rückschlüsse auf dieses System zu
ziehen und daraus ein Modell zu erstellen, mit dem dieses berechenbar wird. Es
war interessant festzustellen, wie aus scheinbar minimalen Veränderungen doch
relativ präzise ein Wert bestimmt werden kann. Durch das Anbringen einer Kraft
auf die Platte wird diese für das menschliche Auge so gut wie nicht sichtbar
bewegt, was aber von den Kraftsensoren, trotz nur winziger Verbiegung ihrer
Aluminiumträger, so genau registriert wird, dass aus den geringfügigen
Unterschieden der sechs Sensoren der Ort des Eintreffens bestimmt werden kann.
Allerdings ergeben sich auch daraus die Nachteile dieses Systems. Diese genaue,
und auch notwendige Messung erfordert aber auch eine mindest ebenso genaue
Messapparatur und Messdurchführung, die teilweise nicht gegeben waren. Die
fälschliche Aufzeichnung der mittleren Sensoren mit 100Hz zeigen, dass trotz
einer, auf den ersten Blick, mit einer Messung alle hundertste Sekunde, sehr
genauen Messaufzeichnung, diese Genauigkeit noch nicht ausreicht, um damit
genaue Ergebnisse zu erzielen.
Da die komplette Berechnung auf Messwerten basiert, wäre es für eine tiefer
gehende Analyse und genauere Berechnung nötig, noch einmal Messungen
durchzuführen. Dazu wäre eine Präzisierung des Messsystems nötig. Die Platte
müsste ständig unter gleicher Temperatur und Luftfeuchtigkeit, also unter
Laborbedingungen, gelagert sein. Auch sollte die Eichung der Sensoren vor dem
Einbau vorgenommen werden. Des Weiteren müssten die mechanischen Elemente
des Systems verstärkt und stabilisiert werden, um für einen festeren Stand der
Apparatur und des Messgestells zu sorgen. Unter diesen Bedingungen wäre dann
eine komplette Vermessung der Platte mit einem engeren Raster denkbar. Auch
sollte für eine genauere Auswertung die gesamte Platte mit verschiedenen
Impulsen vermessen werden, bei einer durchgängigen Messfrequenz von 1000Hz.
Diese Seminararbeit könnte endlos fortgeführt werden. Interessant wäre der
Nachbau des Systems aus Sensoren und Plexiglasplatte mit einem Finite Elemente
Programm, um dort das Verhalten der Platte bei einwirkenden Impulsen
durchzusimulieren und das Schwingungsverhalten sowie die Kraftverteilung und
die Durchbiegung der Platte zu analysieren. Anschließend könnten die dadurch
erhaltenen „theoretischen Messwerte“ mit den tatsächlich gemessenen verglichen

5.4 6.
Ergebnisse und Ausblick - Berechnung mit einer Linearkombination 58
werden, um diese zu bestätigen oder eventuell sogar zu widerlegen. Dazu müssten
wiederum Messungen zur Bestimmung der plattenspezifischen Konstanten wie
dem Elastizitätsmodul unternommen werden.
Durch dieses Projekt habe ich selbst einen kleinen Einblick in die
Forschungstätigkeiten an einer Universität bekommen und halte deswegen das
Seminarfach für eine gute Vorbereitung und einen Vorgeschmack auf ein
Studium. Das Seminarfach ermöglicht die Durchführung komplexerer Projekte,
die bei einer herkömmlichen Facharbeit nicht denkbar sind, genauso wenig wie
eine Arbeit, die mehrere Fachgebiete umfasst. Diese Versuchsdurchführung und –
Auswertung mit MATLAB ® wäre in einem privaten Rahmen nie denkbar
gewesen, weshalb es für die teilnehmende Schüler eine große Chance darstellt,
diese Infrastruktur und Hilfestellung von einem externen Partner zur Verfügung
gestellt zu bekommen. Wünschenswert wäre bei einem umfangreicheren Projekt
jedoch eine längere Bearbeitungszeit gewesen, um die gebotenen Möglichkeiten
auch gebührend auszuschöpfen und somit den oben erwähnten Ausblick in der
Arbeit umzusetzen.

7.1 Anhang - Abbildungsverzeichnis 59
7. Anhang
Abbildungen
7.1. Abbildungsverzeichnis
Abbildung 2-1: Die Degenfechtstation .................................................................... 6
Abbildung 2-2: Eine Wägezelle (Sensor mr) .......................................................... 7
Abbildung 2-3: Die Messelektronik ........................................................................ 8
Abbildung 3-1: Die Messtechnik ........................................................................... 12
Abbildung 3-2: Der Kraftmesser ........................................................................... 13
Diagramme
Diagramm 3-1: Offset bei y=179: Beginn der Messreihe (t=0) ............................ 17
Diagramm 3-2: Offset bei y=99: Ende der Messreihe (t=4h) ................................ 17
Diagramm 3-3: Prozentuale Abweichung von RVor und RNach (y=119) ........... 18
Diagramm 3-4: Prozentuale Abweichung von RNach und RVor des nächsten
Punktes (y=119) ..................................................................................................... 18
Diagramm 3-5: Kraftwerte in Abhängigkeit von x (bei y=179), Werte aus Tabelle
3-1 .......................................................................................................................... 19
Diagramm 3-6: Kraftwerte in Abhängigkeit von y (bei x=68) .............................. 20
Diagramm 3-7: Kraft an Sensor ul in Abhängigkeit vom Ort (erzeugt aus Tabelle
3-2) ........................................................................................................................ 21
Diagramm 3-8: Wie Diagramm 3-7, zusätzlich mit eingezeichneten horizontalen
Geraden .................................................................................................................. 22
Diagramm 3-9: Die in Diagramm 3-8 eingezeichneten Geraden .......................... 22
Diagramm 3-10: Abhängigkeit der Steigung (der horizontalen
Geradengleichungen) von y ................................................................................... 23
Diagramm 3-11: Abhängigkeit des y-Abschnitts (der horizontalen
Geradengleichungen) von y ................................................................................... 23
Diagramm 3-12: Kraftverlauf des Sensors ul (Messwerte) ................................... 24
Diagramm 3-13: Kraftverlauf des Sensors ul (Funktion) ...................................... 24
Diagramm 3-14: Abweichung Funktion - Messwert an Sensor ul ........................ 25
Diagramm 3-15: Kraft in Abhängigkeit von x an Sensor lr; F=4000g .................. 25
Diagramm 3-16: Kraft in Abhängigkeit von y an Sensor ur; F=4000g ................. 26
Diagramm 3-17: Kraft in Abhängigkeit von y; F=500g ........................................ 28
Diagramm 3-18: Kraft in Abhängigkeit von y; F=1000g ...................................... 28

7.1 Anhang - Abbildungsverzeichnis 60
Diagramm 3-19: Kraft in Abhängigkeit von y; F=2500g ...................................... 29
Diagramm 3-20: Kraft in Abhängigkeit von y; F=4000g ...................................... 29
Diagramm 3-21: Kraft in Abhängigkeit vom Ort (ur); F=500g ............................ 30
Diagramm 3-22: Kraft in Abhängigkeit vom Ort (ur); F=1000g .......................... 30
Diagramm 3-23: Kraft in Abhängigkeit vom Ort (ur); F=2500g .......................... 31
Diagramm 3-24: Kraft in Abhängigkeit vom Ort (ur); F=4000g .......................... 31
Diagramm 3-25: Untersuchung der Proportionalität von 4000g und 2500g an
Sensor ul ................................................................................................................ 32
Diagramm 3-26: Angebrachte Kraft in Abhängigkeit der Summe der Sensorwerte
............................................................................................................................... 32
Diagramm 3-27: Summe der Sensorwerte in Abhängigkeit vom Ort; F=4000g .. 33
Diagramm 4-1: Zeit-Kraft-Verlauf eines Impulses ............................................... 45
Diagramm 4-2: Ermittlung der Kraft des Hubmagneten ....................................... 47
Diagramm 4-3: Ermittlung des Impulses des Hubmagneten ................................. 47
Diagramm 4-4: Zeit-Kraft-Verlauf aller gemessenen Impulse.............................. 48
Diagramm 5-1: x-Abweichungen Messung - Funktion aus ul-ur .......................... 51
Diagramm 5-2: y-Abweichungen Messung - Funktion aus ul-ur .......................... 51
Diagramm 5-3: prozentuale y-Abweichungen dreidimensional ............................ 52
Diagramm 5-4: x-Abweichungen Messung - Funktion aus ul, y=const ................ 53
Diagramm 5-5: Kraft-Ort Fläche mit skizzierter vertikaler zusammengesetzter
Funktion ................................................................................................................. 55
Diagramm 5-6: Kraft-Ort Fläche aus zwei zusammengesetzten Funktionen ........ 56
Formeln
Formel 3-1: Aufbau des Gleichungssystems ......................................................... 40
Tabellen
Tabelle 3-1: Wertetabelle für die Reihe y=179 ..................................................... 19
Tabelle 3-2: Dreidimensionale Wertetabelle von Sensor ul (Kraft in Abhngigkeit
vom Ort) ................................................................................................................ 21
Tabelle 3-3: Aufbau der Matrix ForceIn ........................................................... 36
Tabelle 3-4: Eine einzelne dreidimensionale Wertetabelle ................................... 38

7.2 Anhang - Quelltext MATLAB®-Programme 61
7.2. Quelltext MATLAB ® -Programme
7.2.1. pfaller_auswertung_dynamisch.m
Programm zur Auswertung der DIAdem-Messdateien von dynamischen Messungen. Benötigt das Programm ShowData der Universität. (Hinzufügen
mit: File > Set Path...)
% Benötigt das Programm ShowData der Universität. (Hinzufügen mit: File >
% Set Path...)
clear;
% function GetDataFromChannel
global Header;
solution = dlmread('gerade.txt');
m = solution(1, 1);
t = solution(2, 1);
Mess = [];
row = 1;
koordinaten = [];
amplitudes_ll = [];
amplitudes_lr = [];
amplitudes_ml = [];
amplitudes_mr = [];
amplitudes_ul = [];
amplitudes_ur = [];
amplitudes_ll_mean = [];

7.2 Anhang - Quelltext MATLAB®-Programme 62
amplitudes_lr_mean = [];
amplitudes_ml_mean = [];
amplitudes_mr_mean = [];
amplitudes_ul_mean = [];
amplitudes_ur_mean = [];
amplitudes_mag_f = [];
amplitudes_mag_in = [];
% #########################################################################
% Beginn vorgefertigter Quelltext
[ffiles, fpath] = ListFilesForSelect;
ffile = [];
fileNr = length(ffiles);
if ~isempty(ffiles)
detectUiPp.prompText = 'Now select your desired file.dat!';
detectUiPp.boxHeaders = {' '};
for i = 1:fileNr
detectUiPp.boxNames(i, 1) = {[ffiles(i).name ' ' ffiles(i).comment]};
detectUiPp.boxValues(i, 1) = 0;
end
end
qq = AutoDetectUIInput(detectUiPp); % local function
if ~ischar(qq)
for i = 1:fileNr
if qq.boxValues(i, 1)=='1';
ffile = ffiles(i).name;
break;
end
end
end
clear detectUiPp qq ffiles;
if ~isempty(ffile),

7.2 Anhang - Quelltext MATLAB®-Programme 63
Header.FullFilename = '';
fullfilename = fullfile(fpath, ffile);
if strcmpi(ffile((end - 2):end), 'DAT'), % DIADEM file.
hfilename = [fullfilename(1:(end - 4)), '_diaheader.mat'];
if exist(hfilename),
load(hfilename); % open MAT file with HEADER data.
if ~strcmp(Header.FullFilename, fullfilename), %---
Header.FullFilename = fullfilename;
[fpath, dummy] = fileparts(fullfilename);
Header.FilePath = fpath;
save(hfilename, 'Header')
end
else,
Header = TransformDiademToMat(fullfilename);
end
else
dummy = ['File type ', fullfilename((end - 2):end), ...
'is not supported.'];
Notify(dummy, [], 'r')
error([' ### ShowData: ', dummy])
end
for i = 1:Header.NChannels,
switch Header.Channel(i).Name
case 'control'
[amplitude, xnew] = GetDiaData(i, 0, Header.Channel(i).Length);
Mess = (find(diff(amplitude)>0.5) + 1);
Mess = [Mess(1); Mess(find(diff(Mess)>1500)+1)];
end
end
% Ende vorgefertigter Quelltext
% #####################################################################
% Schreiben der Daten der einzelnen Kanäle zu den vorher gefundenen

7.2 Anhang - Quelltext MATLAB®-Programme 64
% Zeitpunkten in ihre Matrizen
for j = 1:size(Mess, 1), % Zählt alle gefundennen Messzeitpunkte durch
for i = 1:Header.NChannels, % Zählt die Messkanäle durch
switch Header.Channel(i).Name % Wählt je nach Name des Messkanals
case 'X'
[Ynew, Xnew] = GetDiaData(i, Mess(j, 1)+500, 5000);
koordinaten(row, 1) = mean(Ynew);
case 'Y'
[Ynew, Xnew] = GetDiaData(i, Mess(j, 1)+500, 5000);
koordinaten(row, 2) = mean(Ynew);
case 'ForceIn_ll'
% GetDiaData(Kanalnummer, Startzeitpunkt, Intervallänge);
% Y_offset: Amplituden in Intervall (500ms)
[Y_offset, X_offset] = GetDiaData(i, Mess(j, 1), 500);
offset = [];
offset = mean(Y_offset); % Offset = Mittelwert auf Intervall
% Ynew: Matrix mit Aplituden der Messung
[Ynew, Xnew] = GetDiaData(i, Mess(j, 1)+500, 5000);
% Offsetkorrektur
amplitudes_ll(size(amplitudes_ll, 1)+1, :) = Ynew - offset;
case 'ForceIn_lr'
[Y_offset, X_offset] = GetDiaData(i, Mess(j, 1), 500);
offset = [];
offset = mean(Y_offset);
[Ynew, Xnew] = GetDiaData(i, Mess(j, 1)+500, 5000);
amplitudes_lr(size(amplitudes_lr, 1)+1, :) = Ynew - offset;
case 'ForceIn_ul'
[Y_offset, X_offset] = GetDiaData(i, Mess(j, 1), 500);
offset = [];

7.2 Anhang - Quelltext MATLAB®-Programme 65
offset = mean(Y_offset);
[Ynew, Xnew] = GetDiaData(i, Mess(j, 1)+500, 5000);
amplitudes_ul(size(amplitudes_ul, 1)+1, :) = Ynew - offset;
case 'ForceIn_ur'
[Y_offset, X_offset] = GetDiaData(i, Mess(j, 1), 500);
offset = [];
offset = mean(Y_offset);
[Ynew, Xnew] = GetDiaData(i, Mess(j, 1)+500, 5000);
amplitudes_ur(size(amplitudes_ur, 1)+1, :) = Ynew - offset;
case 'ForceIn_ml_i(5)'
[Y_offset, X_offset] = GetDiaData(i, Mess(j, 1), 500);
offset = [];
offset = mean(Y_offset);
[Ynew, Xnew] = GetDiaData(i, Mess(j, 1)+500, 5000);
amplitudes_ml(size(amplitudes_ml, 1)+1, :) = Ynew - offset;
case 'ForceIn_mr_i(6)'
[Y_offset, X_offset] = GetDiaData(i, Mess(j, 1), 500);
offset = [];
offset = mean(Y_offset);
[Ynew, Xnew] = GetDiaData(i, Mess(j, 1)+500, 5000);
amplitudes_mr(size(amplitudes_mr, 1)+1, :) = Ynew - offset;
case 'ForceMagIn'
[Y_offset, X_offset] = GetDiaData(i, Mess(j, 1), 500);
offset = [];
offset = mean(Y_offset);
[Ynew, Xnew] = GetDiaData(i, Mess(j, 1)+500, 5000);
amplitudes_mag_f(size(amplitudes_mag_f, 1)+1, :) = Ynew - offset;
case 'HubMagIn'
[Y_offset, X_offset] = GetDiaData(i, Mess(j, 1), 500);

7.2 Anhang - Quelltext MATLAB®-Programme 66
end
end
end
end
row = row + 1;
offset = [];
offset = mean(Y_offset);
[Ynew, Xnew] = GetDiaData(i, Mess(j, 1)+500, 5000);
amplitudes_mag_in(size(amplitudes_mag_in, 1)+1, :) = Ynew - offset;
hold on;
for n = 1:size(amplitudes_ll, 1)
% Suchen des Messpunktes mit der höchsten Amplitude
maximum = [max(max(amplitudes_ll(n, :))), max(max(amplitudes_lr(n, :))), max(max(amplitudes_ml(n, :))),
max(max(amplitudes_mr(n, :))), max(max(amplitudes_ul(n, :))), max(max(amplitudes_ur(n, :)))];
nr = find(maximum == max(maximum));
switch nr
case 1
value = amplitudes_ll(n, :);
case 2
value = amplitudes_lr(n, :);
case 3
value = amplitudes_ml(n, :);
case 4
value = amplitudes_mr(n, :);
case 5
value = amplitudes_ul(n, :);
case 6
value = amplitudes_ur(n, :);
end
% Finden des Startwerts x1 des Kraftintervalls

7.2 Anhang - Quelltext MATLAB®-Programme 67
% Position von x1 = Mitte der 1. Schwingung nach dem Kraftanstieg
x1_1 = 50; % Startwert 50 [ms], kurz vor dem Kraftanstieg
% Suchen des 1. HOP
while value(x1_1) = value(x1_2+1)
x1_2 = x1_2 + 1; % x1_1 ist die Position des TIP nach dem 1. HOP
end
% Von jedem Kraftert zwischen HOP und TIP in der Matrix wird der Mittelwert der beiden subtrahiert
delta_1 = value(1, x1_1:x1_2) - (ones(1, x1_2 - x1_1 + 1) * (value(x1_1) + value(x1_2))/2);
delta_1 = abs(delta_1); % Betrag der obigen Matrix
% Findet das Minimum der Matrix (= Punkt der am nächsten am Mittelwert gelegen ist
x1 = find(delta_1 == min(delta_1), 1, 'last');
x1 = x1 + x1_1 - 1;
% Finden des Endwerts x2 des Kraftintervalls
% Position von x2 = Mitte der letzten Schwingung vor dem Kraftabfall
x2_1 = find(value == min(value), 1, 'first'); % Startwert ist Minimum der gesamten Kurve
% Suchen des 1. HOP vor dem Minimum
while value(x2_1)

7.2 Anhang - Quelltext MATLAB®-Programme 68
while value(x2_2) >= value(x2_2-1)
x2_2 = x2_2 - 1; % x2_1 ist die Position des letzten TIP vor dem Kraftabfall
end
% Finden des Punktes x2 der dem Mittelwert aus x2_1 und x2_2 am nächsten liegt
delta_2 = value(1, x2_2:x2_1) - (ones(1, x2_1 - x2_2 + 1) * (value(x2_1) + value(x2_2))/2);
delta_2 = abs(delta_2);
x2 = find(delta_2 == min(delta_2), 1, 'first');
x2 = x2 + x2_2 - 1;
clear summe;
summe = (amplitudes_ll(n, :)); % Addieren der Kräfte aller Sensoren
summe = summe + (amplitudes_lr(n, :)); % (zur Übersicht untereinander geschrieben)
summe = summe + (amplitudes_ml(n, :));
summe = summe + (amplitudes_mr(n, :));
summe = summe + (amplitudes_ul(n, :));
summe = summe + (amplitudes_ur(n, :));
% Finden der 1. Integrationsgrenze des Impulses
% Position: Stelle zwischen 1 und x1_1, die am nähesten an der
% konstanten Kraft liegt
delta_i1 = summe(1:x1_1) - ones(1, x1_1) * mean(summe(x1:x2));
delta_i1 = abs(delta_i1);
i_start = find(delta_i1 == min(delta_i1), 1, 'first');
% Finden der 2. Integrationsgrenze des Impulses
% Position: Stelle zwischen x1_1 und x1_2, die am nähesten an der
% konstanten Kraft liegt

7.2 Anhang - Quelltext MATLAB®-Programme 69
delta_i2 = summe(x1_1:x1_2) - ones(1, x1_2 - x1_1 + 1) * mean(summe(x1:x2));
delta_i2 = abs(delta_i2);
i_end = find(delta_i2 == min(delta_i2), 1, 'last');
i_end = i_end + x1_1 - 1;
% Berehnung des Impulses
impuls = sum(summe(i_start:i_end)); % Integrieren des Impulses mit den vorher gefundenen Grenzen
impuls = impuls - mean(summe(x1:x2)); % Abziehen der konstanten Kraft (=Fläche unter der konstanten Kraft)
impuls = impuls * (i_end - i_start + 1) / 2; % Halbieren der Fläche
impuls = impuls / 1000; % Umrechnung der Millisekunden auf Sekunden
impuls = impuls * m + t; % Umrechnung der Sensorspannung in g
impuls = impuls / 1000; % Umrechnung der g in kg
impuls = impuls * 9,81; % Umrechnung der kg in N
impuls_matrix(n, 1) = impuls; % Schreiben des aktuellen Impulses in eine Matrix
% Berechnen der Mittelwerte
amplitudes_ll_mean(n, 1) = mean(amplitudes_ll(n, x1:x2));
amplitudes_lr_mean(n, 1) = mean(amplitudes_lr(n, x1:x2));
amplitudes_ml_mean(n, 1) = mean(amplitudes_ml(n, x1:x2));
amplitudes_mr_mean(n, 1) = mean(amplitudes_mr(n, x1:x2));
amplitudes_ul_mean(n, 1) = mean(amplitudes_ul(n, x1:x2));
amplitudes_ur_mean(n, 1) = mean(amplitudes_ur(n, x1:x2));
amplitudes_mag_f_mean(n, 1) = mean(amplitudes_mag_f(n, x1:x2));
amplitudes_mag_in_mean(n, 1) = mean(amplitudes_mag_in(n, x1:x2));
end
hold off;
% Schreiben der gefundenen Werte in eine Matrix
amplitudesMess(:, 1:2) = koordinaten;
amplitudesMess(:, 3) = amplitudes_ll_mean;
amplitudesMess(:, 4) = amplitudes_lr_mean;
amplitudesMess(:, 5) = amplitudes_ul_mean;
amplitudesMess(:, 6) = amplitudes_ur_mean;
amplitudesMess(:, 7) = amplitudes_ml_mean;

7.2 Anhang - Quelltext MATLAB®-Programme 70
amplitudesMess(:, 8) = amplitudes_mr_mean;
amplitudesMess(:, 9) = impuls_matrix;
amplitudesMess(:, 10) = amplitudes_mag_f_mean;
amplitudesMess(:, 11) = amplitudes_mag_in_mean;
xlswrite(amplitudesMess, 'dynamisch_Mess_neue_messungen')
% xlswrite(amplitudesMess, 'Dynamische Messung', {'X', 'Y', 'ForceIn_ll', 'ForceIn_lr', 'ForceIn_ul', 'ForceIn_ur',
'ForceIn_ml', 'ForceIn_mr', 'Impuls', 'Mag_F', 'Mag_in'}, 'dynamisch_Mess_neue_messungen', 'Tabelle1');

7.2 Anhang - Quelltext MATLAB®-Programme 71
7.2.2. pfaller_auswertung_messdaten.m
Programm zum automatischen Auswerten von Messungen. In Zeile 7 und 8 müssen die Speicherpfade der Excel-Tabellen mit den korrigierten Ruhe-
Vor- und Mess-Daten eingegeben werden. Bei dynamischen Messungen muss das Kommentarzeichen in Zeile 39 entfernet werden, da es bei dieser Art
von Messung keine Ruhewerte gibt. Erzeugt die Datei gerade.txt, wird von Programm pfaller_ortberechnung_impuls.m benötigt.
clear;
%##########################################################################
% Matrizen mit den Messwerten
Mess = xlsread('D:\Pfaller\Auswertung\excel\statisch_Mess_neue_messungen_korrigiert.xls'); % Gemessene Kraftwerte
RVor = xlsread('D:\Pfaller\Auswertung\excel\statisch_RVor_neue_messungen_korrigiert.xls'); % Gemessene Ruhewerte
% Messparameter
rows = 14; % Anzahl der gemessenen Reihen
cols = 9; % Anzahl der gemessenen Spalten
forces_v = [500, 1000, 2500, 4000]; % Die verschiedenen angebrachten Kräfte in [g] (sortiert nach Messreihenfolge)
sensors_v = {'ll', 'lr', 'ul', 'ur', 'ml', 'mr'}; % Bezeichnungen der Sensoren
colors = {'b', 'm', 'y', 'c', 'g', 'r'}; % Farben der Sensoren in den Diagrammen
%##########################################################################
% PROGRAMMBEGINN

7.2 Anhang - Quelltext MATLAB®-Programme 72
forces = length(forces_v); % Anzahl der verschiedenen angebrachten Kräfte
sensors = length(sensors_v); % Anzahl der Sensoren
x_max = round((max(Mess(:, 1)) + 10) / 10) * 10; % Obere Grenze für Achsen mit x-Werten
y_max = round((max(Mess(:, 2)) + 10) / 10) * 10; % Obere Grenze für Achsen mit y-Werten
F_max = round((max(max(Mess(:, 3:(sensors + 2)))) + 1)); % Obere Grenze für Achsen mit F-Werten
F_min = round((min(min(Mess(:, 3:(sensors + 2)))) - 1)); % Untere Grenze für Achsen mit F-Werten
% Erstellen der Matrix ForceIn mit Koordinaten der Messpunkte (Spalte 1-2), Offset-korrigierten
% Kraftwerten für jeden Sensor (3-8), Summe der Kräfte pro Messpunkt (9), angebrachte Kräfte (10)
%!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
% RVor = zeros(rows * cols * forces, sensors + 4); % Aktivieren bei dynamischen Messungen, da diese bereits Offsetkorrigiert
sind
%!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
ForceIn = zeros(rows * cols * forces, sensors + 4);
ForceIn(:, 1) = Mess(:, 1); % X-Koordinaten
ForceIn(:, 2) = Mess(:, 2); % Y-Koordinaten
for sen = 1:sensors
% Berechnen der tatsächlichen Kraftwerte jedes Sensors
% Kraftwert = Messwert - Ruhe_vor
ForceIn(:, 2 + sen) = Mess(:, 2 + sen) - RVor(:, 2 + sen);
end
% Bilden der Summe der Kraftsensorwerte für jeden Messpunkt
ForceIn(:, sensors + 3) = ForceIn(:, sensors + 3) + ForceIn(:, 2 + sen);
% Erstellen einer Spalte mit den angebrachten Kraftwerten
for c = 1:forces:(rows * cols * forces)
for n = 1:forces;

7.2 Anhang - Quelltext MATLAB®-Programme 73
end
end
ForceIn(c+n-1, sensors + 4) = forces_v(1, n);
% Erstellen von dreidimensionalen Wertetabellen für jeden Sensor und die
% Summe der Kräfte, in Abhängigkeit des Ortes, jeweils für jede angebrachte Kraft
for sen = 1:(sensors + 1)
for f = 1:forces
n = (sen-1) * (rows + 2);
m = (f-1) * (cols + 2);
for j = 2:(rows+1) % matrix vertikal
for i = 2:(cols+1) % matrix horizontal
reihe = ((i-1) * rows - (j-2)) * forces;
x_wert = ForceIn(reihe, 1);
y_wert = ForceIn(reihe, 2);
end
end
end
end
Werte(1 + n, i + m) = x_wert; % X
Werte(j + n, 1 + m) = y_wert; % Y
Werte(j + n, i + m) = ForceIn((reihe - 4 + f), 2 + sen); % Daten
% Exportieren der offsetkorrigierten Messwerte aller Sensoren in Listenform in Excel
xlswrite('statisch_Mess-Offset', ForceIn);
% xlswrite(ForceIn, 'Statische Messung (ohne Offset)', {'X', 'Y','ForceIn_ll', 'ForceIn_lr', 'ForceIn_ul', 'ForceIn_ur',
'ForceIn_ml', 'ForceIn_mr', 'Kraft [g]', 'Summe Kräfte'}, 'statisch_Mess-Offset', 'Tabelle1');
% Export der dreidimensionalen Wertetabellen für jeden Sensor und für jede Kraft
for sen = 1:(sensors + 1)

7.2 Anhang - Quelltext MATLAB®-Programme 74
end
for f = 1:forces
end
F_str = num2str(forces_v(f)); % Die aktuelle Kraft als String
if forces_v(f) < 1000
F_str = ['0' F_str]; % Fügt bei dreistelligen Zahlen eine 0 vor den String
end % (notwendig für richtige Sortierung der Dateien unter Windows)
if sen == (sensors + 1) % Wenn der Sensorzähler um 1 größer ist als die Anzahl der Sensoren
Sen_str = 'ges'; % enthält 'matrix' die Summe der Sensorwerte -> 'ges' als Sensorname
else
Sen_str = char(sensors_v(sen)); % Dr aktuelle Sensorname als String
end
n1 = 1 + (sen - 1) * (rows + 2); % Vertikaler Startpunkt der Einzelmatrix
n2 = (sen) * (rows + 2) - 1; % Vertikaler Endpunkt der Einzelmatrix
m1 = 1 + (f - 1) * (cols + 2); % Horizontaler Startpunkt der Einzelmatrix
m2 = (f) * (cols + 2) - 1; % Horizontaler Endpunkt der Einzelmatrix
filename = ['F_' Sen_str '_', F_str]; % Zusammensetzen des Dateinamen
matrix = Werte(n1:n2, m1:m2); % Bilden der Matrix aus den Start- und Endpunkten
% Exportieren der Matrix des jweiligen Sensors mit der jeweiligen wirkenden Kraft in Excel
% xlswrite(filename, matrix);
% xlswrite(matrix, filename, {''}, filename, 'Tabelle1');
% Erzeugt ein Diagramm mit den Summen der Sensorwerte jedes Messpunktes in
% Abhängigkeit der angebrachten Kraft und erzeugt eine Ausgleichsgerade:
% Kraft(Sensorwert) = m * Sensorwert + t
hold off;

7.2 Anhang - Quelltext MATLAB®-Programme 75
newplot;
hold on; % Alle Plots werden in eine Graphik geplottet
row = 1;
% Plottet die Messwerte
Forces_y = ForceIn(:, sensors + 4);
Forces_x = ForceIn(:, sensors + 3);
plot(Forces_x, Forces_y, 'y.-', 'MarkerEdgeColor', 'r', 'MarkerFaceColor', 'r', 'MarkerSize',10);
% Erstellen einer Matrix mit der "linken Seite" mit des Gleichungssystems
% Sensorwert * m + 1 * t = Kraft
% in der Form "[Sensorwert, 1]"
for n = 1:rows * cols * forces
links(n, :) = [Forces_x(n, 1), 1];
end
solution = links\Forces_y; % Lösen des Gleichungssystems
m = solution(1, 1);
t = solution(2, 1);
% Erstellen einer Wertetabelle der Geradengleichung zum Plotten der Funktion
x = 0:0.1:(F_max+1);
y = m * x + t;
% Umwandlung des Parameters 't' in einen String
if t > 0
t_string = ['+ ' num2str(t)]; % Fügt ein "+" vor den String, wenn 't' positiv ist
end
if t < 0
t_string = num2str(t); % Wandelt 't' in einen String um
end
if t == 0

7.2 Anhang - Quelltext MATLAB®-Programme 76
end
t_string = ''; % Erzeugt einen leeren String, falls 't' 0 ist
string = ['f(x) = ' num2str(m) ' * x ' t_string]; % Erzeugt einen String mit der Geradengleichung
plot(x, y, 'Color', 'b', 'LineWidth',2); % Plottet die Gerade
ylabel('Angebrachte Kraft [g]'); % x-Achsenbeschriftung
xlabel('Summe der Sensorwerte'); % y-Achsenbeschriftung
title('Angebrachte Kraft in Abhängigkeit der Summe der Sensorwerte'); % Diagrammtitel
% Zeigt die Geradengleichung im Diagramm an (Poistion hängt von Messwerten ab)
text(1, forces_v(length(forces_v)), string);
% Legt die Begrenzung der Achsen fest (abhängig von Messwerten)
axis ([0, F_max+1, 0, (forces_v(length(forces_v))+500)]);
print -dpng sensorwerte_versch_kraefte; % Exportiert das Diagramm als png-Bilddatei
hold off;
% #########################################################################
% #1: vertikal alle Sensoren
% Plottet für jede Spalte (= jeden gemessenen x-Wert) ein Diagramm mit
% den 6 Sensorwerten in Abhängigkeit von y
for col_nr = 1:(rows*forces):(rows * cols * forces) % Ein Durchlauf pro Spalte
for force_nr = 1:forces % Ein Durchlauf pro Kraft
hold off;
newplot;

7.2 Anhang - Quelltext MATLAB®-Programme 77
hold on;
for sen = 1:sensors % Ein Durchlauf pro Sensor
row = 1;
for n = 1:forces:(forces * rows)
Plot (row, 1) = ForceIn (n + force_nr + col_nr - 2, 2); % x-Werte des Diagramms (y-werte der
Messung)
Plot (row, 2) = ForceIn (n + force_nr + col_nr - 2, 2 + sen); % y-Werte des Diagramms (Kraftwerte der
Messung)
row = row + 1;
end
line = 1.5;
marker = 15;
color = char(colors(sen));
style = [color, '.-'];
plot(Plot(:,1), Plot(:,2), style, 'MarkerEdgeColor', color, 'MarkerFaceColor', color, 'LineWidth', line,
'MarkerSize', marker);
end
legend_forces = [];
for leg = 1:sensors
legend_forces = [legend_forces; 'Force ' char(sensors_v(leg))];
end
legend(legend_forces, 'Location', 'EastOutside');
xlabel('Ort vertikal');
ylabel('Gemessene Kraft');
x = num2str(ForceIn(col_nr, 1));
F = num2str(forces_v(force_nr));
title(['Gemessene Kraft in Abhängigkeit von y; x=' x '; F=' F]);
axis ([0, y_max, F_min, F_max]);
if forces_v(force_nr) < 1000
F = ['0' F];
end
filename = ['force_vertikal_x=' x '_' F];

7.2 Anhang - Quelltext MATLAB®-Programme 78
end
end
print ('-dpng', filename);
hold off;
% #########################################################################
% #2: horizontal alle Sensoren
% Plottet für jede Reihe (= jeden gemessenen y-Wert) ein Diagramm mit
% den 6 Sensorwerten in Abhängigkeit von x
clear Plot;
clear string;
clear data;
for row_nr = 1:forces:(forces * rows) % Ein Durchlauf pro Reihe
for force_nr = 1:forces % Ein Durchlauf pro Kraft
hold off;
newplot;
hold on;
for sen = 1:sensors % Ein Durchlauf pro Sensor
row = 1;
for n = 1:(rows*forces):(rows * cols * forces)
Plot (row, 1) = ForceIn (n + force_nr + row_nr - 2, 1);
Plot (row, 2) = ForceIn (n + force_nr + row_nr - 2, 2 + sen);
row = row + 1;
end
line = 1.5;
marker = 15;
color = char(colors(sen));
style = [color, '.-'];

7.2 Anhang - Quelltext MATLAB®-Programme 79
plot(Plot(:,1), Plot(:,2), style, 'MarkerEdgeColor', color, 'MarkerFaceColor', color, 'LineWidth', line,
'MarkerSize', marker);
end
legend_forces = [];
for leg = 1:sensors
legend_forces = [legend_forces; 'Force ' char(sensors_v(leg))];
end
legend(legend_forces, 'Location', 'EastOutside');
xlabel('Ort horizontal');
ylabel('Gemessene Kraft');
y = num2str(ForceIn(row_nr, 2));
F = num2str(forces_v(force_nr));
title(['Gemessene Kraft in Abhängigkeit von x; y=' y '; F=' F]);
axis ([0, x_max, F_min, F_max]);
end
end
if forces_v(force_nr) < 1000
F = ['0' F];
end
filename = ['force_horizontal_y=' y '_' F];
print ('-dpng', filename);
hold off;
% #########################################################################
% #3: horizontal pro Sensor
% Plottet für jeden Sensor und jede Kraft ein Diagramm mit den Sensorwerten

7.2 Anhang - Quelltext MATLAB®-Programme 80
% in Abhängigkeit von x (für alle verschieden y)
% Löscht die Werte des vorhergehenden Plots (wichtig wenn: Länge(alter Plot) > Länge(neuer Plot) -> alte Werte am Ende
der Matrix werden nicht durch neue ersetzt)
clear Plot;
clear string;
clear data;
for force_nr = 1:forces % Ein Durchlauf pro Kraft
for sen = 1:sensors % Ein Durchlauf pro Sensor
hold off; % Setzt die Grafikanzeige zurück
newplot;
hold on; % Alle Plots werden in einer Grafik angezeigt, solange 'hold' aktiviert ist
count = 1; % Schleifenzähler für die String-Matrix der y-Werte
for row_nr = 1:forces:(forces * rows) % Ein Durchlauf pro Reihe
row = 1; % Schleifenzähler für die Plot-Matrix
for n = 1:(rows*forces):(rows * cols * forces)
Plot (row, 1) = ForceIn (n + force_nr + row_nr - 2, 1); % Schreibt x-Werte in die Plot-Matrix
Plot (row, 2) = ForceIn (n + force_nr + row_nr - 2, 2 + sen); % Schreibt Messwerte in die Plot-
Matrix
row = row + 1;
end
l_size = 1; % Setzt die Linienstärke auf "1"
m_size = 15; % Setzt die Markierungsgröße auf "15"
index = (row_nr/(forces * rows)); % Erstellt bei jedem Durchlauf einen Wert index = ]0; 1].
% Die indizes vergrößern sich bei jedem Durchlauf um den selben Wert,
% bis sie beim letzten Durchlauf den Wert 1 erreichen
color = [index, 1-index, 0]; % Die Linienfarbe wird festgelegt, sie ändert sich während den
Durchläfuen (=Reihen) von Grün nach Rot
% Grün = [0, 1, 0], Rot = [1, 0, 0]
marker = '.'; % Setzt die Markierungen auf "Punkt"
line= '-'; % Setzt die Linienart auf "durchgehende Linie"
plot(Plot(:,1), Plot(:,2), 'Marker', marker, 'LineStyle', line, 'Color', color, 'MarkerEdgeColor', color,
'MarkerFaceColor', color, 'LineWidth', l_size, 'MarkerSize', m_size);

7.2 Anhang - Quelltext MATLAB®-Programme 81
end
string = ['y=' num2str(ForceIn(row_nr, 2))]; % Erzeugt einen String string "y=[aktuelles y]"
data(count, 1:length(string)) = string; % Erzeugt eine Matrix mit allen y der Messung
count = count + 1;
legend(cellstr(data), 'Location', 'EastOutside'); % Setzt die Legende
xlabel('Ort horizontal'); % Setzt die x-Achsenbeschriftung
ylabel('Gemessene Kraft (für verschiedene y)'); % Setzt die x-Achsenbeschriftung
F = num2str(forces_v(force_nr)); % Erzeugt einen String mit der aktuellen Kraft
if forces_v(force_nr) < 1000 % Macht "0500" aus "500" (damit die Dateien unter
Windows richtig sortiert werden)
F = ['0' F];
end
s = char(sensors_v(1, sen)); % Erzeugt einen String mit dem aktuellen Sensornamen
title(['Gemessene Kraft in Abhängigkeit von x (bei verschiedenen y) an Sensor ' s '; F=' F]); % Setzt den Titel
des Diagramms
axis ([0, x_max, F_min, F_max]); % Setzt Minimum und Maximum der x- und y-Achse
filename = ['force_horizontal_' s '_' F]; % Erzeugt einen String für den Dateinamen
print ('-dpng', filename); % Exportiert eine .png-Bilddatei
hold off; % Deaktiviert hold
end
end

7.2 Anhang - Quelltext MATLAB®-Programme 82
% #########################################################################
% #4: vertikal pro Sensor
% Plottet für jeden Sensor und jede Kraft ein Diagramm mit den Sensorwerten
% in Abhängigkeit von y (für alle verschieden x)
clear Plot; % Löscht die Werte des vorhergehenden Plots (wichtig wenn: Länge(alter Plot) > Länge(neuer Plot) ->
alte Werte am Ende der Matrix werden nicht durch neue ersetzt)
clear string; % s.o.
clear data;
for force_nr = 1:forces % Ein Durchlauf pro Kraft
for sen = 1:sensors % Ein Durchlauf pro Sensor
hold off; % Setzt die Grafikanzeige zurück
newplot;
hold on; % Alle Plots werden in einer Grafik angezeigt, solange 'hold' aktiviert ist
count = 1; % Schleifenzähler für die String-Matrix der x-Werte
for col_nr = 1:(rows*forces):(rows * cols * forces) % Ein Durchlauf pro Reihe
row = 1; % Schleifenzähler für die Plot-Matrix
for n = 1:forces:(forces * rows)
Plot (row, 1) = ForceIn (n + force_nr + col_nr - 2, 2); % Schreibt y-Werte in die Plot-Matrix
Plot (row, 2) = ForceIn (n + force_nr + col_nr - 2, 2 + sen); % Schreibt Messwerte in die Plot-
Matrix
row = row + 1;
end
l_size = 1; % Setzt die Linienstärke auf "1"
m_size = 15; % Setzt die Markierungsgröße auf "15"
index = (col_nr/(rows * cols * forces)); % Erstellt bei jedem Durchlauf einen Wert index = ]0; 1].
% Die indizes vergrößern sich bei jedem Durchlauf um den selben Wert,
% bis sie beim letzten Durchlauf den Wert 1 erreichen
color = [index, 1-index, 0]; % Die Linienfarbe wird festgelegt, sie ändert sich während den
Durchläfuen (=Reihen) von Grün nach Rot
% Grün = [0, 1, 0], Rot = [1, 0, 0]
marker = '.'; % Setzt die Markierungen auf "Punkt"

7.2 Anhang - Quelltext MATLAB®-Programme 83
line= '-'; % Setzt die Linienart auf "durchgehende Linie"
plot(Plot(:,1), Plot(:,2), 'Marker', marker, 'LineStyle', line, 'Color', color, 'MarkerEdgeColor', color,
'MarkerFaceColor', color, 'LineWidth', l_size, 'MarkerSize', m_size);
end
string = ['x=' num2str(ForceIn(col_nr, 1))]; % Erzeugt einen String string "x=[aktuelles x]"
data(count, 1:length(string)) = string; % Erzeugt eine Matrix mit allen x der Messung
count = count + 1;
legend(cellstr(data), 'Location', 'EastOutside'); % Setzt die Legende
xlabel('Ort vertikal'); % Setzt die x-Achsenbeschriftung
ylabel('Gemessene Kraft (für verschiedene x)'); % Setzt die y-Achsenbeschriftung
F = num2str(forces_v(force_nr)); % Erzeugt einen String mit der aktuellen Kraft
if forces_v(force_nr) < 1000 % Macht "0500" aus "500" (damit die Dateien unter
Windows richtig sortiert werden)
F = ['0' F];
end
s = char(sensors_v(1, sen)); % Erzeugt einen String mit dem aktuellen Sensornamen
title(['Gemessene Kraft in Abhängigkeit von y (bei verschiedenen x) an Sensor ' s '; F=' F]); % Setzt den Titel
des Diagramms
axis ([0, y_max, F_min, F_max]); % Setzt Minimum und Maximum der x- und y-Achse
filename = ['force_vertikal_' s '_' F]; % Erzeugt einen String für den Dateinamen
print ('-dpng', filename); % Exportiert eine .png-Bilddatei
hold off; % Deaktiviert hold
end
end

7.2 Anhang - Quelltext MATLAB®-Programme 84
% #########################################################################
% #5: vertikal pro Sensor Funktion
% Plottet für jeden Sensor und jede Kraft ein Diagramm mit
% Ausgleichsgeraden aus den Sensorwerten in Abhängigkeit von y (für alle verschieden x)
%
% Hier nicht sinnvoll, da eine lineare Näherung nicht möglich ist!
%
% Löscht die Werte des vorhergehenden Plots (wichtig wenn: Länge(alter Plot) > Länge(neuer Plot) -> alte Werte am Ende
der Matrix werden nicht durch neue ersetzt)
clear Plot;
clear string;
clear data;
for force_nr = 1:forces % Ein Durchlauf pro Kraft
for sen = 1:sensors % Ein Durchlauf pro Sensor
hold off; % Setzt die Grafikanzeige zurück
newplot;
hold on; % Alle Plots werden in einer Grafik angezeigt, solange 'hold' aktiviert ist
count = 1; % Schleifenzähler für die String-Matrix der x-Werte
for col_nr = 1:(rows*forces):(rows * cols * forces) % Ein Durchlauf pro Reihe
die Plot-Matrix
Plot-Matrix
row = 1; % Schleifenzähler für die Plot-Matrix
for n = 1:forces:(forces * rows)
Plot (row, col_nr * 2 - 1) = ForceIn (n + force_nr + col_nr - 2, 2); % Schreibt y-Werte in
Plot (row, col_nr * 2) = ForceIn (n + force_nr + col_nr - 2, 2 + sen); % Schreibt Messwerte in die
row = row + 1;
end
l_size = 1; % Setzt die Linienstärke auf "1"
m_size = 15; % Setzt die Markierungsgröße auf "15"
index = (col_nr/(rows * cols * forces)); % Erstellt bei jedem Durchlauf einen Wert index = ]0; 1].

7.2 Anhang - Quelltext MATLAB®-Programme 85
% Die indizes vergrößern sich bei jedem Durchlauf um den selben Wert,
% bis sie beim letzten Durchlauf den Wert 1 erreichen
color = [index, 1-index, 0]; % Die Linienfarbe wird festgelegt, sie ändert sich während den
Durchläfuen (=Reihen) von Grün nach Rot
% Grün = [0, 1, 0], Rot = [1, 0, 0]
for n = 1:(rows)
Plot_x(n, :) = [Plot(n, 1), 1]; % Erstellt eine Matrix mit der "linken Seite" des Gleichungssystems
zum lösen der Geradengleichung m * x + t = F
Plot_y(n, 1) = Plot(n, col_nr * 2); % Erstellt die "rechte Seite" des Gleichungssystems
end
solution = Plot_x\Plot_y;
m = solution(1, 1);
t = solution(2, 1);
if t > 0
t_string = ['+ ' num2str(t)];
end
if t < 0
t_string = num2str(t);
end
x = 0:10:180;
y = m * x + t;
marker = 'none'; % Setzt die Markierungen auf "keine Markierung"
line= '-'; % Setzt die Linienart auf "durchgehende Linie"

7.2 Anhang - Quelltext MATLAB®-Programme 86
plot(x, y, 'Marker', marker, 'LineStyle', line, 'Color', color, 'MarkerEdgeColor', color,
'MarkerFaceColor', color, 'LineWidth', l_size, 'MarkerSize', m_size);
end
% Erzeugt einen String string "x=[aktuelles x]; f(x) = [m] * x [+/-] t"
string = ['x=' num2str(ForceIn(col_nr, 1)) '; f(x)=' m '* x ' t_string];
data(count, 1:length(string)) = string; % Erzeugt eine Matrix mit allen x der Messung
count = count + 1;
for col_nr = 1:(rows*forces):(rows * cols * forces)
marker = '.'; % Setzt die Markierungen auf "Punkt"
line= 'none'; % Setzt die Linienart auf "keine Linie"
index = (col_nr/(rows * cols * forces));
color = [index, 1-index, 0];
plot(Plot(:, col_nr * 2 - 1), Plot(:, col_nr * 2), 'Marker', marker, 'LineStyle', line, 'Color', color,
'MarkerEdgeColor', color, 'MarkerFaceColor', color, 'LineWidth', l_size, 'MarkerSize', m_size);
end
legend(cellstr(data), 'Location', 'EastOutside'); % Setzt die Legende
xlabel('Ort vertikal'); % Setzt die x-Achsenbeschriftung
ylabel('Gemessene Kraft (für verschiedene y)'); % Setzt die y-Achsenbeschriftung
F = num2str(forces_v(force_nr)); % Erzeugt einen String mit der aktuellen Kraft
if forces_v(force_nr) < 1000 % Macht "0500" aus "500" (damit die Dateien unter Windows richtig sortiert
werden)
F = ['0' F];
end
s = char(sensors_v(1, sen)); % Erzeugt einen String mit dem aktuellen Sensornamen
% Setzt den Titel des Diagramms
title(['Gemessene Kraft in Abhängigkeit von y (bei verschiedenen x) an Sensor ' s '; F=' F]);
axis ([0, y_max, F_min, F_max]); % Setzt Minimum und Maximum der x- und y-Achse

7.2 Anhang - Quelltext MATLAB®-Programme 87
end
end
filename = ['force_vertikal_' s '_' F '_fx']; % Erzeugt einen String für den Dateinamen
print ('-dpng', filename); % Exportiert eine .png-Bilddatei
hold off; % Deaktiviert hold
% #########################################################################
% #6: horizontal pro Sensor Funktion
% Plottet für jeden Sensor und jede Kraft ein Diagramm mit
% Ausgleichsgeraden aus den Sensorwerten in Abhängigkeit von x (für alle verschieden y)
Plot = []; % Löscht die Werte des vorhergehenden Plots
% (wichtig wenn: Länge(alter Plot) > Länge(neuer Plot)
% -> alte Werte am Ende der Matrix werden nicht durch neue ersetzt)
clear Plot;
clear string;
clear data;
clear solution;
clear m;
clear t;
clear Plot_x;
clear Plot_y;
for force_nr = 1:forces % Ein Durchlauf pro Kraft
for sen = 1:sensors % Ein Durchlauf pro Sensor
hold off; % Setzt die Grafikanzeige zurück
newplot;
hold on; % Alle Plots werden in einer Grafik angezeigt, solange 'hold' aktiviert ist
count = 1; % Schleifenzähler für die String-Matrix der y-Werte

7.2 Anhang - Quelltext MATLAB®-Programme 88
die Plot-Matrix
Plot-Matrix
for row_nr = 1:forces:(forces * rows) % Ein Durchlauf pro Reihe
row = 1; % Schleifenzähler für die Plot-Matrix
for n = 1:(rows*forces):(rows * cols * forces)
Plot (row, row_nr * 2 - 1) = ForceIn (n + force_nr + row_nr - 2, 1); % Schreibt x-Werte in
Plot (row, row_nr * 2) = ForceIn (n + force_nr + row_nr - 2, 2 + sen); % Schreibt Messwerte in die
row = row + 1;
end
l_size = 1; % Setzt die Linienstärke auf "1"
m_size = 15; % Setzt die Markierungsgröße auf "15"
index = (row_nr/(forces * rows)); % Erstellt bei jedem Durchlauf einen Wert index = ]0; 1].
% Die indizes vergrößern sich bei jedem Durchlauf um den selben Wert,
% bis sie beim letzten Durchlauf den Wert 1 erreichen
color = [index, 1-index, 0]; % Die Linienfarbe wird festgelegt, sie ändert sich während den
Durchläfuen (=Reihen) von Grün nach Rot
% Grün = [0, 1, 0], Rot = [1, 0, 0]
for n = 1:cols
Plot_x(n, :) = [Plot(n, 1), 1]; % Erstellt eine Matrix mit der "linken Seite" des Gleichungssystems
zum lösen der Geradengleichung m * x + t = F
Plot_y(n, 1) = Plot(n, row_nr * 2); % Erstellt die "rechte Seite" des Gleichungssystems
end
solution = Plot_x\Plot_y; % Löst das Gleichungssystem
m = solution(1, 1);
t = solution(2, 1);
if t > 0
t_string = ['+ ' num2str(t)];
end
if t < 0
t_string = num2str(t);

7.2 Anhang - Quelltext MATLAB®-Programme 89
end
x = 0:10:y_max;
y = m * x + t;
marker = 'none'; % Setzt die Markierungen auf "keine Markierung"
line= '-'; % Setzt die Linienart auf "durchgehende Linie"
plot(x, y, 'Marker', marker, 'LineStyle', line, 'Color', color, 'MarkerEdgeColor', color,
'MarkerFaceColor', color, 'LineWidth', l_size, 'MarkerSize', m_size);
eine Spalte
% Erzeugt einen String string "y=[aktuelles y]; f(x) = [m] * x [+/-] t"
string_file = ['y=' num2str(ForceIn(row_nr, 2)) '; f(x)=' num2str(m) ' * x ' t_string];
% Schreibt alle Strings der Durchläufe in eine Matrix
data_file(count, 1:length(string_file)) = string_file;
string = ['y=' num2str(ForceIn(row_nr, 2))];% Erzeugt einen String string "y=[aktuelles y]" = Legende für
data(count, 1:length(string)) = string; % Erzeugt eine Matrix mit allen Legenden
count = count + 1;
end
for row_nr = 1:forces:(forces * rows)
marker = '.'; % Setzt die Markierungen auf "Punkt"
line= 'none'; % Setzt die Linienart auf "durchgehende Linie"
index = (row_nr/(forces * rows));
color = [index, 1-index, 0];
plot(Plot(:, row_nr * 2 - 1), Plot(:, row_nr * 2), 'Marker', marker, 'LineStyle', line, 'Color', color,
'MarkerEdgeColor', color, 'MarkerFaceColor', color, 'LineWidth', l_size, 'MarkerSize', m_size);
end
legend(cellstr(data), 'Location', 'EastOutside'); % Setzt die Legende
xlabel('Ort horizontal'); % Setzt die x-Achsenbeschriftung

7.2 Anhang - Quelltext MATLAB®-Programme 90
ylabel('Gemessene Kraft (für verschiedene y)'); % Setzt die x-Achsenbeschriftung
F = num2str(forces_v(force_nr)); % Erzeugt einen String mit der aktuellen Kraft
if forces_v(force_nr) < 1000 % Macht "0500" aus "500" (damit die Dateien unter Windows
richtig sortiert werden)
F = ['0' F];
end
s = char(sensors_v(1, sen)); % Erzeugt einen String mit dem aktuellen Sensornamen
title(['Gemessene Kraft in Abhängigkeit von x (bei verschiedenen y) an Sensor ' s '; F=' F]); % Setzt den Titel
des Diagramms
axis ([0, x_max, F_min, F_max]); % Setzt Minimum und Maximum der x- und y-Achse
filename = ['force_horizontal_' s '_' F '_fx']; % Erzeugt einen String für den Dateinamen
print ('-dpng', filename); % Exportiert eine .png-Bilddatei
filename = [filename '.txt']; % Fügt ".txt" an den Dateinamen hinzu
dlmwrite (filename, data_file, 'delimiter', ''); % Exportiert eine Matrix mit den Geradenparameter in einer
.txt-Textdatei
hold off; % Deaktiviert hold
end
end
% #########################################################################
% Graphische Darstellung der oben erstellten (dreidimensionalen) Wertetabellen, Export als .jpeg-Bilddatei
for sen = 1:(sensors + 1)

7.2 Anhang - Quelltext MATLAB®-Programme 91
for f = 1:forces
hold off;
newplot;
F_str = num2str(forces_v(f)); % Die aktuelle Kraft als String
if forces_v(f) < 1000
F_str = ['0' F_str]; % Fügt bei dreistelligen Zahlen eine 0 vor den String
end % (notwendig für richtige Sortierung der Dateien unter Windows)
if sen == (sensors + 1) % Wenn der Sensorzähler um 1 größer ist als die Anzahl der Sensoren
Sen_str = 'ges'; % enthält 'matrix' die Summe der Sensorwerte -> 'ges' als Sensorname
else
Sen_str = char(sensors_v(sen)); % Der aktuelle Sensorname als String
end
n1 = 1 + (sen - 1) * (rows + 2); % Vertikaler Startpunkt der Einzelmatrix
n2 = (sen) * (rows + 2) - 1; % Vertikaler Endpunkt der Einzelmatrix
m1 = 1 + (f - 1) * (cols + 2); % Horizontaler Startpunkt der Einzelmatrix
m2 = (f) * (cols + 2) - 1; % Horizontaler Endpunkt der Einzelmatrix
matrix = Werte(n1:n2, m1:m2); % Bilden der Matrix aus den Start- und Endpunkten
max_x = max(ForceIn(:, 1)); % größter enthaltener x-Wert
min_x = min(ForceIn(:, 1)); % kleinster enthaltener x-Wert
max_y = max(ForceIn(:, 2)); % größter enthaltener y-Wert
min_y = min(ForceIn(:, 2)); % kleinster enthaltener y-Wert
% Generiert Matrizen für 'X' und 'Y' für den dreidimensionalen Plot
[X, Y] = meshgrid(matrix(1, 2:(cols+1)), matrix(2:(rows+1), 1));
Z = matrix(2:(rows+1), 2:(cols+1)); % Generiert eine Matrix mit den Z-Werten des Plots
surf(X,Y,Z); % Erstellt eine Oberfläche aus 'X', 'Y', 'Z'
xlabel('Ort horizontal'); % Setzt die x-Achsenbeschriftung

7.2 Anhang - Quelltext MATLAB®-Programme 92
end
end
ylabel('Ort vertikal'); % Setzt die y-Achsenbeschriftung
zlabel(['Kraft an Sensor ' Sen_str]); % Setzt die z-Achsenbeschriftung
title(['Kraft in Abhängigkeit vom Ort an Sensor ' Sen_str]); % Setzt den Diagrammtitel
caxis ([F_min, F_max]); % Setzt die Achsenbeschränkungen der Farbtafel
colormap(jet) % Legt das Farbschema fest
colorbar; % Erzeugt eine Farbtafel
axis ([min_x, max_x, min_y, max_y, F_min, F_max]); % Setzt x, y, z-Achsenbeschränkungen
filename = ['sensor_' Sen_str '_' F_str]; % Erstellt den Dateinamen
% Exportiert die Matrix des jweiligen Sensors und der jeweiligen Kraft als jpeg-Bilddatei
print ('-djpeg100', filename);

7.2 Anhang - Quelltext MATLAB®-Programme 93
7.2.3. pfaller_auswertung_statisch.m
Programm zur Auswertung der DIAdem-Messdateien von statischen Messungen. Benötigt das Programm ShowData der Universität. (Hinzufügen mit:
File > Set Path...)
% Benötigt das Programm ShowData der Universität. (Hinzufügen mit: File >
% Set Path...)
clear;
% function GetDataFromChannel
global Header;
Mess = [];
amplitudesMess = [];
% #########################################################################
[ffiles, fpath] = ListFilesForSelect;
ffile = [];
fileNr = length(ffiles);
if ~isempty(ffiles)
detectUiPp.prompText = 'Now select your desired file.dat!';
detectUiPp.boxHeaders = {' '};
for i = 1:fileNr
detectUiPp.boxNames(i, 1) = {[ffiles(i).name ' ' ffiles(i).comment]};
detectUiPp.boxValues(i, 1) = 0;
end
qq = AutoDetectUIInput(detectUiPp); % local function

7.2 Anhang - Quelltext MATLAB®-Programme 94
end
if ~ischar(qq)
for i = 1:fileNr
if qq.boxValues(i, 1)=='1';
ffile = ffiles(i).name;
break;
end
end
end
clear detectUiPp qq ffiles;
if ~isempty(ffile),
Header.FullFilename = '';
fullfilename = fullfile(fpath, ffile);
if strcmpi(ffile((end - 2):end), 'DAT'), % DIADEM file.
hfilename = [fullfilename(1:(end - 4)), '_diaheader.mat'];
if exist(hfilename),
load(hfilename); % open MAT file with HEADER data.
if ~strcmp(Header.FullFilename, fullfilename),
Header.FullFilename = fullfilename;
[fpath, dummy] = fileparts(fullfilename);
Header.FilePath = fpath;
save(hfilename, 'Header')
end
else,
Header = TransformDiademToMat(fullfilename);
end
else
dummy = ['File type ', fullfilename((end - 2):end), ...
'is not supported.'];
Notify(dummy, [], 'r')
error([' ### ShowData: ', dummy])
end

7.2 Anhang - Quelltext MATLAB®-Programme 95
for i = 1:Header.NChannels,
switch Header.Channel(i).Name
case 'Mess_1'
[amplitude, xnew] = GetDiaData(i, 0, Header.Channel(i).Length);
Mess = (find(diff(amplitude)>0.5) + 1);
Mess = [Mess(1); Mess(find(diff(Mess)>1500)+1)];
case 'RVor_1'
[amplitude, xnew] = GetDiaData(i, 0, Header.Channel(i).Length);
RVor = (find(diff(amplitude)>0.5) + 1);
RVor = [RVor(1); RVor(find(diff(RVor)>1500)+1)];
case 'RNach_1'
[amplitude, xnew] = GetDiaData(i, 0, Header.Channel(i).Length);
RNach = (find(diff(amplitude)>0.5) + 1);
RNach = [RNach(1); RNach(find(diff(RNach)>1500)+1)];
end
end
%Mittelwerte
for j = 1:size(Mess, 1),
for i = 1:Header.NChannels,
switch Header.Channel(i).Name
case 'X'
[Ynew, Xnew] = GetDiaData(i, Mess(j, 1), 1000);
amplitudesMess(j, 1) = 0;
amplitudesMess(j, 2) = mean(Ynew);
case 'Y'
[Ynew, Xnew] = GetDiaData(i, Mess(j, 1), 1000);
amplitudesMess(j, 3) = mean(Ynew);
case 'ForceIn_ll'
[Ynew, Xnew] = GetDiaData(i, Mess(j, 1), 1000);
amplitudesMess(j, 4) = mean(Ynew);
case 'ForceIn_lr'
[Ynew, Xnew] = GetDiaData(i, Mess(j, 1), 1000);
amplitudesMess(j, 5) = mean(Ynew);

7.2 Anhang - Quelltext MATLAB®-Programme 96
end
end
end
case 'ForceIn_ul'
[Ynew, Xnew] = GetDiaData(i, Mess(j, 1), 1000);
amplitudesMess(j, 6) = mean(Ynew);
case 'ForceIn_ur'
[Ynew, Xnew] = GetDiaData(i, Mess(j, 1), 1000);
amplitudesMess(j, 7) = mean(Ynew);
case 'ForceIn_ml_i(5)'
[Ynew, Xnew] = GetDiaData(i, Mess(j, 1), 1000);
amplitudesMess(j, 8) = mean(Ynew);
case 'ForceIn_mr_i(6)'
[Ynew, Xnew] = GetDiaData(i, Mess(j, 1), 1000);
amplitudesMess(j, 9) = mean(Ynew);
for j = 1:size(RVor, 1)
for i = 1:Header.NChannels,
switch Header.Channel(i).Name
case 'X'
[Ynew, Xnew] = GetDiaData(i, RVor(j, 1), 1000);
amplitudesRVor(j, 1) = -1;
amplitudesRVor(j, 2) = mean(Ynew);
case 'Y'
[Ynew, Xnew] = GetDiaData(i, RVor(j, 1), 1000);
amplitudesRVor(j, 3) = mean(Ynew);
case 'ForceIn_ll'
[Ynew, Xnew] = GetDiaData(i, RVor(j, 1), 1000);
amplitudesRVor(j, 4) = mean(Ynew);
case 'ForceIn_lr'
[Ynew, Xnew] = GetDiaData(i, RVor(j, 1), 1000);
amplitudesRVor(j, 5) = mean(Ynew);

7.2 Anhang - Quelltext MATLAB®-Programme 97
end
end
end
j = j+1;
case 'ForceIn_ul'
[Ynew, Xnew] = GetDiaData(i, RVor(j, 1), 1000);
amplitudesRVor(j, 6) = mean(Ynew);
case 'ForceIn_ur'
[Ynew, Xnew] = GetDiaData(i, RVor(j, 1), 1000);
amplitudesRVor(j, 7) = mean(Ynew);
case 'ForceIn_ml_i(5)'
[Ynew, Xnew] = GetDiaData(i, RVor(j, 1), 1000);
amplitudesRVor(j, 8) = mean(Ynew);
case 'ForceIn_mr_i(6)'
[Ynew, Xnew] = GetDiaData(i, RVor(j, 1), 1000);
amplitudesRVor(j, 9) = mean(Ynew);
for j = 1:size(RNach, 1),
for i = 1:Header.NChannels,
switch Header.Channel(i).Name
case 'X'
[Ynew, Xnew] = GetDiaData(i, RNach(j, 1), 1000);
amplitudesRNach(j, 1) = 1;
amplitudesRNach(j, 2) = mean(Ynew);
case 'Y'
[Ynew, Xnew] = GetDiaData(i, RNach(j, 1), 1000);
amplitudesRNach(j, 3) = mean(Ynew);
case 'ForceIn_ll'
[Ynew, Xnew] = GetDiaData(i, RNach(j, 1), 1000);
amplitudesRNach(j, 4) = mean(Ynew);
case 'ForceIn_lr'
[Ynew, Xnew] = GetDiaData(i, RNach(j, 1), 1000);
amplitudesRNach(j, 5) = mean(Ynew);

7.2 Anhang - Quelltext MATLAB®-Programme 98
end
end
end
j = j+1;
case 'ForceIn_ul'
[Ynew, Xnew] = GetDiaData(i, RNach(j, 1), 1000);
amplitudesRNach(j, 6) = mean(Ynew);
case 'ForceIn_ur'
[Ynew, Xnew] = GetDiaData(i, RNach(j, 1), 1000);
amplitudesRNach(j, 7) = mean(Ynew);
case 'ForceIn_ml_i(5)'
[Ynew, Xnew] = GetDiaData(i, RNach(j, 1), 1000);
amplitudesRNach(j, 8) = mean(Ynew);
case 'ForceIn_mr_i(6)'
[Ynew, Xnew] = GetDiaData(i, RNach(j, 1), 1000);
amplitudesRNach(j, 9) = mean(Ynew);
end
% #########################################################################
xlswrite('statisch_y72_Mess', amplitudesMess)
xlswrite('statisch_y72_RVor', amplitudesRVor)
xlswrite('statisch_y72_RNach', amplitudesRNach)
% xlswrite(amplitudesMess, 'Statische Messung, y72', {'Typ', 'X', 'Y', 'ForceIn_ll', 'ForceIn_lr', 'ForceIn_ul',
'ForceIn_ur', 'ForceIn_ml', 'ForceIn_mr'}, 'statisch_y72_Mess', 'Tabelle1')

7.2 Anhang - Quelltext MATLAB®-Programme 99
7.2.4. pfaller_flaechengleichung_2_funktionen.m
Programm zum Erstellen von Flächengleichungen die aus zwei verschiedenen Gleichungen bestehen. Greift auf die Funktionen pfaller_gleichung_lin.m
und pfaller_gleichung_pol.m zurück.
clear;
mess_lower = xlsread('D:\PfalLer\Auswertung\excel\F_lr_4000.xls');
cols = size(mess_lower, 2) - 1;
rows = size(mess_lower, 1) - 1;
% Linearer Anteil: 2 - grenze1
grenze1 = 100;
% Polynomischer Anteil: grenze1 - grenze2
grenze2 = 190;
% Erzeugen einer Wertetabelle (mit den oberen Grenzen) zur linearen
% optimierung
n = 1;
for i = 2:(rows+1)
if mess_lower(i, 1)

7.2 Anhang - Quelltext MATLAB®-Programme 100
data_lin = [xdata_lin; ydata_lin];
a0 = zeros(1, 4); % Geratene Startwerte
% Optimierung der Funktion pfaller_gleichung_lin mit den Daten aus data_lin
a = lsqcurvefit(@pfaller_gleichung_lin, a0, data_lin, zdata_lin)
% Erzeugen einer Wertetabelle (mit den oberen Grenzen) zur polynomischen
% optimierung
n = 1;
for i = 2:(rows+1)
if mess_lower(i, 1) >= grenze1 && mess_lower(i, 1)

7.2 Anhang - Quelltext MATLAB®-Programme 101
end
end
% polynomischer Teil
for i = 2:(rows+1)
if mess_lower(i, 1) >= grenze1 && mess_lower(i, 1) < grenze2
for j = 2:(cols+1)
x = mess_lower(1, j);
y = mess_lower(i, 1);
end
end
end
Z(i-1, j-1) = pfaller_gleichung_pol(b, [x; y]);
[rows2, cols2] = size(Z);
% Plotten der Funktionen
[X, Y] = meshgrid(mess_lower(1, 2:(cols2+1)), mess_lower(2:(rows2+1), 1));
Z_mess = mess_lower(2:(rows2+1), 2:(cols2+1));
Z_delta = Z - Z_mess;
hold on;
surf(X,Y,Z);
% surf(X,Y,Z_mess);
% surf(X,Y,Z_delta);
hold off;
xlabel('Ort horizontal');
ylabel('Ort vertikal');
zlabel('Kraft an Sensor lr');
title('Kraft in Abhängigkeit vom Ort an Sensor lr');
axis ([7 79 2 184 -1 10]);
caxis ([-1 10]);
colormap(Jet)
colorbar;
print -djpeg100 sensor_lr_4000_fx.jpeg;

7.2 Anhang - Quelltext MATLAB®-Programme 102
7.2.5. pfaller_gleichung_lin.m
Funktion für die lineare Flächenoptimierung.
function F = gleichung_lin(a, data)
x = data(1, :);
y = data(2, :);
% F (x) = (ay + b)x + cy + d
F = (a(1) .* y + a(2)) .* x + a(3) .* y + a(4);
7.2.6. pfaller_gleichung_pol.m
Funktion für die polynomische Flächenoptimierung.
function F = gleichung_pol(b, data)
x = data(1, :);
y = data(2, :);
% quadratisch
% F (x) = (ey² + fy + g) * x + hy² + iy + j
F = (b(1) .* y.^2 + b(2) .* y + b(3)) .* x + b(4) .* y.^2 + b(5) .* y + b(6);
% kubisch -> geratene Startwerte a0 müssen 8 statt 6 Werte enthalten
% F = (b(1).*y.^3 + b(2).*y.^2 + b(3).*y + b(4)) .*x + b(5).*y.^3 + b(6).*y.^2 + b(7).*y + b(8);

7.2 Anhang - Quelltext MATLAB®-Programme 103
7.2.7. pfaller_linearkombination_felder.m
Programm zur Berechnung des Ortes durch vier verschiedene Linearkombinationen. In Zeile 4 bis 9 müssen die Speicherpfade der Excel-Tabellen mit
den dreidimensionalen Wertetabellen der drei Sensoren eingegeben werden.
clear;
% Messwerte einlesen
ForceIn_ul = xlsread('D:\Pfaller\Auswertung\excel\matrix-ForceIn_ul.xls');
ForceIn_ur = xlsread('D:\Pfaller\Auswertung\excel\matrix-ForceIn_ur.xls');
ForceIn_ml = xlsread('D:\Pfaller\Auswertung\excel\matrix-ForceIn_ml.xls');
ForceIn_mr = xlsread('D:\Pfaller\Auswertung\excel\matrix-ForceIn_mr.xls');
ForceIn_ll = xlsread('D:\Pfaller\Auswertung\excel\matrix-ForceIn_ll.xls');
ForceIn_lr = xlsread('D:\Pfaller\Auswertung\excel\matrix-ForceIn_lr.xls');
% Finden der Koeffizienten zur Ortsberechnung
row = 1;
row_1 = 1;
row_2 = 1;
row_3 = 1;
row_4 = 1;
for j = 2:(size(ForceIn_ul, 1))
for i = 2:(size(ForceIn_ul, 2))
% Unterteilung der oberen Plattenhälfte in vier Bereiche:
% 1 (oben links), 2 (oben rechts), 3 (unten links), 4 (unten rechts)
% 1: x > 40, y > 46
% 2: x < 40, y > 46
% 3: x > 40, y < 46
% 4: x < 40, y < 46

7.2 Anhang - Quelltext MATLAB®-Programme 104
F_ul = ForceIn_ul(j,i);
F_ur = ForceIn_ur(j,i);
F_ml = ForceIn_ml(j,i);
F_mr = ForceIn_mr(j,i);
F_ll = ForceIn_ll(j,i);
F_lr = ForceIn_lr(j,i);
x_temp = ForceIn_ul(j,1);
y_temp = ForceIn_ul(1,i);
if y_temp > 139 % oben
if x_temp > 42 % links oben: 1
koeffizienten_1(row_1, 1) = F_ul;
koeffizienten_1(row_1, 2) = F_ur;
koeffizienten_1(row_1, 3) = F_ml;
koeffizienten_1(row_1, 4) = F_mr;
koeffizienten_1(row_1, 5) = F_ll;
koeffizienten_1(row_1, 6) = F_lr;
rechts_x_1(row_1, 1) = ForceIn_ul(j,1);
rechts_y_1(row_1, 1) = ForceIn_ul(1,i);
row_1 = row_1 + 1;
end
if x_temp < 42 % rechts oben: 2
koeffizienten_2(row_2, 1) = F_ul;
koeffizienten_2(row_2, 2) = F_ur;
koeffizienten_2(row_2, 3) = F_ml;
koeffizienten_2(row_2, 4) = F_mr;
koeffizienten_2(row_2, 5) = F_ll;
koeffizienten_2(row_2, 6) = F_lr;

7.2 Anhang - Quelltext MATLAB®-Programme 105
rechts_x_2(row_2, 1) = ForceIn_ul(j,1);
rechts_y_2(row_2, 1) = ForceIn_ul(1,i);
row_2 = row_2 + 1;
end
end
if y_temp 42 % links unten: 3
koeffizienten_3(row_3, 1) = F_ul;
koeffizienten_3(row_3, 2) = F_ur;
koeffizienten_3(row_3, 3) = F_ml;
koeffizienten_3(row_3, 4) = F_mr;
koeffizienten_3(row_3, 5) = F_ll;
koeffizienten_3(row_3, 6) = F_lr;
end
end
rechts_x_3(row_3, 1) = ForceIn_ul(j,1);
rechts_y_3(row_3, 1) = ForceIn_ul(1,i);
row_3 = row_3 + 1;
end
if x_temp < 42 % rechts unten: 4
koeffizienten_4(row_4, 1) = F_ul;
koeffizienten_4(row_4, 2) = F_ur;
koeffizienten_4(row_4, 3) = F_ml;
koeffizienten_4(row_4, 4) = F_mr;
koeffizienten_4(row_4, 5) = F_ll;
koeffizienten_4(row_4, 6) = F_lr;
rechts_x_4(row_4, 1) = ForceIn_ul(j,1);
rechts_y_4(row_4, 1) = ForceIn_ul(1,i);
row_4 = row_4 + 1;

7.2 Anhang - Quelltext MATLAB®-Programme 106
end
end
% Erstellen der Matrizen zum Finden der Koeffizienten die für die gesamte obere Plattenhälfte gelten.
% Mit ihnen wird später der vorläufige Ort berechnet
koeffizienten(row, 1) = F_ul;
koeffizienten(row, 2) = F_ur;
koeffizienten(row, 3) = F_ml;
koeffizienten(row, 4) = F_mr;
koeffizienten(row, 5) = F_ll;
koeffizienten(row, 6) = F_lr;
rechts_x(row, 1) = ForceIn_ul(j,1);
rechts_y(row, 1) = ForceIn_ul(1,i);
row = row + 1;
% Lösen der Gleichungen für die einzelnen Felder
faktoren_x = koeffizienten\rechts_x;
faktoren_y = koeffizienten\rechts_y;
faktoren_x_1 = koeffizienten_1\rechts_x_1;
faktoren_y_1 = koeffizienten_1\rechts_y_1;
faktoren_x_2 = koeffizienten_2\rechts_x_2;
faktoren_y_2 = koeffizienten_2\rechts_y_2;
faktoren_x_3 = koeffizienten_3\rechts_x_3;
faktoren_y_3 = koeffizienten_3\rechts_y_3;
faktoren_x_4 = koeffizienten_4\rechts_x_4;
faktoren_y_4 = koeffizienten_4\rechts_y_4;
faktoren_gesamt(:, 1) = faktoren_x

7.2 Anhang - Quelltext MATLAB®-Programme 107
faktoren_gesamt(:, 2) = faktoren_x_1
faktoren_gesamt(:, 3) = faktoren_x_2
faktoren_gesamt(:, 4) = faktoren_x_3
faktoren_gesamt(:, 5) = faktoren_x_4
faktoren_gesamt(:, 7) = faktoren_y
faktoren_gesamt(:, 8) = faktoren_y_1
faktoren_gesamt(:, 9) = faktoren_y_2
faktoren_gesamt(:, 10) = faktoren_y_3
faktoren_gesamt(:, 11) = faktoren_y_4
% Ortsberechnung mit den oben gefundenen Koeffizienten
n_ul = faktoren_x(1, 1);
n_ur = faktoren_x(2, 1);
n_ml = faktoren_x(3, 1);
n_mr = faktoren_x(4, 1);
n_ll = faktoren_x(5, 1);
n_lr = faktoren_x(6, 1);
m_ul = faktoren_y(1, 1);
m_ur = faktoren_y(2, 1);
m_ml = faktoren_y(3, 1);
m_mr = faktoren_y(4, 1);
m_ll = faktoren_y(5, 1);
m_lr = faktoren_y(6, 1);
n_ul_1 = faktoren_x_1(1, 1);
n_ur_1 = faktoren_x_1(2, 1);
n_ml_1 = faktoren_x_1(3, 1);
n_mr_1 = faktoren_x_1(4, 1);
n_ll_1 = faktoren_x_1(5, 1);
n_lr_1 = faktoren_x_1(6, 1);
m_ul_1 = faktoren_y_1(1, 1);
m_ur_1 = faktoren_y_1(2, 1);
m_ml_1 = faktoren_y_1(3, 1);
m_mr_1 = faktoren_y_1(4, 1);

7.2 Anhang - Quelltext MATLAB®-Programme 108
m_ll_1 = faktoren_y_1(5, 1);
m_lr_1 = faktoren_y_1(6, 1);
n_ul_2 = faktoren_x_2(1, 1);
n_ur_2 = faktoren_x_2(2, 1);
n_ml_2 = faktoren_x_2(3, 1);
n_mr_2 = faktoren_x_2(4, 1);
n_ll_2 = faktoren_x_2(5, 1);
n_lr_2 = faktoren_x_2(6, 1);
m_ul_2 = faktoren_y_2(1, 1);
m_ur_2 = faktoren_y_2(2, 1);
m_ml_2 = faktoren_y_2(3, 1);
m_mr_2 = faktoren_y_2(4, 1);
m_ll_2 = faktoren_y_2(5, 1);
m_lr_2 = faktoren_y_2(6, 1);
n_ul_3 = faktoren_x_3(1, 1);
n_ur_3 = faktoren_x_3(2, 1);
n_ml_3 = faktoren_x_3(3, 1);
n_mr_3 = faktoren_x_3(4, 1);
n_ll_3 = faktoren_x_3(5, 1);
n_lr_3 = faktoren_x_3(6, 1);
m_ul_3 = faktoren_y_3(1, 1);
m_ur_3 = faktoren_y_3(2, 1);
m_ml_3 = faktoren_y_3(3, 1);
m_mr_3 = faktoren_y_3(4, 1);
m_ll_3 = faktoren_y_3(5, 1);
m_lr_3 = faktoren_y_3(6, 1);
n_ul_4 = faktoren_x_4(1, 1);
n_ur_4 = faktoren_x_4(2, 1);
n_ml_4 = faktoren_x_4(3, 1);
n_mr_4 = faktoren_x_4(4, 1);
n_ll_4 = faktoren_x_4(5, 1);
n_lr_4 = faktoren_x_4(6, 1);
m_ul_4 = faktoren_y_4(1, 1);
m_ur_4 = faktoren_y_4(2, 1);
m_ml_4 = faktoren_y_4(3, 1);

7.2 Anhang - Quelltext MATLAB®-Programme 109
m_mr_4 = faktoren_y_4(4, 1);
m_ll_4 = faktoren_y_4(5, 1);
m_lr_4 = faktoren_y_4(6, 1);
row = 1;
for j = 2:(size(ForceIn_ul, 1))
for i = 2:(size(ForceIn_ul, 2))
% Unterteilung der oberen Plattenhälfte in vier Bereiche:
% 1 (oben links), 2 (oben rechts), 3 (unten links), 4 (unten rechts)
% 1: x > 40, y > 46
% 2: x < 40, y > 46
% 3: x > 40, y < 46
% 4: x < 40, y < 46
F_ul = ForceIn_ul(j,i);
F_ur = ForceIn_ur(j,i);
F_ml = ForceIn_ml(j,i);
F_mr = ForceIn_mr(j,i);
F_ll = ForceIn_ll(j,i);
F_lr = ForceIn_lr(j,i);
x_temp = n_ul*F_ul + n_ur * F_ur + n_ml * F_ml +n_mr * F_mr + n_ll * F_ll + n_lr * F_lr;
y_temp = m_ul*F_ul + m_ur * F_ur + m_ml * F_ml +m_mr * F_mr + m_ll * F_ll + m_lr * F_lr;
if y_temp > 139 % oben
if x_temp > 42 % links oben: 1
x_calc = n_ul_1 * F_ul + n_ur_1 * F_ur + n_ml_1 * F_ml +n_mr_1 * F_mr + n_ll_1 * F_ll + n_lr_1 * F_lr;
y_calc = m_ul_1 * F_ul + m_ur_1 * F_ur + m_ml_1 * F_ml +m_mr_1 * F_mr + m_ll_1 * F_ll + m_lr_1 * F_lr;
end
if x_temp < 42 % rechts oben: 2
x_calc = n_ul_2 * F_ul + n_ur_2 * F_ur + n_ml_2 * F_ml +n_mr_2 * F_mr + n_ll_2 * F_ll + n_lr_2 * F_lr;

7.2 Anhang - Quelltext MATLAB®-Programme 110
y_calc = m_ul_2 * F_ul + m_ur_2 * F_ur + m_ml_2 * F_ml +m_mr_2 * F_mr + m_ll_2 * F_ll + m_lr_2 * F_lr;
end
end
if y_temp 42 % links unten: 3
x_calc = n_ul_3 * F_ul + n_ur_3 * F_ur + n_ml_3 * F_ml +n_mr_3 * F_mr + n_ll_3 * F_ll + n_lr_3 * F_lr;
y_calc = m_ul_3 * F_ul + m_ur_3 * F_ur + m_ml_3 * F_ml +m_mr_3 * F_mr + m_ll_3 * F_ll + m_lr_3 * F_lr;
end
if x_temp < 42 % rechts unten: 4
x_calc = n_ul_4 * F_ul + n_ur_4 * F_ur + n_ml_4 * F_ml +n_mr_4 * F_mr + n_ll_4 * F_ll + n_lr_4 * F_lr;
y_calc = m_ul_4 * F_ul + m_ur_4 * F_ur + m_ml_4 * F_ml +m_mr_4 * F_mr + m_ll_4 * F_ll + m_lr_4 * F_lr;
end
end
koordinaten(row, 1) = ForceIn_ul(j,1); % x gemessen
koordinaten(row, 5) = ForceIn_ul(1,i); % y gemessen
koordinaten(row, 2) = x_calc; % x in dem jeweiligen Bereich berechnet
koordinaten(row, 6) = y_calc; % y in dem jeweiligen Bereich berechnet
koordinaten(row, 3) = abs((koordinaten(row, 1) - koordinaten(row, 2)) * 100 / koordinaten(row, 1)); % Die
prozentuale Differenz zwischen gemessenem und berechnetem x im Betrag
koordinaten(row, 7) = abs((koordinaten(row, 5) - koordinaten(row, 6)) * 100 / koordinaten(row, 5)); % Die
prozentuale Differenz zwischen gemessenem und berechnetem y im Betrag
end
end
row = row+1;
mittelwerte = mean(koordinaten); % Berechnung der Mittelwerte für jede Spalte
koordinaten(row, 3) = mittelwerte(1, 3);
koordinaten(row, 7) = mittelwerte(1, 7);

7.2 Anhang - Quelltext MATLAB®-Programme 111
cols = size(ForceIn_ul, 1) - 1; % Anzahl der verschiedenen horizontalen Messpunkte (bzw. Anzahl der gemessenen Spalten)
rows = size(ForceIn_ul, 2) - 1; % Anzahl der verschiedenen vertikalen Messpunkte (bzw. Anzahl der gemessenen Reihen)
% Umwandlung der Matrizen von Listenform in eine dreidimensionaleWertetabelle
for j = 2:(rows+1) % matrix vertikal
for i = 2:(cols+1) % matrix horizontal
matrix_x(1, i) = koordinaten((rows * cols - (i-2) * rows), 1);
matrix_x(j, 1) = koordinaten((rows * cols - (i-2) * rows - j + 2), 5);
matrix_x(j ,i) = koordinaten((rows * cols - (i-2) * rows - j + 2), 3);
end
end
for j = 2:(rows+1) % matrix vertikal
for i = 2:(cols+1) % matrix horizontal
matrix_y(1, i) = koordinaten((rows * cols - (i-2) * rows), 1);
matrix_y(j, 1) = koordinaten((rows * cols - (i-2) * rows - j + 2), 5);
matrix_y(j ,i) = koordinaten((rows * cols - (i-2) * rows - j + 2), 7);
end
end
% Plotten der Wertetabellen der prozentualne Differenzen zwischen
% gemessenen und berechneten x und y im Betrag als Oberflächen-Graph
[X, Y] = meshgrid(matrix_x(1, 2:(cols+1)), matrix_x(2:(rows+1), 1));
Z = matrix_x(2:(rows+1), 2:(cols+1));
surf(X,Y,Z);
xlabel('Ort horizontal');
ylabel('Ort vertikal');
zlabel('Delta x [%]');
title('Abweichung Berechnung aus Linearkombination Messung X [%]');
colorbar
axis ([8 78 99 179 0 15])
print -djpeg100 linearkombination_abweichung_x_optimiert.jpeg;

7.2 Anhang - Quelltext MATLAB®-Programme 112
[X, Y] = meshgrid(matrix_y(1, 2:(cols+1)), matrix_y(2:(rows+1), 1));
Z = matrix_y(2:(rows+1), 2:(cols+1));
surf(X,Y,Z);
xlabel('Ort horizontal');
ylabel('Ort vertikal');
zlabel('Delta y [%]');
title('Abweichung Berechnung aus Linearkombination Messung Y [%]');
colorbar
axis ([8 78 99 179 0 15])
print -djpeg100 linearkombination_abweichung_y_optimiert.jpeg;
% Ausgabe der Matrizen in Listenform und als Wertetabelle in Excel
xlswrite('linearkombination_optimiert', koordinaten);
xlswrite('linearkombination_abweichungen_x_optimiert', matrix_x);
xlswrite('linearkombination_abweichungen_y_optimiert', matrix_y);
xlswrite('koeffizienten_optimiert', faktoren_gesamt);
% xlswrite(koordinaten, 'Vergleich Ort: Messung Berechnung aus Linearkombination', {'X-Mess', 'X-Calc', '|dX|%', '',
'Y-Mess', 'Y-Calc', '|dY|%'}, 'linearkombination_optimiert', 'Tabelle1');
% xlswrite(matrix_x, 'Linearkombination %-Abweichungen x', {''}, 'linearkombination_abweichungen_x_optimiert',
'Tabelle1');
% xlswrite(matrix_y, 'Linearkombination %-Abweichungen y', {''}, 'linearkombination_abweichungen_y_optimiert',
'Tabelle1');
% xlswrite(faktoren_gesamt, 'Koeffizienten der Linearkombinationen',
{'x','x1','x2','x3','x4','','y','y1','y2','y3','y4'}, 'koeffizienten_optimiert', 'Tabelle1');
clear;

7.2 Anhang - Quelltext MATLAB®-Programme 113
7.2.8. pfaller_ortberechnung_impuls.m
Das komplette Programm um aus einem mechanischen Impuls auf die Platte Ort und Stärke des Impulses und Stärke der konstanten Kraft zu
berechnen. Die Messdaten werden direkt aus DIAdem eingelesen. Die Speicherpfade der Dateien faktoren_x.txt, faktoren_y.txt und geraden.txt müssen
in MATLAB ® eingegeben werden, weiterhin wird das Programm ShowData der Universität benötigt: File > Set Path…
% Benötigt das Programm ShowData der Universität. (Hinzufügen mit: File >
% Set Path...)
% Die Speicherpfade der Dateien faktoren_x.txt, faktoren_y.txt und
% geraden.txt müssen in MATLAB® eingegeben werden: File > Set Path...
% function GetDataFromChannel
clear;
global Header;
solution = dlmread('gerade.txt');
m = solution(1, 1);
t = solution(2, 1);
Mess = [];
row = 1;
koordinaten = [];
amplitudes_ll = [];
amplitudes_lr = [];

7.2 Anhang - Quelltext MATLAB®-Programme 114
amplitudes_ml = [];
amplitudes_mr = [];
amplitudes_ul = [];
amplitudes_ur = [];
amplitudes_ll_mean = [];
amplitudes_lr_mean = [];
amplitudes_ml_mean = [];
amplitudes_mr_mean = [];
amplitudes_ul_mean = [];
amplitudes_ur_mean = [];
amplitudes_mag_f = [];
amplitudes_mag_in = [];
[ffiles, fpath] = ListFilesForSelect;
ffile = [];
fileNr = length(ffiles);
if ~isempty(ffiles)
detectUiPp.prompText = 'Now select your desired file.dat!';
detectUiPp.boxHeaders = {' '};
for i = 1:fileNr
detectUiPp.boxNames(i, 1) = {[ffiles(i).name ' ' ffiles(i).comment]};
detectUiPp.boxValues(i, 1) = 0;
end
qq = AutoDetectUIInput(detectUiPp); % local function
if ~ischar(qq)
for i = 1:fileNr
if qq.boxValues(i, 1)=='1';
ffile = ffiles(i).name;
break;
end
end
end
clear detectUiPp qq ffiles;

7.2 Anhang - Quelltext MATLAB®-Programme 115
end
if ~isempty(ffile),
Header.FullFilename = '';
fullfilename = fullfile(fpath, ffile);
if strcmpi(ffile((end - 2):end), 'DAT'), % DIADEM file.
hfilename = [fullfilename(1:(end - 4)), '_diaheader.mat'];
if exist(hfilename),
load(hfilename); % open MAT file with HEADER data.
if ~strcmp(Header.FullFilename, fullfilename), %---
Header.FullFilename = fullfilename;
[fpath, dummy] = fileparts(fullfilename);
Header.FilePath = fpath;
save(hfilename, 'Header')
end
else,
Header = TransformDiademToMat(fullfilename);
end
else
dummy = ['File type ', fullfilename((end - 2):end), ...
'is not supported.'];
Notify(dummy, [], 'r')
error([' ### ShowData: ', dummy])
end
for i = 1:Header.NChannels,
switch Header.Channel(i).Name
case 'control'
[amplitude, xnew] = GetDiaData(i, 0, Header.Channel(i).Length);
Mess = (find(diff(amplitude)>0.5) + 1);
Mess = [Mess(1); Mess(find(diff(Mess)>1500)+1)];
end
end

7.2 Anhang - Quelltext MATLAB®-Programme 116
for j = 1:size(Mess, 1),
for i = 1:Header.NChannels,
switch Header.Channel(i).Name
case 'X'
[Ynew, Xnew] = GetDiaData(i, Mess(j, 1)+500, 5000);
koordinaten(row, 1) = mean(Ynew);
case 'Y'
[Ynew, Xnew] = GetDiaData(i, Mess(j, 1)+500, 5000);
koordinaten(row, 2) = mean(Ynew);
case 'ForceIn_ll'
[Y_offset, X_offset] = GetDiaData(i, Mess(j, 1), 500);
offset = [];
offset(size(offset, 1)+1, :) = mean(Y_offset);
[Ynew, Xnew] = GetDiaData(i, Mess(j, 1)+500, 5000);
amplitudes_ll(size(amplitudes_ll, 1)+1, :) = Ynew - offset;
case 'ForceIn_lr'
[Y_offset, X_offset] = GetDiaData(i, Mess(j, 1), 500);
offset = [];
offset(size(offset, 1)+1, :) = mean(Y_offset);
[Ynew, Xnew] = GetDiaData(i, Mess(j, 1)+500, 5000);
amplitudes_lr(size(amplitudes_lr, 1)+1, :) = Ynew - offset;
case 'ForceIn_ul'
[Y_offset, X_offset] = GetDiaData(i, Mess(j, 1), 500);
offset = [];
offset(size(offset, 1)+1, :) = mean(Y_offset);
[Ynew, Xnew] = GetDiaData(i, Mess(j, 1)+500, 5000);

7.2 Anhang - Quelltext MATLAB®-Programme 117
amplitudes_ul(size(amplitudes_ul, 1)+1, :) = Ynew - offset;
case 'ForceIn_ur'
[Y_offset, X_offset] = GetDiaData(i, Mess(j, 1), 500);
offset = [];
offset(size(offset, 1)+1, :) = mean(Y_offset);
[Ynew, Xnew] = GetDiaData(i, Mess(j, 1)+500, 5000);
amplitudes_ur(size(amplitudes_ur, 1)+1, :) = Ynew - offset;
case 'ForceIn_ml_i(5)'
[Y_offset, X_offset] = GetDiaData(i, Mess(j, 1), 500);
offset = [];
offset(size(offset, 1)+1, :) = mean(Y_offset);
[Ynew, Xnew] = GetDiaData(i, Mess(j, 1)+500, 5000);
amplitudes_ml(size(amplitudes_ml, 1)+1, :) = Ynew - offset;
case 'ForceIn_mr_i(6)'
[Y_offset, X_offset] = GetDiaData(i, Mess(j, 1), 500);
offset = [];
offset(size(offset, 1)+1, :) = mean(Y_offset);
[Ynew, Xnew] = GetDiaData(i, Mess(j, 1)+500, 5000);
amplitudes_mr(size(amplitudes_mr, 1)+1, :) = Ynew - offset;
case 'ForceMagIn'
[Y_offset, X_offset] = GetDiaData(i, Mess(j, 1), 500);
offset = [];
offset(size(offset, 1)+1, :) = mean(Y_offset);
[Ynew, Xnew] = GetDiaData(i, Mess(j, 1)+500, 5000);
amplitudes_mag_f(size(amplitudes_mag_f, 1)+1, :) = Ynew - offset;
case 'HubMagIn'
[Y_offset, X_offset] = GetDiaData(i, Mess(j, 1), 500);
offset = [];
offset(size(offset, 1)+1, :) = mean(Y_offset);

7.2 Anhang - Quelltext MATLAB®-Programme 118
end
end
end
end
row = row + 1;
[Ynew, Xnew] = GetDiaData(i, Mess(j, 1)+500, 5000);
amplitudes_mag_in(size(amplitudes_mag_in, 1)+1, :) = Ynew - offset;
hold on;
for n = 1:size(amplitudes_ll, 1)
% Suchen des Messpunktes mit der höchsten Amplitude
maximum = [max(max(amplitudes_ll(n, :))), max(max(amplitudes_lr(n, :))), max(max(amplitudes_ml(n, :))),
max(max(amplitudes_mr(n, :))), max(max(amplitudes_ul(n, :))), max(max(amplitudes_ur(n, :)))];
nr = find(maximum == max(maximum));
switch nr
case 1
value = amplitudes_ll(n, :);
case 2
value = amplitudes_lr(n, :);
case 3
value = amplitudes_ml(n, :);
case 4
value = amplitudes_mr(n, :);
case 5
value = amplitudes_ul(n, :);
case 6
value = amplitudes_ur(n, :);
end
% Finden des Startwerts x1 des Kraftintervalls
% Position von x1 = Mitte der 1. Schwingung nach dem Kraftanstieg
x1_1 = 50; % Startwert 50 [ms], kurz vor dem Kraftanstieg
% Suchen des 1. HOP

7.2 Anhang - Quelltext MATLAB®-Programme 119
while value(x1_1) = value(x1_2+1)
x1_2 = x1_2 + 1; % x1_1 ist die Position des TIP nach dem 1. HOP
end
% Von jedem Kraftert zwischen HOP und TIP in der Matrix wird der Mittelwert der beiden subtrahiert
delta_1 = value(1, x1_1:x1_2) - (ones(1, x1_2 - x1_1 + 1) * (value(x1_1) + value(x1_2))/2);
delta_1 = abs(delta_1); % Betrag der obigen Matrix
% Findet das Minimum der Matrix (= Punkt der am nächsten am Mittelwert gelegen ist
x1 = find(delta_1 == min(delta_1), 1, 'last');
x1 = x1 + x1_1 - 1;
% Finden des Endwerts x2 des Kraftintervalls
% Position von x2 = Mitte der letzten Schwingung vor dem Kraftabfall
x2_1 = find(value == min(value), 1, 'first'); % Startwert ist Minimum der gesamten Kurve
% Suchen des 1. HOP vor dem Minimum
while value(x2_1) = value(x2_2-1)
x2_2 = x2_2 - 1; % x2_1 ist die Position des letzten TIP vor dem Kraftabfall
end

7.2 Anhang - Quelltext MATLAB®-Programme 120
% Finden des Punktes x2 der dem Mittelwert aus x2_1 und x2_2 am nächsten liegt
delta_2 = value(1, x2_2:x2_1) - (ones(1, x2_1 - x2_2 + 1) * (value(x2_1) + value(x2_2))/2);
delta_2 = abs(delta_2);
x2 = find(delta_2 == min(delta_2), 1, 'first');
x2 = x2 + x2_2 - 1;
clear summe;
summe = (amplitudes_ll(n, :)); % Addieren der Kräfte aller Sensoren
summe = summe + (amplitudes_lr(n, :)); % (zur Übersicht untereinander geschrieben)
summe = summe + (amplitudes_ml(n, :));
summe = summe + (amplitudes_mr(n, :));
summe = summe + (amplitudes_ul(n, :));
summe = summe + (amplitudes_ur(n, :));
% Finden der 1. Integrationsgrenze des Impulses
% Position: Stelle zwischen 1 und x1_1, die am nähesten an der
% konstanten Kraft liegt
delta_i1 = summe(1:x1_1) - ones(1, x1_1) * mean(summe(x1:x2));
delta_i1 = abs(delta_i1);
i_start = find(delta_i1 == min(delta_i1), 1, 'first');
% Finden der 2. Integrationsgrenze des Impulses
% Position: Stelle zwischen x1_1 und x1_2, die am nähesten an der
% konstanten Kraft liegt
delta_i2 = summe(x1_1:x1_2) - ones(1, x1_2 - x1_1 + 1) * mean(summe(x1:x2));
delta_i2 = abs(delta_i2);
i_end = find(delta_i2 == min(delta_i2), 1, 'last');

7.2 Anhang - Quelltext MATLAB®-Programme 121
i_end = i_end + x1_1 - 1;
% Berehnung des Impulses
impuls = sum(summe(i_start:i_end)); % Integrieren des Impulses mit den vorher gefundenen Grenzen
impuls = impuls - mean(summe(x1:x2)); % Abziehen der konstanten Kraft (=Fläche unter der konstanten Kraft)
impuls = impuls * (i_end - i_start + 1) / 2; % Halbieren der Fläche
impuls = impuls / 1000; % Umrechnung der Millisekunden auf Sekunden
impuls = impuls * m + t; % Umrechnung der Sensorspannung in g
impuls = impuls / 1000; % Umrechnung der g in kg
impuls = impuls * 9,81; % Umrechnung der kg in N
impuls_matrix(n, 1) = impuls; % Schreiben des aktuellen Impulses in eine Matrix
% Berechnen der Mittelwerte
amplitudes_ll_mean(n, 1) = mean(amplitudes_ll(n, x1:x2));
amplitudes_lr_mean(n, 1) = mean(amplitudes_lr(n, x1:x2));
amplitudes_ml_mean(n, 1) = mean(amplitudes_ml(n, x1:x2));
amplitudes_mr_mean(n, 1) = mean(amplitudes_mr(n, x1:x2));
amplitudes_ul_mean(n, 1) = mean(amplitudes_ul(n, x1:x2));
amplitudes_ur_mean(n, 1) = mean(amplitudes_ur(n, x1:x2));
amplitudes_mag_f_mean(n, 1) = mean(amplitudes_mag_f(n, x1:x2));
amplitudes_mag_in_mean(n, 1) = mean(amplitudes_mag_in(n, x1:x2));
end
hold off;
% Schreiben der gefundenen Werte in eine Matrix
ForceIn_ul = amplitudes_ul_mean;
ForceIn_ur = amplitudes_ur_mean;
ForceIn_ml = amplitudes_ml_mean;
ForceIn_mr = amplitudes_mr_mean;
ForceIn_ll = amplitudes_ll_mean;
ForceIn_lr = amplitudes_lr_mean;
% Einlesen der Koeffizienten der Linearkombination

7.2 Anhang - Quelltext MATLAB®-Programme 122
faktoren_x = dlmread('faktoren_x.txt');
faktoren_y = dlmread('faktoren_y.txt');
n_ul = faktoren_x(1, 1);
n_ur = faktoren_x(2, 1);
n_ml = faktoren_x(3, 1);
n_mr = faktoren_x(4, 1);
n_ll = faktoren_x(5, 1);
n_lr = faktoren_x(6, 1);
m_ul = faktoren_y(1, 1);
m_ur = faktoren_y(2, 1);
m_ml = faktoren_y(3, 1);
m_mr = faktoren_y(4, 1);
m_ll = faktoren_y(5, 1);
m_lr = faktoren_y(6, 1);
% Die Gleichung ist für F=4000g definiert, F_0 ist dieser Wert als
% Sensorspannung
F_0 = (4000 - t)/m;
for row = 1:size(koordinaten, 1)
F_ul = ForceIn_ul(row, 1);
F_ur = ForceIn_ur(row, 1);
F_ml = ForceIn_ml(row, 1);
F_mr = ForceIn_mr(row, 1);
F_ll = ForceIn_ll(row, 1);
F_lr = ForceIn_lr(row, 1);
% Berechnen der Gesamtkraft
F_ges = F_ul + F_ur + F_ml + F_mr + F_ll + F_lr;

7.2 Anhang - Quelltext MATLAB®-Programme 123
% Berechnen, welcher Kraft die aktuelle Kraft bei einer Gesamtkraft von
% F_0 entsoricht
F_ul = F_ul * F_0 / F_ges;
F_ur = F_ur * F_0 / F_ges;
F_ml = F_ml * F_0 / F_ges;
F_mr = F_mr * F_0 / F_ges;
F_ll = F_ll * F_0 / F_ges;
F_lr = F_lr * F_0 / F_ges;
auswertung(row, 1) = koordinaten(row, 1); % x gemessen
auswertung(row, 2) = m_ul*F_ul + m_ur * F_ur + m_ml * F_ml +m_mr * F_mr + m_ll * F_ll + m_lr * F_lr; % Berechnung
von y
auswertung(row, 3) = abs((auswertung(row, 1) - auswertung(row, 2)) * 100 / auswertung(row, 1)); % Die prozentuale
Differenz zwischen gemessenem und berechnetem x im Betrag
auswertung(row, 5) = koordinaten(row, 2); % y gemessen
auswertung(row, 6) = n_ul*F_ul + n_ur * F_ur + n_ml * F_ml +n_mr * F_mr + n_ll * F_ll + n_lr * F_lr; % Berechnung
von x
auswertung(row, 7) = abs((auswertung(row, 5) - auswertung(row, 6)) * 100 / auswertung(row, 5)); % Die prozentuale
Differenz zwischen gemessenem und berechnetem y im Betrag
end
auswertung(row, 11) = (F_ges * m + t) / 1000 * 9,81;
auswertung(:, 9) = impuls_matrix;
row = row + 1;
mittelwerte = mean(auswertung); % Berechnung der Mittelwerte für jede Spalte
auswertung(row, 3) = mittelwerte(1, 3); % Mittelwert Abweichungen x
auswertung(row, 7) = mittelwerte(1, 7); % Mittelwert Abweichungen y
% Ausgabe der berechneten Matrix

7.2 Anhang - Quelltext MATLAB®-Programme 124
xlswrite('linearkombination_einfach_neu', auswertung);
% xlswrite(auswertung, 'Vergleich Ort: Messung Berechnung aus Linearkombination', {'X-Mess', 'X-Calc', '|dX|%', '',
'Y-Mess', 'Y-Calc', '|dY|%', '', 'Impuls [Ns]', '', 'Kraft [N]'}, 'linearkombination_einfach_neu', 'Tabelle1');

7.2 Anhang - Quelltext MATLAB®-Programme 125
7.2.9. pfaller_solve_linearkombination.m
Programm zur Berechnung des Ortes durch eine verschiedene Linearkombination. In Zeile 4 bis 9 müssen die Speicherpfade der Excel-Tabellen mit
den dreidimensionalen Wertetabellen der drei Sensoren eingegeben werden. Erzeugt die Dateien faktoren_x.txt und faktoren_y.txt mit den
Koeffizienten der Linearkombination, wird von Programm pfaller_ortberechnung_impuls.m benötigt.
clear;
% Messwerte einlesen
ForceIn_ul = xlsread('D:\Pfaller\Auswertung\excel\F_ul_4000.xls');
ForceIn_ur = xlsread('D:\Pfaller\Auswertung\excel\F_ur_4000.xls');
ForceIn_ml = xlsread('D:\Pfaller\Auswertung\excel\F_ml_4000.xls');
ForceIn_mr = xlsread('D:\Pfaller\Auswertung\excel\F_mr_4000.xls');
ForceIn_ll = xlsread('D:\Pfaller\Auswertung\excel\F_ll_4000.xls');
ForceIn_lr = xlsread('D:\Pfaller\Auswertung\excel\F_lr_4000.xls');
% Finden der Koeffizienten zur Ortsberechnung
row = 1;
for j = 2:(size(ForceIn_ul, 1))
for i = 2:(size(ForceIn_ul, 2))
% Erzeigt pro Messpunkt eine Gleichung der Form:
% x = n_ul*F_ul + n_ur * F_ur + n_ml * F_ml +n_mr * F_mr + n_ll * F_ll + n_lr * F_lr
% und
% y = m_ul*F_ul + m_ur * F_ur + m_ml * F_ml +m_mr * F_mr + m_ll * F_ll + m_lr * F_lr
%
% koeffizienten = [F_ul1, F_ur1, F_ml1, F_mr1, F_ll1, F_lr1

7.2 Anhang - Quelltext MATLAB®-Programme 126
% F_ul2, F_ur2, F_ml2, F_mr2, F_ll2, F_lr2
% ... ]
%
% rechts_x = [x1;
% x2;
% ...]
% rechts_y = [y1;
% y2;
% ...]
%
% Zum Lösen des linearen Gleichungssystems:
% koeffizienten\rechts_x = [n_ul;
% n_ur;
% n_ml;
% n_mr;
% n_ll;
% n_lr;]
%
% koeffizienten\rechts_y = [m_ul;
% m_ur;
% m_ml;
% m_mr;
% m_ll;
% m_lr;]
F_ul = ForceIn_ul(j,i);
F_ur = ForceIn_ur(j,i);
F_ml = ForceIn_ml(j,i);
F_mr = ForceIn_mr(j,i);
F_ll = ForceIn_ll(j,i);
F_lr = ForceIn_lr(j,i);
koeffizienten(row, 1) = F_ul;

7.2 Anhang - Quelltext MATLAB®-Programme 127
end
end
koeffizienten(row, 2) = F_ur;
koeffizienten(row, 3) = F_ml;
koeffizienten(row, 4) = F_mr;
koeffizienten(row, 5) = F_ll;
koeffizienten(row, 6) = F_lr;
rechts_x(row, 1) = ForceIn_ul(j,1);
rechts_y(row, 1) = ForceIn_ul(1,i);
row = row + 1;
faktoren_x = koeffizienten\rechts_x;
faktoren_y = koeffizienten\rechts_y;
% Ortsberechnung mit den oben gefundenen Koeffizienten
n_ul = faktoren_x(1, 1);
n_ur = faktoren_x(2, 1);
n_ml = faktoren_x(3, 1);
n_mr = faktoren_x(4, 1);
n_ll = faktoren_x(5, 1);
n_lr = faktoren_x(6, 1);
m_ul = faktoren_y(1, 1);
m_ur = faktoren_y(2, 1);
m_ml = faktoren_y(3, 1);
m_mr = faktoren_y(4, 1);
m_ll = faktoren_y(5, 1);
m_lr = faktoren_y(6, 1);

7.2 Anhang - Quelltext MATLAB®-Programme 128
dlmwrite('faktoren_x.txt', faktoren_x);
dlmwrite('faktoren_y.txt', faktoren_y);
row = 1;
for j = 2:(size(ForceIn_ul, 1))
for i = 2:(size(ForceIn_ul, 2))
F_ul = ForceIn_ul(j,i);
F_ur = ForceIn_ur(j,i);
F_ml = ForceIn_ml(j,i);
F_mr = ForceIn_mr(j,i);
F_ll = ForceIn_ll(j,i);
F_lr = ForceIn_lr(j,i);
koordinaten(row, 1) = ForceIn_ul(j,1); % x gemessen
koordinaten(row, 2) = n_ul*F_ul + n_ur * F_ur + n_ml * F_ml +n_mr * F_mr + n_ll * F_ll + n_lr * F_lr; %
Berechnung von x
koordinaten(row, 3) = abs((koordinaten(row, 1) - koordinaten(row, 2)) * 100 / koordinaten(row, 1)); % Die
prozentuale Differenz zwischen gemessenem und berechnetem x im Betrag
koordinaten(row, 5) = ForceIn_ul(1,i); % y gemessen
koordinaten(row, 6) = m_ul*F_ul + m_ur * F_ur + m_ml * F_ml +m_mr * F_mr + m_ll * F_ll + m_lr * F_lr; %
Berechnung von y
koordinaten(row, 7) = abs((koordinaten(row, 5) - koordinaten(row, 6)) * 100 / koordinaten(row, 5)); % Die
prozentuale Differenz zwischen gemessenem und berechnetem y im Betrag
end
end
row = row+1;
mittelwerte = mean(koordinaten); % Berechnung der Mittelwerte für jede Spalte
koordinaten(row, 3) = mittelwerte(1, 3);

7.2 Anhang - Quelltext MATLAB®-Programme 129
koordinaten(row, 7) = mittelwerte(1, 7);
cols = size(ForceIn_ul, 1) - 1; % Anzahl der verschiedenen horizontalen Messpunkte (bzw. Anzahl der gemessenen Spalten)
rows = size(ForceIn_ul, 2) - 1; % Anzahl der verschiedenen vertikalen Messpunkte (bzw. Anzahl der gemessenen Reihen)
% Umwandlung der Matrizen von Listenform in eine dreidimensionaleWertetabelle
for j = 2:(rows+1) % matrix vertikal
for i = 2:(cols+1) % matrix horizontal
matrix_x(1, i) = koordinaten((rows * cols - (i-2) * rows), 1);
matrix_x(j, 1) = koordinaten((rows * cols - (i-2) * rows - j + 2), 5);
matrix_x(j ,i) = koordinaten((rows * cols - (i-2) * rows - j + 2), 3);
end
end
for j = 2:(rows+1) % matrix vertikal
for i = 2:(cols+1) % matrix horizontal
matrix_y(1, i) = koordinaten((rows * cols - (i-2) * rows), 1);
matrix_y(j, 1) = koordinaten((rows * cols - (i-2) * rows - j + 2), 5);
matrix_y(j ,i) = koordinaten((rows * cols - (i-2) * rows - j + 2), 7);
end
end
% Plotten der Wertetabellen der prozentualne Differenzen zwischen
% gemessenen und berechneten x und y im Betrag als Oberflächen-Graph
[X, Y] = meshgrid(matrix_x(1, 2:(cols+1)), matrix_x(2:(rows+1), 1));
Z = matrix_x(2:(rows+1), 2:(cols+1));
surf(X,Y,Z);
xlabel('Ort horizontal');
ylabel('Ort vertikal');
zlabel('Delta x [%]');

7.2 Anhang - Quelltext MATLAB®-Programme 130
title('Abweichung Berechnung aus Linearkombination Messung X [%]');
colorbar
% axis ([8 78 99 179 0 15])
print -djpeg100 linearkombination_abweichung_x_neu.jpeg;
[X, Y] = meshgrid(matrix_y(1, 2:(cols+1)), matrix_y(2:(rows+1), 1));
Z = matrix_y(2:(rows+1), 2:(cols+1));
surf(X,Y,Z);
xlabel('Ort horizontal');
ylabel('Ort vertikal');
zlabel('Delta y [%]');
title('Abweichung Berechnung aus Linearkombination Messung Y [%]');
colorbar
% axis ([8 78 99 179 0 15])
print -djpeg100 linearkombination_abweichung_y_neu.jpeg;
% Ausgabe der Matrizen in Listenform und als Wertetabelle in Excel
xlswrite('linearkombination_einfach_neu', koordinaten);
xlswrite('linearkombination_abweichungen_x_neu', matrix_x);
xlswrite('linearkombination_abweichungen_y_neu', matrix_y);
% xlswrite(koordinaten, 'Vergleich Ort: Messung Berechnung aus Linearkombination', {'X-Mess', 'X-Calc', '|dX|%', '',
'Y-Mess', 'Y-Calc', '|dY|%'}, 'linearkombination_einfach_neu', 'Tabelle1');
% xlswrite(matrix_x, 'Linearkombination %-Abweichungen x', {''}, 'linearkombination_abweichungen_x_neu', 'Tabelle1');
% xlswrite(matrix_y, 'Linearkombination %-Abweichungen y', {''}, 'linearkombination_abweichungen_y_neu', 'Tabelle1');

7.2 Anhang - Quelltext MATLAB®-Programme 131
7.2.10. pfaller_solve_sensorgleichungen.m
Programm zum Berechnen des Ortes über je zwei Sensorgleichungen.
clear;
ForceIn_mr = xlsread('D:\Pfaller\Auswertung\excel\matrix-ForceIn_mr.xls');
ForceIn_ml = xlsread('D:\Pfaller\Auswertung\excel\matrix-ForceIn_ml.xls');
ForceIn_ur = xlsread('D:\Pfaller\Auswertung\excel\matrix-ForceIn_ur.xls');
ForceIn_ul = xlsread('D:\Pfaller\Auswertung\excel\matrix-ForceIn_ul.xls');
koordinaten_ur_ul = [];
koordinaten_mr_ml = [];
mittelwerte = [];
a = 0.000359639212592366;
b = -0.0342834501388174;
c = -0.00390141447718803;
d = 0.425751094384385;
e = -0.000363574763629761;
f = 0.0343389335868583;
g = 0.0275989158973349;
h = -2.5380814944847;
m = 1;
for j = 2:size(ForceIn_ur, 1) %ort horizontal, matrix vertikal
for i = 2:size(ForceIn_ur, 2) %ort vertikal, matrix horizontal
Q = ForceIn_ur(j,i);
W = ForceIn_ul(j,i);
koordinaten_ur_ul (m, 1) = ForceIn_ur(j,1); % X-Mess

7.2 Anhang - Quelltext MATLAB®-Programme 132
koordinaten_ur_ul (m, 2) = ForceIn_ur(1,i); % Y-Mess
% X aus ul und ur
koordinaten_ur_ul (m, 3) = (-a*Q+a*h-b*g+W*e-d*e+c*f+sqrt((a*Q-a*h+b*g-W*e+d*e-c*f)^2-4*(b*e-a*f)*(-W*g+c*Qc*h+d*g)))/(2*(b*e-a*f));
% Y aus ul und ur
koordinaten_ur_ul (m, 4) = (-e*W+e*d-b*g+Q*a-h*a+f*c+sqrt((e*W-e*d+b*g-Q*a+h*a-f*c)^2-4*(a*g-e*c)*(h*b-Q*b+f*Wf*d)))/(2*(a*g-e*c));
m = m+1;
end
end
xlswrite('berechnung-ul_ur', koordinaten_ur_ul)
% xlswrite(koordinaten_ur_ul, 'Vergleich Ort: Messung Funktion', {'X-Mess','Y-Mess','X-Funktion','Y-Funktion'},
'berechnung-ul_ur', 'Tabelle1')
a = 0.000259735649014046;
b = -0.0545167750587224;
c = -0.0211168168811804;
d = 4.42018275302235;
e = -0.000256296316559226;
f = 0.0552293477502357;
g = 0.00132484860844195;
h = -0.303685785851139;
n = 1;
for j = 2:size(ForceIn_mr, 1) %ort horizontal, matrix vertikal
for i = 2:size(ForceIn_mr, 2) %ort vertikal, matrix horizontal
Q = ForceIn_ml(j,i);
W = ForceIn_mr(j,i);
koordinaten_mr_ml (n, 1) = ForceIn_mr(j,1);
koordinaten_mr_ml (n, 2) = ForceIn_mr(1,i);
% X aus ml und mr

7.2 Anhang - Quelltext MATLAB®-Programme 133
koordinaten_mr_ml (n, 3) = (-a*Q+a*h-b*g+W*e-d*e+c*f+sqrt((a*Q-a*h+b*g-W*e+d*e-c*f)^2-4*(b*e-a*f)*(-W*g+c*Qc*h+d*g)))/(2*(b*e-a*f));
% Y aus ml und mr
koordinaten_mr_ml (n, 4) = (-e*W+e*d-b*g+Q*a-h*a+f*c+sqrt((e*W-e*d+b*g-Q*a+h*a-f*c)^2-4*(a*g-e*c)*(h*b-Q*b+f*Wf*d)))/(2*(a*g-e*c));
n = n+1;
end
end
xlswrite('berechnung-ml_mr', koordinaten_mr_ml)
% xlswrite(koordinaten_mr_ml, 'Vergleich Ort: Messung Funktion', {'X-Mess','Y-Mess','X-Funktion','Y-Funktion'},
'berechnung-ml_mr', 'Tabelle1')
% Errechnen der Mittelwerte
for j = 1:size(koordinaten_mr_ml, 1)
for i = 1:size(koordinaten_mr_ml, 2)
mittelwerte (j, i) = (koordinaten_ur_ul (j, i) + koordinaten_mr_ml (j, i))/2;
end
end
xlswrite('berechnung-mittelwerte', mittelwerte)
% xlswrite(mittelwerte, 'Vergleich Ort: Messung Funktion', {'X-Mess','Y-Mess','X-Funktion','Y-Funktion'},
'berechnung-mittelwerte', 'Tabelle1')

7.2 Anhang - Quelltext MATLAB®-Programme 134
7.2.11. pfaller_solve_sensorgleichungen_felder.m
Programm zum Berechnen des Ortes aus Sensorgleichungen, die ortsabhängig ausgewählt werden.
clear;
% Messwerte einlesen
ForceIn_ul = xlsread('D:\Pfaller\Auswertung\excel\matrix-ForceIn_ul.xls');
ForceIn_ur = xlsread('D:\Pfaller\Auswertung\excel\matrix-ForceIn_ur.xls');
ForceIn_ml = xlsread('D:\Pfaller\Auswertung\excel\matrix-ForceIn_ml.xls');
ForceIn_mr = xlsread('D:\Pfaller\Auswertung\excel\matrix-ForceIn_mr.xls');
ForceIn_ll = xlsread('D:\Pfaller\Auswertung\excel\matrix-ForceIn_ll.xls');
ForceIn_lr = xlsread('D:\Pfaller\Auswertung\excel\matrix-ForceIn_lr.xls');
% Setzen der Parameter für die Sensorgleichungen
% ForceIn_ul
m1 = 0.000359639212592366;
t1 = -0.0342834501388174;
n1 = -0.00390141447718803;
u1 = 0.425751094384385;
% ForceIn_ur
m2 = -0.000362039560416502;
t2 = 0.0341478167581925;
n2 = 0.0275886250224694;
u2 = -2.53788271315461;
% ForceIn_ml

7.2 Anhang - Quelltext MATLAB®-Programme 135
m3 = -0.000256296316559226;
t3 = 0.0552293477502357;
n3 = 0.00132484860844195;
u3 = -0.303685785851139;
% ForceIn_mr
m4 = 0.000259735649014046;
t4 = -0.0545167750587224;
n4 = -0.0211168168811804;
u4 = 4.42018275302235;
% ForceIn_ll
m5 = -0.0000295424783482509;
t5 = 0.00364881555582335;
n5 = -0.000106219411055925;
u5 = 0.0294868232698038;
% ForceIn_lr
m6 = 0.0000244897192616882;
t6 = -0.00303742828177236;
n6 = -0.00233875288353974;
u6 = 0.300506639279001;
koordinaten = [];
row = 1;
% Finden der Anzahl der gemessenen Spalten und Reihen
cols = size(ForceIn_ul, 1) - 1;

7.2 Anhang - Quelltext MATLAB®-Programme 136
rows = size(ForceIn_ul, 2) - 1;
for j = 2:(cols+1) %ort horizontal, matrix vertikal
for i = 2:(rows+1) %ort vertikal, matrix horizontal
% Bestimmung der aktuellen Sensorkräfte aus den vorher eingelesenen Matrizen
F_ul = ForceIn_ul(j,i);
F_ur = ForceIn_ur(j,i);
F_ml = ForceIn_ml(j,i);
F_mr = ForceIn_mr(j,i);
F_ll = ForceIn_ll(j,i);
F_lr = ForceIn_lr(j,i);
% Lösen der Sensorgleichung nach x und y mit allen sechs Sensoren
% zur groben Ortsbestimmung
F = @(V) [(m1 * V(2) + t1) * V(1) + n1 * V(2) + u1 - F_ul; (m2 * V(2) + t2) * V(1) + n2 * V(2) + u2 - F_ur; (m3 *
V(2) + t3) * V(1) + n3 * V(2) + u3 - F_ml; (m4 * V(2) + t4) * V(1) + n4 * V(2) + u4 - F_mr; (m5 * V(2) + t5) * V(1) + n5
* V(2) + u5 - F_ll; (m6 * V(2) + t6) * V(1) + n6 * V(2) + u6 - F_ll];
solution = fsolve(F, [0 200]);
F_ur];
F_ul];
F_mr];
F_ul];
% Unterteilung der Platte in vier Felder
% Ortsberechnung durch verschiedene Sensoren, je nach Feld
if solution(1,1) > 40
if solution(1,2) > 46 % links oben: ur + ul für x, ml + ul für y
G = @(V) [(m1 * V(2) + t1) * V(1) + n1 * V(2) + u1 - F_ul; (m2 * V(2) + t2) * V(1) + n2 * V(2) + u2 -
H = @(V) [(m3 * V(2) + t3) * V(1) + n3 * V(2) + u3 - F_ml; (m1 * V(2) + t1) * V(1) + n1 * V(2) + u1 -
end
if solution(1,2) < 46 % links unten: ml + mr für x, ml + ul für y
G = @(V) [(m3 * V(2) + t3) * V(1) + n3 * V(2) + u3 - F_ml; (m4 * V(2) + t4) * V(1) + n4 * V(2) + u4 -
end
H = @(V) [(m3 * V(2) + t3) * V(1) + n3 * V(2) + u3 - F_ml; (m1 * V(2) + t1) * V(1) + n1 * V(2) + u1 -

7.2 Anhang - Quelltext MATLAB®-Programme 137
F_ur];
F_ur];
F_mr];
F_ur];
end
if solution(1,1) < 40
if solution(1,2) > 46 % rechts oben: ur + ul für x, mr + ur für y
G = @(V) [(m1 * V(2) + t1) * V(1) + n1 * V(2) + u1 - F_ul; (m2 * V(2) + t2) * V(1) + n2 * V(2) + u2 -
end
H = @(V) [(m4 * V(2) + t4) * V(1) + n4 * V(2) + u4 - F_mr; (m2 * V(2) + t2) * V(1) + n2 * V(2) + u2 -
end
if solution(1,2) < 46 % rechts unten: ml + mr für x, mr + ur für y
G = @(V) [(m3 * V(2) + t3) * V(1) + n3 * V(2) + u3 - F_ml; (m4 * V(2) + t4) * V(1) + n4 * V(2) + u4 -
end
H = @(V) [(m4 * V(2) + t4) * V(1) + n4 * V(2) + u4 - F_mr; (m2 * V(2) + t2) * V(1) + n2 * V(2) + u2 -
options = optimset('Display','off'); % Zwischenergebnisse werden während der Optimierung nicht angezeit
x0 = [0 200]; % geratene Startwerte für die Berechnung
solution_x = fsolve(G, x0, options); % Lösen der Gleichung für x
solution_y = fsolve(H, x0, options); % Lösen der Gleichung für y
% Schreiben der Ergebnisse in eine Liste
koordinaten(row, 1) = ForceIn_ul(j,1); % gemessenes x
koordinaten(row, 2) = ForceIn_ul(1,i); % gemessenes y
koordinaten(row, 3) = solution(1,1); % berechnetes x
koordinaten(row, 4) = solution(1,2); % berechnetes y
% prozentuale x-Differenz als Betrag
koordinaten(row, 5) = abs((ForceIn_ul(j,1)-solution(1,1)) * 100 / ForceIn_ul(j,1));
% prozentuale y-Differenz als Betrag
koordinaten(row, 6) = abs((ForceIn_ul(1,i)-solution(1,2)) * 100 / ForceIn_ul(1,i));
row = row + 1;

7.2 Anhang - Quelltext MATLAB®-Programme 138
end
end
koordinaten(row, 3) = mean(abs(koordinaten(:, 1)-koordinaten(:, 3))); % durchschnittliche Abweichung x
koordinaten(row, 4) = mean(abs(koordinaten(:, 2)-koordinaten(:, 4))); % durchschnittliche Abweichung y
abweichung = mean(koordinaten);
koordinaten(row, 5) = abweichung(1, 5); % durchschnittliche prozentuale Abweichung x
koordinaten(row, 6) = abweichung(1, 6); % durchschnittliche prozentuale Abweichung y
% Umwandlung der listenförmigen Matrix in eine dreidiemsionale Wertetabelle
for j = 2:(rows+1) % matrix vertikal
for i = 2:(cols+1) % matrix horizontal
matrix_x(1, i) = koordinaten((rows * cols - (i-2) * rows), 1);
matrix_x(j, 1) = koordinaten((rows * cols - (i-2) * rows - j + 2), 2);
matrix_x(j ,i) = koordinaten((rows * cols - (i-2) * rows - j + 2), 5);
end
end
for j = 2:(rows+1) % matrix vertikal
for i = 2:(cols+1) % matrix horizontal
matrix_y(1, i) = koordinaten((rows * cols - (i-2) * rows), 1);
matrix_y(j, 1) = koordinaten((rows * cols - (i-2) * rows - j + 2), 2);
matrix_y(j ,i) = koordinaten((rows * cols - (i-2) * rows - j + 2), 6);
end
end
% Export der Matrizen in Excel
xlswrite('berechnung_ranking', koordinaten);
xlswrite('abweichungen_x', matrix_x);
xlswrite('abweichungen_y', matrix_y);
% xlswrite(koordinaten, 'Vergleich Ort: Messung Funktion', {'X-Mess','Y-Mess','X-Funktion','Y-Funktion', '|dX|%',
'|dY|%'}, 'berechnung_ranking', 'Tabelle1');
% xlswrite(matrix_x, '%-Abweichungen x', {''}, 'abweichungen_x', 'Tabelle1');
% xlswrite(matrix_y, '%-Abweichungen y', {''}, 'abweichungen_y', 'Tabelle1');

7.2 Anhang - Quelltext MATLAB®-Programme 139
% Plotten der dreidimensionalen Wertetabellen
[X, Y] = meshgrid(matrix_x(1, 2:(cols+1)), matrix_x(2:(rows+1), 1));
Z = matrix_x(2:(rows+1), 2:(cols+1));
surf(X,Y,Z);
xlabel('Ort horizontal');
ylabel('Ort vertikal');
zlabel('Delta x [%]');
title('Abweichung Funktion Messung X [%]');
colorbar
print -djpeg100 abweichung_x.jpeg;
[X, Y] = meshgrid(matrix_y(1, 2:(cols+1)), matrix_y(2:(rows+1), 1));
Z = matrix_y(2:(rows+1), 2:(cols+1));
surf(X,Y,Z);
xlabel('Ort horizontal');
ylabel('Ort vertikal');
zlabel('Delta y [%]');
title('Abweichung Funktion Messung Y [%]');
colorbar
print -djpeg100 abweichung_y.jpeg;