Analyse von Kraftsensor-Messwerten mit MATLAB zur Orts ... · 2.1 Einführung - Aufbau und Funktion...

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

Impulsbestimmung

Vorgelegt von:

Martin Pfaller

Waldparkstraße 39c

85521 Riemerling

am 17.08.2007

Prüfer: Peter Brichzin, StR

In Kooperation mit der

Fakultät für Elektrotechnik und Informationstechnik,

Institut für Mathematik und Datenverarbeitung

Betreuung: Prof. Dr.-Ing. Werner Wolf


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.


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.


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


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.

1.

2.1 Der Versuch - Aufbau und Funktion 6

2. Der Versuch

2.1. Aufbau und Funktion

Abbildung 2-1: Die Degenfechtstation

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),

1

5 6

3 4

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

8 7

9

10

11


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


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.

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,

1

2

5 3 4

1) Messverstärker 1

2) Messverstärker 2

3) Computerinterface

4) Lichtgitterhardware

5) Lautsprecher

6) Potentiometer

6


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) Messgestell

2) Metallschiene

3) Schlitten

4) Kraftmesser

1

2

3

4


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


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


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.


Diagramm 3-1: Offset bei y=179: Beginn der Messreihe (t=0)

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

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

Zeitliche Veränderung des Offset

-0,1

0

0,1

0,2

0,3

0,4

0,5

0,6

0,7

0 10 20 30 40 50 60 70 80 90

Ort horizontal (~ Zeit)

Mitt

elw

ert R

Vor

u.

RN

ach

ForceIn_llForceIn_lrForceIn_ulForceIn_urForceIn_mlForceIn_mr

Zeit

Zeitliche Veränderung des Offset

-0,1

0

0,1

0,2

0,3

0,4

0,5

0,6

0,7

0 10 20 30 40 50 60 70 80 90

Ort horizontal (~ Zeit)

Mitt

elw

ert R

Vor

u.

RN

ach


Zeit


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)

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.

Prozentuale Abweichung von RVor und RNach

-15

-10

-5

0

5

10

15

0 10 20 30 40 50 60 70 80 90

Ort horizontal

%


Prozentuale Abweichung von RNach und RVor des nächs ten Punktes

-25

-20

-15

-10

-5

0

5

10

15

0 10 20 30 40 50 60 70 80 90

Ort horizontal

%



Tabelle 3-1: Wertetabelle für die Reihe y=179

X Y ForceIn_ll ForceIn_lr ForceIn_ul ForceIn_ur For ceIn_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

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.

Kraftwerte in Abhängigkeit von x (bei y=179)

-0,5

0

0,5

1

1,5

2

2,5

0 10 20 30 40 50 60 70 80

Ort horizontal

Sen

sors

pann

ung ForceIn_ll

ForceIn_lr

ForceIn_ul

ForceIn_ur

ForceIn_ml

ForceIn_mr


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.

Der nächste Schritt in der Auswertung war nun, diese Gleichungen zu finden. Da

die Funktion die Form ),( yxnungSensorspan 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“.

Kraftwerte in Abhängigkeit von y (bei x=68)

-0,5

0

0,5

1

1,5

2

2,5

90 100 110 120 130 140 150 160 170 180

Ort vertikal

Sen

sors

pann

ung ForceIn_ll

ForceIn_lr

ForceIn_ul

ForceIn_ur

ForceIn_ml

ForceIn_mr


Tabelle 3-2: Dreidimensionale Wertetabelle von Sensor ul (Kraft in Abhngigkeit vom Ort)

x-Koordinaten

y-K

oord

inat

en

78 68 58 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

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 txmF += * von Spalte zu Spalte verändern. Um diese

99

119

139

159

179

818283848586878

-0,5

0

0,5

1

1,5

2

2,5

Sensorspannung

Ort vertikal

Ort horizontal

Kraft an Sensor ul in Abhängigkeit vom Ort

2-2,5

1,5-2

1-1,5

0,5-1

0-0,5

-1-0

Sensorposition


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.

Diagramm 3-8: Wie Diagramm 3-7, zusätzlich mit eingezeichneten horizontalen Geraden

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:

99

119

139

159

179

818283848586878

-0,5

0

0,5

1

1,5

2

2,5

Sensorspannung

Ort vertikal

Ort horizontal

Kraft an Sensor ul in Abhängigkeit vom Ort

2-2,5

1,5-2

1-1,5

0,5-1

0-0,5

-1-0

-0,5

0

0,5

1

1,5

2

2,5

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)


11 * tymm += und 22 * tymt += . Setzt man diese beiden Gleichungen in

txmF += * ein, erhält man für die Flächengleichung:

2211 **)*( tymxtymF +++=

Die Parameter 1m , 2m , 1t und 2t müssen für jeden Sensor ermittelt werden.

Diagramm 3-10: Abhängigkeit der Steigung (der horizontalen Geradengleichungen) von y

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)

Abhängigkeit der Steigung (der horizontalen Geraden gleichungen) von y

m = 0,0004y - 0,0344

00,0050,01

0,0150,02

0,0250,03

0,035

90 100 110 120 130 140 150 160 170 180

Ort vertikal

Ste

igun

g

Steigung

Linear (Steigung)

Abhängigkeit des y-Abschnitts (der horizontalen Ger adengleichungen) von y

t = -0,0039y + 0,4281

-0,3

-0,25-0,2

-0,15

-0,1

-0,050

0,05

0,1

90 100 110 120 130 140 150 160 170 180

Ort vertikal

y-A

bsch

nitt

y-Abschnitt

Linear (y-Abschnitt)y


Diagramm 3-12: Kraftverlauf des Sensors ul (Messwerte)

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

99

119

139

159

179

818283848586878

-0,5

0

0,5

1

1,5

2

2,5

3

Kraft

Ort vertikal

Ort horizontal

Kraftverlauf des Sensors ul (Messwerte)

2,5-3

2-2,5

1,5-2

1-1,5

0,5-1

0-0,5

-1-0

99

119

139

159

179

818283848586878

-0,5

0

0,5

1

1,5

2

2,5

3

Kraft

Ort vertikal

Ort horizontal

Kraftverlauf des Sensors ul (optimierte Funktion)

2,5-3

2-2,5

1,5-2

1-1,5

0,5-1

0-0,5

-1-0


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.

Diagramm 3-14: Abweichung Funktion - Messwert an Sensor ul

Im Folgenden werden die Sensorkurven der zweiten statischen Messung erklärt.

Diagramm 3-15: Kraft in Abhängigkeit von x an Sensor lr; F=4000g

99 109 119 129 139 149 159 169 1798

28

48

68

-0,15

-0,1

-0,05

0

0,05

0,1

Funktion - Messwert

Ort vertikal

Ort horizontal

Abweichung Funktion - Messwert an Sensor ul

0,05-0,1

0-0,05

-0,05-0

-0,1--0,05

-0,15--0,1


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


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.


Diagramm 3-17: Kraft in Abhängigkeit von y; F=500g





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.


Diagramm 3-21: Kraft in Abhängigkeit vom Ort (ur); F=500g





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.


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


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


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.


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 ∑ Kraft an Sensoren

angebrachte Kraft

( O f f s e t k o r r i g i e r t )

x1 y1 F1-1 F1-2 … F1-sensors ∑=

−

sensors

kkF

11 Force 1

x2 y2 F2-1 F2-2 … F2-sensors ∑=

−

sensors

kkF

12 Force 2

… … … … … … … …

Xcols Yrows Fcols*rows*forces-1 Fcols*rows*forces-2 … Fcols*rows*forces-sensors ∑=

−

sensors

kkforcesrowscolsF

1** Force forces

Spaltennummer

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.


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


Aufbau, werden zusammen nach dem Muster aus Abbildung 3-3 in die Matrix

Werte geschrieben.

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:

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); Werte(1 + n, i + m) = x_wert; Werte(j + n, 1 + m) = y_wert; Werte(j + n, i + m) = ForceIn((reih e - 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

Sensor 1 Kraft 1

Sensor 1 Kraft 2

Sensor 1 Kraft forces

Sensor 2 Kraft 1

Sensor 2 Kraft 2

Sensor 2 Kraft forces

Sensor sensors Kraft 1

Sensor sensors Kraft 2

Sensor sensors Kraft forces

…

…

…

… … … …

∑ Sensoren Kraft 1

∑ Sensoren Kraft 2

∑ Sensoren Kraft forces

…

Abbildung 3-3: Aufbau der Matrix Werte


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 1**)( tSensorwertmSensorwertKraft += über die Messwerte gelegt werden.

for n = 1:rows * cols * forces links(n, :) = [Forces_x(n, 1), 1]; end


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

=

∑

∑∑∑

t

m

forcesForce

Force

Force

Force

yxF

yxF

yxF

yxF

rowscols

*

_

...

3_

2_

1_

1),(

......

1),(

1),(

1),(

33

22

11

solution = links\Forces_y; m = solution(1, 1); t = solution(2, 1);

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

links Forces_y solution


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.


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.


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

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

t0 t1 t2 t3 t4


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 amF *= (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


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.

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

t1 t2


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 pF &= , d.h. die Kraft ist die Ableitung des Impulses nach der

Zeit. Integriert man diese Gleichung nach der Zeit, erhält man

∫ −=2

1

12)(t

t

ppdttF , d.h. die Impulsänderung ist das Integral der Kraft über die

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.

Diagramm 4-4: Zeit-Kraft-Verlauf aller gemessenen Impulse

In

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: dycxbyaQ +++= **)*(

Gleichung für zweiten Sensor: hygxfyeW +++= **)*(

Nach x aufgelöste Gleichung:

)(2

))((4)²(

afbe

dgchcQgWafbecfdeeWbgahaQcfdeeWbgahaQx

−+−+−−−−+−+−++−+−+−

=

Nach y aufgelöste Gleichung:

)(2

))((4)²(

ceag

dffWbQbhceagcfahaQbgdeeWcfahaQbgdeeWy

−−+−−−−+−+−++−+−+−

=

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


berechneten x-Koordinaten immer weiter gestreut, da durch den weiteren Weg

zum Sensor die am Sensor gemessene Kraft immer mehr verfälscht wird.

Diagramm 5-1: x-Abweichungen Messung - Funktion aus ul-ur

Diagramm 5-2: y-Abweichungen Messung - Funktion aus ul-ur

Abweichungen Messung<->Funktion aus ul-ur

-10

10

30

50

70

90

110

90 100 110 120 130 140 150 160 170 180

Platte Y

Pla

tte X X-Mess

X-Funktion

ur

ul

Abweichungen Messung<->Funktion aus ul-ur

90

110

130

150

170

190

0 10 20 30 40 50 60 70 80

Platte X

Pla

tte Y Y-Mess

Y-Funktion

ur ul


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.

Diagramm 5-3: prozentuale y-Abweichungen dreidimensional

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)

8

28

48

6899 109 119 129 139 149 159 169 179

-4

-3

-2

-1

0

1

2

3

4

5

6

%

Ort horizontal

Ort vertikal

y-Abweichung Messwert <-> Funktion aus ul-ur

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:

=

),(...),(

.........

),(...),(

*

),(...),(

.........

),(...),(

212

12112

111

11111

rowscolsrows

cols

rowscolsrows

cols

yxFyxF

yxFyxF

const

yxFyxF

yxFyxF

Da dies bei einem einzelnen Sensor zutrifft, gilt dies auch für die Summe aller

Sensoren an einem Messpunkt:

constF

F

F

F

Sensor

Sensor ==Σ−

Σ−

−

−

2

1

22

11

Der Programmablauf ist nun folgender: die Ortsberechnung ist für einen

bestimmten Kraftwert Σ−0F definiert. Zuerst wird die Summe aller Sensorwerte an

einem Messpunkt Σ−1F berechnet, die Kraft die an diesem Punkt auf den Sensor

einwirkt ist 1F . Gesucht ist der Kraftwert 0F , der auf dem gleichen Punkt wie 1F

bei einer Gesamtkraft von Σ−0F auf den Sensor einwirken würde. Aus der oberen

Gleichung ergibt sich für 0F :

11

00 * F

F

FF

Σ−

Σ−=

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 vert ikaler 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):

2211 **)*( tymxtymF +++=

Die quadratische Funktion (Verlauf horizontal linear, vertikal quadratisch):

fyeydxcybyaF +++++= *²**)*²*(

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:

665544332211 ****** FaFaFaFaFaFax +++++=

665544332211 ****** FbFbFbFbFbFby +++++=

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.4 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

6.

5.4 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.

6.

7.1 Anhang - Abbildungsverzeichnis 59

7. Anhang

7.1. Abbildungsverzeichnis

Abbildungen

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-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-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 = [];


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).nam e ' ' 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 ; 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(fullfile name); Header.FilePath = fpath; save(hfilename, 'Header' ) end else , Header = TransformDiademToMat(fullfilen ame); 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(Mes s)>1500)+1)]; end end % Ende vorgefertigter Quelltext % ################################################# #################### % Schreiben der Daten der einzelnen Kanäle zu den v orher gefundenen


% 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, Me ss(j, 1)+500, 5000); koordinaten(row, 1) = mean(Ynew ); case 'Y' [Ynew, Xnew] = GetDiaData(i, Me ss(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] = GetDiaDa ta(i, Mess(j, 1), 500); offset = []; offset = mean(Y_offset); % Offset = Mittelwert auf Intervall % Ynew: Matrix mit Aplituden der Messung [Ynew, Xnew] = GetDiaData(i, Me ss(j, 1)+500, 5000); % Offsetkorrektur amplitudes_ll(size(amplitudes_l l, 1)+1, :) = Ynew - offset; case 'ForceIn_lr' [Y_offset, X_offset] = GetDiaDa ta(i, Mess(j, 1), 500); offset = []; offset = mean(Y_offset); [Ynew, Xnew] = GetDiaData(i, Me ss(j, 1)+500, 5000); amplitudes_lr(size(amplitudes_l r, 1)+1, :) = Ynew - offset; case 'ForceIn_ul' [Y_offset, X_offset] = GetDiaDa ta(i, Mess(j, 1), 500); offset = [];


offset = mean(Y_offset); [Ynew, Xnew] = GetDiaData(i, Me ss(j, 1)+500, 5000); amplitudes_ul(size(amplitudes_u l, 1)+1, :) = Ynew - offset; case 'ForceIn_ur' [Y_offset, X_offset] = GetDiaDa ta(i, Mess(j, 1), 500); offset = []; offset = mean(Y_offset); [Ynew, Xnew] = GetDiaData(i, Me ss(j, 1)+500, 5000); amplitudes_ur(size(amplitudes_u r, 1)+1, :) = Ynew - offset; case 'ForceIn_ml_i(5)' [Y_offset, X_offset] = GetDiaDa ta(i, Mess(j, 1), 500); offset = []; offset = mean(Y_offset); [Ynew, Xnew] = GetDiaData(i, Me ss(j, 1)+500, 5000); amplitudes_ml(size(amplitudes_m l, 1)+1, :) = Ynew - offset; case 'ForceIn_mr_i(6)' [Y_offset, X_offset] = GetDiaDa ta(i, Mess(j, 1), 500); offset = []; offset = mean(Y_offset); [Ynew, Xnew] = GetDiaData(i, Me ss(j, 1)+500, 5000); amplitudes_mr(size(amplitudes_m r, 1)+1, :) = Ynew - offset; case 'ForceMagIn' [Y_offset, X_offset] = GetDiaDa ta(i, Mess(j, 1), 500); offset = []; offset = mean(Y_offset); [Ynew, Xnew] = GetDiaData(i, Me ss(j, 1)+500, 5000); amplitudes_mag_f(size(amplitude s_mag_f, 1)+1, :) = Ynew - offset; case 'HubMagIn' [Y_offset, X_offset] = GetDiaDa ta(i, Mess(j, 1), 500);


offset = []; offset = mean(Y_offset); [Ynew, Xnew] = GetDiaData(i, Me ss(j, 1)+500, 5000); amplitudes_mag_in(size(amplitud es_mag_in, 1)+1, :) = Ynew - offset; end end row = row + 1; end end hold on; for n = 1:size(amplitudes_ll, 1) % Suchen des Messpunktes mit der höchsten Amplitude maximum = [max(max(amplitudes_ll(n, :))), max(m ax(amplitudes_lr(n, :))), max(max(amplitudes_ml(n, :))), max(max(amplitudes_mr(n, :))), max(max(amplitudes_u l(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 de m Kraftanstieg x1_1 = 50; % Startwert 50 [ms], kurz vor dem Kraftanstieg % Suchen des 1. HOP while value(x1_1) <= value(x1_1+1) % Wird so lange weitergezählt, bis der Kraftwert ei ne [ms] kleiner als der aktuelle ist x1_1 = x1_1 + 1; % x1_1 ist die Position des 1. HOP end % Suchen des TIP nach dem 1. HOP x1_2 = x1_1; % Startwert ist der 1. HOP while value(x1_2) >= 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 Ma trix 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äc hsten 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 vo r 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_1-1) x2_1 = x2_1 - 1; % x2_1 ist die Position des letzten HOP vor dem Kra ftabfall end % Suchen des 1. TIP vor dem Minimum x2_2 = x2_1;


while value(x2_2) >= value(x2_2-1) x2_2 = x2_2 - 1; % x2_1 ist die Position des letzten TIP vor dem Kra ftabfall 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ähe sten 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' ); i_end = i_end + x1_1 - 1; % Berehnung des Impulses impuls = sum(summe(i_start:i_end)); % Integrieren des Impulses mit den vorher gefundene n 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_m ag_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;


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.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_mes sungen_korrigiert.xls' ); % Gemessene Kraftwerte RVor = xlsread( 'D:\Pfaller\Auswertung\excel\statisch_RVor_neue_mes sungen_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] (sor tiert 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


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 b ereits Offset-korrigiert 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 Sens ors % Kraftwert = Messwert - Ruhe_vor ForceIn(:, 2 + sen) = Mess(:, 2 + sen) - RVor(: , 2 + sen); % Bilden der Summe der Kraftsensorwerte für jeden M esspunkt ForceIn(:, sensors + 3) = ForceIn(:, sensors + 3) + ForceIn(:, 2 + sen); end % Erstellen einer Spalte mit den angebrachten Kraft werten for c = 1:forces:(rows * cols * forces) for n = 1:forces;


ForceIn(c+n-1, sensors + 4) = forces_v(1, n ); end end % Erstellen von dreidimensionalen Wertetabellen für jeden Sensor und die % Summe der Kräfte, in Abhängigkeit des Ortes, jewe ils 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)) * fo rces; x_wert = ForceIn(reihe, 1); y_wert = ForceIn(reihe, 2); Werte(1 + n, i + m) = x_wert; % X Werte(j + n, 1 + m) = y_wert; % Y Werte(j + n, i + m) = ForceIn((reih e - 4 + f), 2 + sen); % Daten end end end end % Exportieren der offsetkorrigierten Messwerte alle r 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 je den Sensor und für jede Kraft for sen = 1:(sensors + 1)


for f = 1:forces 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 Stri ng end % (notwendig für richtige Sortierung der Dateien un ter Windows) if sen == (sensors + 1) % Wenn der Sensorzähler um 1 größer ist als die Anz ahl der Sensoren Sen_str = 'ges' ; % enthält 'matrix' die Summe der Sensorwerte -> 'ge s' 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, 'Tabel le1'); end end % Erzeugt ein Diagramm mit den Summen der Sensorwer te jedes Messpunktes in % Abhängigkeit der angebrachten Kraft und erzeugt e ine Ausgleichsgerade: % Kraft(Sensorwert) = m * Sensorwert + t hold off ;


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


t_string = '' ; % Erzeugt einen leeren String, falls 't' 0 ist end 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 Se nsorwerte' ); % Diagrammtitel % Zeigt die Geradengleichung im Diagramm an (Poisti on 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))+5 00)]); 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-Wer t) 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;


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];


print ( '-dpng' , filename); hold off ; end end % ################################################# ######################## % #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, '.-' ];


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]); if forces_v(force_nr) < 1000 F = [ '0' F]; end filename = [ 'force_horizontal_y=' y '_' F]; print ( '-dpng' , filename); hold off ; end end % ################################################# ######################## % #3: horizontal pro Sensor % Plottet für jeden Sensor und jede Kraft ein Diagr amm mit den Sensorwerten


% in Abhängigkeit von x (für alle verschieden y) % Löscht die Werte des vorhergehenden Plots (wichti g wenn: Länge(alter Plot) > Länge(neuer Plot) -> al te 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, sola nge '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 + fo rce_nr + row_nr - 2, 1); % Schreibt x-Werte in die Plot-Matrix Plot (row, 2) = ForceIn (n + fo rce_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 u m den selben Wert, % bis sie beim letzten Durchlauf den Wert 1 erreich en 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);


string = [ 'y=' num2str(ForceIn(row_nr, 2))]; % Erzeugt einen String string "y=[aktuelles y]" data(count, 1:length(string)) = str ing; % Erzeugt eine Matrix mit allen y der Messung count = count + 1; end 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 Sensorname n title([ 'Gemessene Kraft in Abhängigkeit von x (bei verschi edenen 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


% ################################################# ######################## % #4: vertikal pro Sensor % Plottet für jeden Sensor und jede Kraft ein Diagr amm mit den Sensorwerten % in Abhängigkeit von y (für alle verschieden x) clear Plot ; % Löscht die Werte des vorhergehenden Plots (wichti g wenn: Länge(alter Plot) > Länge(neuer Plot) -> alte Werte am Ende der Matrix werden nicht durch ne ue 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, sola nge '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 + fo rce_nr + col_nr - 2, 2); % Schreibt y-Werte in die Plot-Matrix Plot (row, 2) = ForceIn (n + fo rce_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 * forc es)); % Erstellt bei jedem Durchlauf einen Wert index = ] 0; 1]. % Die indizes vergrößern sich bei jedem Durchlauf u m den selben Wert, % bis sie beim letzten Durchlauf den Wert 1 erreich en 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); string = [ 'x=' num2str(ForceIn(col_nr, 1))]; % Erzeugt einen String string "x=[aktuelles x]" data(count, 1:length(string)) = str ing; % Erzeugt eine Matrix mit allen x der Messung count = count + 1; end 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 Sensorname n title([ 'Gemessene Kraft in Abhängigkeit von y (bei verschi edenen 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


% ################################################# ######################## % #5: vertikal pro Sensor Funktion % Plottet für jeden Sensor und jede Kraft ein Diagr amm mit % Ausgleichsgeraden aus den Sensorwerten in Abhängi gkeit von y (für alle verschieden x) % % Hier nicht sinnvoll, da eine lineare Näherung nic ht möglich ist! % % Löscht die Werte des vorhergehenden Plots (wichti g wenn: Länge(alter Plot) > Länge(neuer Plot) -> al te 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, sola nge '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, col_nr * 2 - 1) = Fo rceIn (n + force_nr + col_nr - 2, 2); % Schreibt y-Werte in die Plot-Matrix Plot (row, col_nr * 2) = ForceI n (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 * forc es)); % Erstellt bei jedem Durchlauf einen Wert index = ] 0; 1].


% Die indizes vergrößern sich bei jedem Durchlauf u m den selben Wert, % bis sie beim letzten Durchlauf den Wert 1 erreich en 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 G leichungssystems 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"


plot(x, y, 'Marker' , marker, 'LineStyle' , line, 'Color' , color, 'MarkerEdgeColor' , color, 'MarkerFaceColor' , color, 'LineWidth' , l_size, 'MarkerSize' , m_size); % 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)) = str ing; % Erzeugt eine Matrix mit allen x der Messung count = count + 1; end 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(:, c ol_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 W indows richtig sortiert werden) F = [ '0' F]; end s = char(sensors_v(1, sen)); % Erzeugt einen String mit dem aktuellen Sensorname n % Setzt den Titel des Diagramms title([ 'Gemessene Kraft in Abhängigkeit von y (bei verschi edenen x) an Sensor ' s '; F=' F]); axis ([0, y_max, F_min, F_max]); % Setzt Minimum und Maximum der x- und y-Achse


filename = [ 'force_vertikal_' s '_' F '_fx' ]; % Erzeugt einen String für den Dateinamen print ( '-dpng' , filename); % Exportiert eine .png-Bilddatei hold off ; % Deaktiviert hold end end % ################################################# ######################## % #6: horizontal pro Sensor Funktion % Plottet für jeden Sensor und jede Kraft ein Diagr amm mit % Ausgleichsgeraden aus den Sensorwerten in Abhängi gkeit von x (für alle verschieden y) Plot = []; % Löscht die Werte des vorhergehenden Plots % (wichtig wenn: Länge(alter Plot) > Länge(neuer Pl ot) % -> alte Werte am Ende der Matrix werden nicht dur ch 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, sola nge '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, row_nr * 2 - 1) = Fo rceIn (n + force_nr + row_nr - 2, 1); % Schreibt x-Werte in die Plot-Matrix Plot (row, row_nr * 2) = ForceI n (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 u m den selben Wert, % bis sie beim letzten Durchlauf den Wert 1 erreich en 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 G leichungssystems 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);


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); % 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 Matr ix data_file(count, 1:length(string_fi le)) = string_file; string = [ 'y=' num2str(ForceIn(row_nr, 2))]; % Erzeugt einen String string "y=[aktuelles y]" = L egende für eine Spalte data(count, 1:length(string)) = str ing; % 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


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 W indows richtig sortiert werden) F = [ '0' F]; end s = char(sensors_v(1, sen)); % Erzeugt einen String mit dem aktuellen Sensorname n title([ 'Gemessene Kraft in Abhängigkeit von x (bei verschi edenen 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 i n einer .txt-Textdatei hold off ; % Deaktiviert hold end end % ################################################# ######################## % Graphische Darstellung der oben erstellten (dreid imensionalen) Wertetabellen, Export als .jpeg-Bildd atei for sen = 1:(sensors + 1)


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 Stri ng end % (notwendig für richtige Sortierung der Dateien un ter Windows) if sen == (sensors + 1) % Wenn der Sensorzähler um 1 größer ist als die Anz ahl der Sensoren Sen_str = 'ges' ; % enthält 'matrix' die Summe der Sensorwerte -> 'ge s' 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 dreidi mensionalen Plot [X, Y] = meshgrid(matrix(1, 2:(cols+1)), ma trix(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


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 d er jeweiligen Kraft als jpeg-Bilddatei print ( '-djpeg100' , filename); end end


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).nam e ' ' 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 ; 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(fullfile name); Header.FilePath = fpath; save(hfilename, 'Header' ) end else , Header = TransformDiademToMat(fullfilen ame); 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 'Mess_1' [amplitude, xnew] = GetDiaData(i, 0 , Header.Channel(i).Length); Mess = (find(diff(amplitude)>0.5) + 1); Mess = [Mess(1); Mess(find(diff(Mes s)>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(RVo r)>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, Me ss(j, 1), 1000); amplitudesMess(j, 1) = 0; amplitudesMess(j, 2) = mean(Yne w); case 'Y' [Ynew, Xnew] = GetDiaData(i, Me ss(j, 1), 1000); amplitudesMess(j, 3) = mean(Yne w); case 'ForceIn_ll' [Ynew, Xnew] = GetDiaData(i, Me ss(j, 1), 1000); amplitudesMess(j, 4) = mean(Yne w); case 'ForceIn_lr' [Ynew, Xnew] = GetDiaData(i, Me ss(j, 1), 1000); amplitudesMess(j, 5) = mean(Yne w);


case 'ForceIn_ul' [Ynew, Xnew] = GetDiaData(i, Me ss(j, 1), 1000); amplitudesMess(j, 6) = mean(Yne w); case 'ForceIn_ur' [Ynew, Xnew] = GetDiaData(i, Me ss(j, 1), 1000); amplitudesMess(j, 7) = mean(Yne w); case 'ForceIn_ml_i(5)' [Ynew, Xnew] = GetDiaData(i, Me ss(j, 1), 1000); amplitudesMess(j, 8) = mean(Yne w); case 'ForceIn_mr_i(6)' [Ynew, Xnew] = GetDiaData(i, Me ss(j, 1), 1000); amplitudesMess(j, 9) = mean(Yne w); end end end for j = 1:size(RVor, 1) for i = 1:Header.NChannels, switch Header.Channel(i).Name case 'X' [Ynew, Xnew] = GetDiaData(i, RV or(j, 1), 1000); amplitudesRVor(j, 1) = -1; amplitudesRVor(j, 2) = mean(Yne w); case 'Y' [Ynew, Xnew] = GetDiaData(i, RV or(j, 1), 1000); amplitudesRVor(j, 3) = mean(Yne w); case 'ForceIn_ll' [Ynew, Xnew] = GetDiaData(i, RV or(j, 1), 1000); amplitudesRVor(j, 4) = mean(Yne w); case 'ForceIn_lr' [Ynew, Xnew] = GetDiaData(i, RV or(j, 1), 1000); amplitudesRVor(j, 5) = mean(Yne w);


case 'ForceIn_ul' [Ynew, Xnew] = GetDiaData(i, RV or(j, 1), 1000); amplitudesRVor(j, 6) = mean(Yne w); case 'ForceIn_ur' [Ynew, Xnew] = GetDiaData(i, RV or(j, 1), 1000); amplitudesRVor(j, 7) = mean(Yne w); case 'ForceIn_ml_i(5)' [Ynew, Xnew] = GetDiaData(i, RV or(j, 1), 1000); amplitudesRVor(j, 8) = mean(Yne w); case 'ForceIn_mr_i(6)' [Ynew, Xnew] = GetDiaData(i, RV or(j, 1), 1000); amplitudesRVor(j, 9) = mean(Yne w); end end j = j+1; end for j = 1:size(RNach, 1), for i = 1:Header.NChannels, switch Header.Channel(i).Name case 'X' [Ynew, Xnew] = GetDiaData(i, RN ach(j, 1), 1000); amplitudesRNach(j, 1) = 1; amplitudesRNach(j, 2) = mean(Yn ew); case 'Y' [Ynew, Xnew] = GetDiaData(i, RN ach(j, 1), 1000); amplitudesRNach(j, 3) = mean(Yn ew); case 'ForceIn_ll' [Ynew, Xnew] = GetDiaData(i, RN ach(j, 1), 1000); amplitudesRNach(j, 4) = mean(Yn ew); case 'ForceIn_lr' [Ynew, Xnew] = GetDiaData(i, RN ach(j, 1), 1000); amplitudesRNach(j, 5) = mean(Yn ew);


case 'ForceIn_ul' [Ynew, Xnew] = GetDiaData(i, RN ach(j, 1), 1000); amplitudesRNach(j, 6) = mean(Yn ew); case 'ForceIn_ur' [Ynew, Xnew] = GetDiaData(i, RN ach(j, 1), 1000); amplitudesRNach(j, 7) = mean(Yn ew); case 'ForceIn_ml_i(5)' [Ynew, Xnew] = GetDiaData(i, RN ach(j, 1), 1000); amplitudesRNach(j, 8) = mean(Yn ew); case 'ForceIn_mr_i(6)' [Ynew, Xnew] = GetDiaData(i, RN ach(j, 1), 1000); amplitudesRNach(j, 9) = mean(Yn ew); end end j = j+1; end 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', 'Fo rceIn_ul', 'ForceIn_ur', 'ForceIn_ml', 'ForceIn_mr'}, 'statisc h_y72_Mess', 'Tabelle1')


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 Grenz en) zur linearen % optimierung n = 1; for i = 2:(rows+1) if mess_lower(i, 1) <= grenze1 for j = 2:(cols+1) xdata_lin(1, n) = mess_lower(1, j); ydata_lin(1, n) = mess_lower(i, 1); zdata_lin(1, n) = mess_lower(i, j); n = n+1; end end end


data_lin = [xdata_lin; ydata_lin]; a0 = zeros(1, 4); % Geratene Startwerte % Optimierung der Funktion pfaller_gleichung_lin mi t den Daten aus data_lin a = lsqcurvefit(@pfaller_gleichung_lin, a0, data_li n, zdata_lin) % Erzeugen einer Wertetabelle (mit den oberen Grenz en) zur polynomischen % optimierung n = 1; for i = 2:(rows+1) if mess_lower(i, 1) >= grenze1 && mess_lower(i, 1) <= grenze2 for j = 2:(cols+1) xdata_pol(1, n) = mess_lower(1, j); ydata_pol(1, n) = mess_lower(i, 1); zdata_pol(1, n) = mess_lower(i, j); n = n+1; end end end data_pol = [xdata_pol; ydata_pol]; a0 = zeros(1, 6); % Geratene Startwerte % Optimierung der Funktion pfaller_gleichung_pol mi t den Daten aus data_pol b = lsqcurvefit(@pfaller_gleichung_pol, a0, data_po l, zdata_pol) % Berechnung der Funktionswerte mit den gefundenen Gleichungskoeffizienten % linearer Teil for i = 2:(rows+1) if mess_lower(i, 1) < grenze1 for j = 2:(cols+1) x = mess_lower(1, j); y = mess_lower(i, 1); Z(i-1, j-1) = pfaller_gleichung_lin(a, [x; y]); end


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); Z(i-1, j-1) = pfaller_gleichung_pol(b, [x; y]); end end end [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.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.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


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;


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 <= 139 % unten if x_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; 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; end end


% Erstellen der Matrizen zum Finden der Koeffizient en die für die gesamte obere Plattenhälfte gelten. % Mit ihnen wird später der vorläufige Ort berechne t 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; end end % 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


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 Koeffizien ten 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);


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);


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_l r;


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 <= 139 % unten if x_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 berec hnetem x im Betrag koordinaten(row, 7) = abs((koordinaten(row, 5) - koordinaten(row, 6)) * 100 / koordinaten(row, 5)); % Die prozentuale Differenz zwischen gemessenem und berec hnetem y im Betrag row = row+1; end end mittelwerte = mean(koordinaten); % Berechnung der Mittelwerte für jede Spalte koordinaten(row, 3) = mittelwerte(1, 3); 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 (b zw. Anzahl der gemessenen Reihen) % Umwandlung der Matrizen von Listenform in eine dr eidimensionaleWertetabelle 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 Differ enzen 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 <-> Me ssung X [%]' ); colorbar axis ([8 78 99 179 0 15]) print -djpeg100 linearkombination_abweichung_x_optimiert.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 <-> Me ssung Y [%]' ); colorbar axis ([8 78 99 179 0 15]) print -djpeg100 linearkombination_abweichung_y_optimiert.jpeg ; % Ausgabe der Matrizen in Listenform und als Wertet abelle 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-C alc', '|dX|%', '', 'Y-Mess', 'Y-Calc', '|dY|%'}, 'linearkombination_op timiert', 'Tabelle1'); % xlswrite(matrix_x, 'Linearkombination %-Abweichun gen x', {''}, 'linearkombination_abweichungen_x_opt imiert', 'Tabelle1'); % xlswrite(matrix_y, 'Linearkombination %-Abweichun gen y', {''}, 'linearkombination_abweichungen_y_opt imiert', 'Tabelle1'); % xlswrite(faktoren_gesamt, 'Koeffizienten der Line arkombinationen', {'x','x1','x2','x3','x4','','y','y1','y2','y3','y4' }, 'koeffizienten_optimiert', 'Tabelle1'); clear;


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, fak toren_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 = [];


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).nam e ' ' 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 ;


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(fullfile name); Header.FilePath = fpath; save(hfilename, 'Header' ) end else , Header = TransformDiademToMat(fullfilen ame); 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(Mes s)>1500)+1)]; end end


for j = 1:size(Mess, 1), for i = 1:Header.NChannels, switch Header.Channel(i).Name case 'X' [Ynew, Xnew] = GetDiaData(i, Me ss(j, 1)+500, 5000); koordinaten(row, 1) = mean(Ynew ); case 'Y' [Ynew, Xnew] = GetDiaData(i, Me ss(j, 1)+500, 5000); koordinaten(row, 2) = mean(Ynew ); case 'ForceIn_ll' [Y_offset, X_offset] = GetDiaDa ta(i, Mess(j, 1), 500); offset = []; offset(size(offset, 1)+1, :) = mean(Y_offset); [Ynew, Xnew] = GetDiaData(i, Me ss(j, 1)+500, 5000); amplitudes_ll(size(amplitudes_l l, 1)+1, :) = Ynew - offset; case 'ForceIn_lr' [Y_offset, X_offset] = GetDiaDa ta(i, Mess(j, 1), 500); offset = []; offset(size(offset, 1)+1, :) = mean(Y_offset); [Ynew, Xnew] = GetDiaData(i, Me ss(j, 1)+500, 5000); amplitudes_lr(size(amplitudes_l r, 1)+1, :) = Ynew - offset; case 'ForceIn_ul' [Y_offset, X_offset] = GetDiaDa ta(i, Mess(j, 1), 500); offset = []; offset(size(offset, 1)+1, :) = mean(Y_offset); [Ynew, Xnew] = GetDiaData(i, Me ss(j, 1)+500, 5000);


amplitudes_ul(size(amplitudes_u l, 1)+1, :) = Ynew - offset; case 'ForceIn_ur' [Y_offset, X_offset] = GetDiaDa ta(i, Mess(j, 1), 500); offset = []; offset(size(offset, 1)+1, :) = mean(Y_offset); [Ynew, Xnew] = GetDiaData(i, Me ss(j, 1)+500, 5000); amplitudes_ur(size(amplitudes_u r, 1)+1, :) = Ynew - offset; case 'ForceIn_ml_i(5)' [Y_offset, X_offset] = GetDiaDa ta(i, Mess(j, 1), 500); offset = []; offset(size(offset, 1)+1, :) = mean(Y_offset); [Ynew, Xnew] = GetDiaData(i, Me ss(j, 1)+500, 5000); amplitudes_ml(size(amplitudes_m l, 1)+1, :) = Ynew - offset; case 'ForceIn_mr_i(6)' [Y_offset, X_offset] = GetDiaDa ta(i, Mess(j, 1), 500); offset = []; offset(size(offset, 1)+1, :) = mean(Y_offset); [Ynew, Xnew] = GetDiaData(i, Me ss(j, 1)+500, 5000); amplitudes_mr(size(amplitudes_m r, 1)+1, :) = Ynew - offset; case 'ForceMagIn' [Y_offset, X_offset] = GetDiaDa ta(i, Mess(j, 1), 500); offset = []; offset(size(offset, 1)+1, :) = mean(Y_offset); [Ynew, Xnew] = GetDiaData(i, Me ss(j, 1)+500, 5000); amplitudes_mag_f(size(amplitude s_mag_f, 1)+1, :) = Ynew - offset; case 'HubMagIn' [Y_offset, X_offset] = GetDiaDa ta(i, Mess(j, 1), 500); offset = []; offset(size(offset, 1)+1, :) = mean(Y_offset);


[Ynew, Xnew] = GetDiaData(i, Me ss(j, 1)+500, 5000); amplitudes_mag_in(size(amplitud es_mag_in, 1)+1, :) = Ynew - offset; end end row = row + 1; end end hold on; for n = 1:size(amplitudes_ll, 1) % Suchen des Messpunktes mit der höchsten Amplitude maximum = [max(max(amplitudes_ll(n, :))), max(m ax(amplitudes_lr(n, :))), max(max(amplitudes_ml(n, :))), max(max(amplitudes_mr(n, :))), max(max(amplitudes_u l(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 de m Kraftanstieg x1_1 = 50; % Startwert 50 [ms], kurz vor dem Kraftanstieg % Suchen des 1. HOP


while value(x1_1) <= value(x1_1+1) % Wird so lange weitergezählt, bis der Kraftwert ei ne [ms] kleiner als der aktuelle ist x1_1 = x1_1 + 1; % x1_1 ist die Position des 1. HOP end % Suchen des TIP nach dem 1. HOP x1_2 = x1_1; % Startwert ist der 1. HOP while value(x1_2) >= 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 Ma trix 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äc hsten 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 vo r 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_1-1) x2_1 = x2_1 - 1; % x2_1 ist die Position des letzten HOP vor dem Kra ftabfall end % Suchen des 1. TIP vor dem Minimum x2_2 = x2_1; while value(x2_2) >= value(x2_2-1) x2_2 = x2_2 - 1; % x2_1 ist die Position des letzten TIP vor dem Kra ftabfall 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ähe sten 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' );


i_end = i_end + x1_1 - 1; % Berehnung des Impulses impuls = sum(summe(i_start:i_end)); % Integrieren des Impulses mit den vorher gefundene n 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_m ag_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


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 ;


% Berechnen, welcher Kraft die aktuelle Kraft bei e iner 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_l r; % 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_l r; % 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 auswertung(row, 11) = (F_ges * m + t) / 1000 * 9,81; end 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


xlswrite( 'linearkombination_einfach_neu' , auswertung); % xlswrite(auswertung, 'Vergleich Ort: Messung <-> Berechnung aus Linearkombination', {'X-Mess', 'X-Ca lc', '|dX|%', '', 'Y-Mess', 'Y-Calc', '|dY|%', '', 'Impuls [Ns]', '', 'Kraft [N]'}, 'linearkombination_einfach_neu', 'Ta belle1');


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_m r1, F_ll1, F_lr1


% F_ul2, F_ur2, F_ml2, F_m r2, 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;


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; end end faktoren_x = koeffizienten\rechts_x; faktoren_y = koeffizienten\rechts_y; % Ortsberechnung mit den oben gefundenen Koeffizien ten 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);


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 berec hnetem 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 berec hnetem y im Betrag row = row+1; end end mittelwerte = mean(koordinaten); % Berechnung der Mittelwerte für jede Spalte koordinaten(row, 3) = mittelwerte(1, 3);


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 (b zw. Anzahl der gemessenen Reihen) % Umwandlung der Matrizen von Listenform in eine dr eidimensionaleWertetabelle 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 Differ enzen 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 <-> Me ssung 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 <-> Me ssung Y [%]' ); colorbar % axis ([8 78 99 179 0 15]) print -djpeg100 linearkombination_abweichung_y_neu.jpeg ; % Ausgabe der Matrizen in Listenform und als Wertet abelle 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-C alc', '|dX|%', '', 'Y-Mess', 'Y-Calc', '|dY|%'}, 'linearkombination_ei nfach_neu', 'Tabelle1'); % xlswrite(matrix_x, 'Linearkombination %-Abweichun gen x', {''}, 'linearkombination_abweichungen_x_neu ', 'Tabelle1'); % xlswrite(matrix_y, 'Linearkombination %-Abweichun gen y', {''}, 'linearkombination_abweichungen_y_neu ', 'Tabelle1');


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


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*Q-c*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*W-f*d)))/(2*(a*g-e*c)); m = m+1; end end xlswrite( 'berechnung-ul_ur' , koordinaten_ur_ul) % xlswrite(koordinaten_ur_ul, 'Vergleich Ort: Messu ng <-> 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


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*Q-c*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*W-f*d)))/(2*(a*g-e*c)); n = n+1; end end xlswrite( 'berechnung-ml_mr' , koordinaten_mr_ml) % xlswrite(koordinaten_mr_ml, 'Vergleich Ort: Messu ng <-> 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-Funk tion'}, 'berechnung-mittelwerte', 'Tabelle1')


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


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 Reih en cols = size(ForceIn_ul, 1) - 1;


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 vor her 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]); % Unterteilung der Platte in vier Felder % Ortsberechnung durch verschiedene Sensoren, je na ch 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) + n 2 * V(2) + u2 - F_ur]; H = @(V) [(m3 * V(2) + t3) * V(1) + n3 * V(2) + u3 - F_ml; (m1 * V(2) + t1) * V(1) + n 1 * V(2) + u1 - F_ul]; 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) + n 4 * V(2) + u4 - F_mr]; H = @(V) [(m3 * V(2) + t3) * V(1) + n3 * V(2) + u3 - F_ml; (m1 * V(2) + t1) * V(1) + n 1 * V(2) + u1 - F_ul]; end


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) + n 2 * V(2) + u2 - F_ur]; H = @(V) [(m4 * V(2) + t4) * V(1) + n4 * V(2) + u4 - F_mr; (m2 * V(2) + t2) * V(1) + n 2 * V(2) + u2 - F_ur]; 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) + n 4 * V(2) + u4 - F_mr]; H = @(V) [(m4 * V(2) + t4) * V(1) + n4 * V(2) + u4 - F_mr; (m2 * V(2) + t2) * V(1) + n 2 * V(2) + u2 - F_ur]; end end 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;


end end koordinaten(row, 3) = mean(abs(koordinaten(:, 1)-ko ordinaten(:, 3))); % durchschnittliche Abweichung x koordinaten(row, 4) = mean(abs(koordinaten(:, 2)-ko ordinaten(:, 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 drei diemsionale 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-Funk tion', '|dX|%', '|dY|%'}, 'berechnung_ranking', 'Tabelle1'); % xlswrite(matrix_x, '%-Abweichungen x', {''}, 'abw eichungen_x', 'Tabelle1'); % xlswrite(matrix_y, '%-Abweichungen y', {''}, 'abw eichungen_y', 'Tabelle1');


% 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 ;

Analyse von Kraftsensor-Messwerten mit MATLAB zur Orts ... · 2.1 Einführung - Aufbau und Funktion...

Documents

Transcript of Analyse von Kraftsensor-Messwerten mit MATLAB zur Orts ... · 2.1 Einführung - Aufbau und Funktion...