Wie die Schnittgerade zweier Ebenen berechnen.

[Bensch]

Hallo zusammen,

ich programmiere grade eine Rückwärtskinematik für einen "Delta"-Roboter, hier ein Youtube-Video (http://www.youtube.com/watch?v=6DUuzecAtXQ&feature=channel_page) zur verdeutlichung.

Um die Winkel zu finden, auf welche die Oberen Armteile eingestellt werden (relativ zu der Ebene, in der der Bot montiert ist), muss ich den Ort kennen, an dem das Armgelenk sich befindet. Dieser Ort liegt auf einer Schnittgeraden zweier Ebenen E1 und E2.

Die Ebene E1 berechne ich aus dem Schnitt zweier Kugeln, weshalb diese in Koordinatenform vorliegt.

Von der Ebene E2 sind 3 Punkte bekannt, sie liegt also in Parameterform vor.

Wie berechne ich nun am schnellsten die Schnittgrade der Ebenen? Ich Programmiere in BASCOM-Basic für einen AtMega32.

Beste Grüße aus Düsseldorf,

Benjamin

[vohopri]

Hallo Ben,

fertige Formel hab ich jetzt auch keine zur Hand, aber vor solchen Aufgaben bin ich bei der CAD - Programmmierung auch schon öfter gestanden.

Ich zeichne mir das immer mit Bleistift auf, da sieht man sofort die Zusammenhänge. Gleichungssystem lösen und dabei Lösung auf minimale Rechenoprationen optimieren.

Da kommt schnellerer Code raus, als bei allgmeinen Lösungen.

grüsse,
Hannes

[cipher]

Hi!

Das Stichwort nennt sich Hesseform einer Ebene. Die Ebene wird dabei durch einen Punkt und zwei Vektoren beschrieben. Die Ebenengleichung lautet dabei:

Q = P + a * r + b * t

P, r und t beschreiben die Ebene (P ist Punkt, r und t sind linear unabhängige Vektoren), a und b sind Faktoren, mit denen jeder Punkt Q auf der Ebene ermittelt werden kann.

Um die Schnittgerade zweier Ebenen zu bestimmen einfach für beide Ebenen die Gleichung aufstellen Q1 und Q2 (entspricht Q der obigen Gleichung für die jeweilige Ebene) gleichsetzen und das Gleichungssystem lösen. Lösung ist eine Gleichung der Form
S = T + c * v
(S, T sind Punkte, v ist der Richtungsvektor der Ebene, c ist ein Faktor)

Ich hoffe, das ist in aller kürze hilfreich.

Viele Grüße,
Markus

[Bensch]

Hallo Hannes,

vielen Dank für deine Antwort.
Ich werde mal verschiedene Methoden durchprobieren. Wenn was brauchbares dabei rumkommt, oder ich speziellere Frage habe, melde ich mich dann wieder ;)

Viele Grüße,

Benjamin

Edit:
Hallo Cypher,

auch dir vielen Dank.
Wie gesagt, ich experimentiere mal ein bischen rum.

[Bensch]

Ich bins nochmal ;)

Ich habe jetzt beide Ebenen, zunächst mal nur auf dem Papier, in Koordinatenform gebracht, einmal in der Form

E1: e*x + f*y +g = 0

(Diese Ebene steht immer senkrecht im Raum, deshalb fehlt hier der z-Anteil [z ist bei mir die Höhe])
und einmal in der Form

E2: a*x + b*y + c*z + d = 0

Wenn ich nun gleichsetze erhalte ich für die Schnittgrade G

G: (a-e)*x + (b-f)*y + c*z + (d-g) = 0

Die Gleichung hat also wieder die selbe Form wie eine Ebenengleichung. Kann das sein? Sind Ebenen und Geraden im Raum als Koordinatenform "durch scharfes hinsehen" nicht unterscheidbar? Merke ich das erst, wenn ich versuche zwei Richtungsvektoren zu erzeugen, und diese dann immer kolinear sind (bei der Geraden)?

[vohopri]

Hi Ben

Nein, das was du hast, ist keine Geradengleichung.

Entweder gehst du es mit Verktorgleichungen an, da gibts Wiki Artikel.
Oder du beschreibst die Gerade durch 2 Projezierte Geraden.

Den letzteren Weg verwende ich um schnellen Code (auf Kosten der Allgemeinheit ) zu erhalten.
Dein E1 ist schon die Projezierte in der xy-Ebene.
Wenn du nun in beiden Gleichungen y explizit darstellst und die Terme gleich setzt, bekommst du die Projezierte in der xz Ebene.

Aber mir fehlt jetzt die Info, was du mit der Geraden weiter anfangen willst.

grüsse,
Hannes




EDIT: Ich find jetzt kein Bild von deinem Aufbau, könntest du bitte Bild oder Link posten?

EDIT2: Es ist unverzeihlich, solche Fragestellungen zu posten. Seit einer halben Stunde denke ich an nichts anderes. Vor allem bewegt mich, dass mir noch nicht eingefallen ist, wie ich das rückwärts zeichnerisch lösen könnte. Vorwärts ist natürlich leicht und in der Algebra geht alles, was vorwärts funktioniert, auch rückwärts (naja fast alles).

Jedenfalls, wenn dein Aufbau, dem von radbruch ähnelt, dann habe ich schon eine Lösung, eine algebraische. Bei Interesse, stelle ich sie auch gerne dar.

[Bensch]

Hallo Hannes,

ich habe noch keinen Aufbau :D
Die Teile dafür sollten im Laufe der nächsten Woche bei mir eintreffen. Radbruch hat es aber von der Kinematik her exakt so umgesetzt, wie ich es vorhabe. In diesen Fred (https://www.roboternetz.de/phpBB2/viewtopic.php?t=45961) haben wir uns zusammengerottet ;)
Trotzdem wollte ich die Ansteuerung schonmal soweit wie möglich fertig machen. Konstruktionsmerkmale wie zB den Abstand der Arm-Anfänge vom Mittelpunkt des Bots habe ich als Variable implementiert, die kann ich nachträglich anpassen.

Mein Gedankengang zur Rückwärtskinematik ist folgender:
Gesucht ist der Winkel zwischen dem Oberen Armteil und der Ebene, in der der Bot befestigt ist (welche ich fix als parallele zur xy-Ebene definiert habe).
Um den Winkel zu finden, muss man den Ort des mittleren Armgelenkes ("Ellenbogen") kennen. Von diesem kenne ich folgende Eigenschaften:
- Abstand zum Anfang des Armes
- Abstand zum Ende des Armes (Ende des Armes ist abhängig von der zu erreichenden Koordinate)
- Liegt auf der Ebene E1, welche alle Punkte beinhaltet, die der "Ellenbogen" durch Rotation am Armanfangs-Gelenk erreichen kann.

Ich habe nun zwei Kugeln generiert, eine um den Armanfang, eine um das Armende, auf dessen Schnittkreis der Ellenbogen liegen muss. Der Schnittkreis liegt in Ebene E2, welche durch Gleichsetzen der Kugelgleichungen entstanden ist.

Das Gelenk muss also auf der Schnittgeraden von E1 und E2 liegen. Diese sei G.

Auf G finde man nun die Punkte, die zu Arm-Anfang und Arm-Ende mit den tatsächlichen Ausmaßen des Arms übereinstimmende Abstände haben. Von diesen ist nun jener zu Wählen, der vom Mittelpunkt der Konstruktion weiter entfernt ist (Damit der Arm nach aussen und nicht nach innen geknickt ist).

Ja, und nach G suche ich nun.

Falls du vor einem Herzinfarkt nicht zurückschreckst, kannst du dir auch gerne mal den Code anschauen, den ich mir bisher gebraut habe:




'************************************************* *****************************
'*** Delta-Ansteuerung3.BAS ***
'************************************************* *****************************
'*** ***
'*** Stellt eine Rückwärtskinematik für einen 3-Armigen Roboter nach ***
'*** Delta-Art zur Verfügung. ***
'*** ***
'*** Programm wurde für AtMega32 auf RN_Control V1.4 konzipiert. ***
'*** ***
'************************************************* *****************************
$regfile = "m32def.dat"
$framesize = 32
$swstack = 32
$hwstack = 32
$crystal = 16000000
$baud = 9600

'Für Tastenabfrage:
Config Adc = Single , Prescaler = Auto
Config Pina.7 = Input
Porta.7 = 1

'************************************************* *****************************
'*** Deklaration von Unterprogrammen ***
'************************************************* *****************************
Declare Function Tastenabfrage() As Byte
Declare Sub Update_ae()
Declare Sub Update_abst()
Declare Function Check_abst() As Byte
Declare Sub Update_ebene1()
Declare Sub Init_calc()
Declare Sub Clr_hilf()
Declare Sub Change_t()
Declare Sub Nix()

'************************************************* *****************************
'*** Deklaration von Variablen ***
'************************************************* *****************************
Dim Taste As Byte 'Für die Onboard-Tasten
Dim Abst_ok As Byte 'Für die Rückgabe von Check_abst()
Dim I As Integer
Dim J As Integer
Dim K As Integer
Dim Single_hilf(5) As Single 'Hilfsvariablen für Zwischenergebnisse
Dim Long_hilf(5) As Long

Dim B_x As Long 'Drei Koordinaten des Punktes B = Befestigungspunkt des Bots im Raum
Dim B_y As Long
Dim B_z As Long
Dim Oa As Long 'Länge des Servosnahen Armteils
Dim Ua As Long 'Länge des servofernen Armteils
Dim Abst_b_aa_xy As Long 'Abstand der Arm-Anfänge vom Befestigungspunkt B, gemessen in Projektion auf die xy-Ebene
Dim Abst_b_aa_z As Long 'Abstand der Arm-Anfänge vom Befestigungspunkt B, gemessen nur in z-Richtung
Dim Abst_t_ae_xy As Long 'Abstand der Arm-Enden vom Tool-Punkt T, gemessen in Projektion auf die xy-Ebene
Dim Abst_t_ae_z As Long 'Abstand der Arm-Enden vom Tool-Punkt T, gemessen nur in z-Richtung

Dim Aa_x(3) As Long 'x-Koordinate des Armanfangs für jeden Arm
Dim Aa_y(3) As Long 'y-Koordinate des Armanfangs für jeden Arm
Dim Aa_z(3) As Long 'z-Koordinate des Armanfangs für jeden Arm
Dim Ae_x(3) As Long 'x-Koordinate des Armendes für jeden Arm
Dim Ae_y(3) As Long 'y-Koordinate des Armendes für jeden Arm
Dim Ae_z(3) As Long 'z-Koordinate des Armendes für jeden Arm

Dim Abst_min As Long 'Minimaler Abstand, den Armanfang zu Armende haben muss
Dim Abst_max As Long 'Maximaler Abstand, den Armanfang zu Armende haben darf

Dim T_x As Long 'Drei Koordinaten des Punktes T = Tool-Punkt.
Dim T_y As Long 'Das ist der Punkt, des der Bot erreichen soll.
Dim T_z As Long

Dim Abst(3) As Long 'Abstand von Armanfang zu Armende für jeden Arm.

Dim D(12) As Single 'Parameter der Schnittebene E2. Siehe Dokumentation ######################### TODO: ERKLÄRUNG IN DOKU EINFÜGEN ###########################
Dim E(3) As Single 'Parameter der Ebene E1 zu jedem Arm. Die Ebene geht durch B, AA und [ B - (0,0,1) ]

'************************************************* *****************************
'*** Definition der Konstruktionsmerkmale ***
'************************************************* *****************************
'Nachfolgend werden die Konstruktionsmerkmale des Bots festgelegt. Die Bedeutung
'der Variablen ist bei der Deklaration kommentiert.

B_x = 0
B_y = 0
B_z = 0

Oa = 100000000 '=10cm
Ua = 200000000 '=20cm

Abst_b_aa_xy = 10000000 '=1cm
Abst_b_aa_z = 20000000 '=2cm
Abst_t_ae_xy = 20000000 '=2cm
Abst_t_ae_z = 10000000 '=1cm

'************************************************* *****************************
'************************************************* *****************************
'************************************************* *****************************
'*** Hauptprogramm ***
'************************************************* *****************************
'************************************************* *****************************
'************************************************* *****************************

Debug On 'Wenn ON, werden viele Zwischenergebnisse ausgegeben.
'Wenn OFF, werden nur Fehler ausgegeben

Call Init_calc
Print
Print "Gestartet"
Print "Tastenbelegung:"
Print "Taste1: Testweise den Punkt T ändern"
Print "Taste2: Armenden berechnen & Armabstaende berechnen"
Print "Taste3: Armabstaende pruefen"
Print "Taste4: Schnittebene berechnen"
Print "Taste5: Hilfsvariablen nullen"
Do
Taste = Tastenabfrage()
If Taste <> 0 Then
Select Case Taste
Case 1
Call Change_t
Case 2
Call Update_ae
Call Update_abst
Case 3
Abst_ok = Check_abst()
Case 4
Call Update_ebene1
Case 5
Call Clr_hilf
End Select
End If
Waitms 100
Loop
End

'************************************************* *****************************
'*** Unterprogramme ***
'************************************************* *****************************

'Fragt die Tastatur am analogen Port A.7 ab. Rückgabewert=Tastennummer(1...5)
Function Tastenabfrage() As Byte
Local Ws As Word
Tastenabfrage = 0
Start Adc
Ws = Getadc(7)
If Ws < 500 Then
Select Case Ws
Case 400 To 450
Tastenabfrage = 1
Case 330 To 380
Tastenabfrage = 2
Case 260 To 305
Tastenabfrage = 3
Case 180 To 220
Tastenabfrage = 4
Case 90 To 130
Tastenabfrage = 5
End Select
End If
End Function

'Generiert aus dem Toolpunkt T die Armendpunkte Ae
Sub Update_ae()
Debug "Update_ae() gestartet"
'Arm1
Ae_x(1) = T_x
Ae_y(1) = T_y + Abst_t_ae_xy
Ae_z(1) = T_z + Abst_t_ae_z
'Arm2
Single_hilf(1) = 0.866025403784435 '=Cos(30°)
Long_hilf(1) = Single_hilf(1) * Abst_t_ae_xy
Ae_x(2) = T_x - Long_hilf(1)
Long_hilf(2) = Abst_t_ae_xy / 2
Ae_y(2) = T_y - Long_hilf(2)
Ae_z(2) = T_z + Abst_t_ae_z
'Arm3
Ae_x(3) = T_x + Long_hilf(1)
Ae_y(3) = T_y - Long_hilf(2)
Ae_z(3) = T_z + Abst_t_ae_z
Debug "Armenden berechnet:"
Debug "Ae1: ( " ; Ae_x(1) ; " , " ; Ae_y(1) ; " , " ; Ae_z(1) ; ")"
Debug "Ae2: ( " ; Ae_x(2) ; " , " ; Ae_y(2) ; " , " ; Ae_z(2) ; ")"
Debug "Ae3: ( " ; Ae_x(3) ; " , " ; Ae_y(3) ; " , " ; Ae_z(3) ; ")"
End Sub
'################################################# ##############################


'Berechnet den Abstand von Armanfang zu Armende für jeden Arm.
'Die Formel ist der "verallgemeinerte Pythagoras".
Sub Update_abst()
Debug "Update_abst() gestartet"
For I = 1 To 3
Long_hilf(1) = Aa_x(i) - Ae_x(i)
Single_hilf(1) = Long_hilf(1) * Long_hilf(1)
Long_hilf(1) = Aa_y(i) - Ae_y(i)
Single_hilf(2) = Long_hilf(1) * Long_hilf(1)
Long_hilf(1) = Aa_z(i) - Ae_z(i)
Single_hilf(3) = Long_hilf(1) * Long_hilf(1)
Single_hilf(3) = Single_hilf(3) + Single_hilf(2)
Single_hilf(3) = Single_hilf(3) + Single_hilf(1)
Abst(i) = Sqr(single_hilf(3))
Next I
Debug "Abstände berechnet:"
Debug "Abst(1) = " ; Abst(1)
Debug "Abst(2) = " ; Abst(2)
Debug "Abst(2) = " ; Abst(3)
End Sub
'################################################# ##############################


'Prueft, ob der Abstand von Armanfang zu Armende zulaessig ist,
'also, ob der Bot diesen Ort erreichen kann. Wenn der Ort erreichbar ist,
'wird 3 zurückgegeben, sonst eine Zahl < 3.
Function Check_abst() As Byte
Debug "Check_abst() gestartet"
Debug "Abst_max = " ; Abst_max
Debug "Abst_min = " ; Abst_min

Check_abst = 0
I = 1
For I = 1 To 3
If Abst(i) < Abst_max And Abst(i) > Abst_min Then
Check_abst = Check_abst + 1
End If
Next I
Debug "Rueckgabewert: " ; Check_abst ;
Debug " (3=OK, weniger=Fehler)"
Debug "Check_abst beendet"
End Function
'################################################# ##############################


'Berechnet eine Ebenengleichung. In dieser Ebene muss das Armgelenk liegen.
'Die Ebenengleichung hat die Form D(j)*x + D(j+1)*y + D(j+2)*z - D(j+3) = 0
'wobei für Arm1 J=1, für Arm2 J=5 und für Arm3 J=9 gilt.
'Alle drei Ebenen liegen nachher im Array D(12) vor.
Sub Update_ebene1()
Debug "Update_ebene1() gestartet"
If Abst_ok = 3 Then
Debug "Ebenendaten werden berechnet."
I = 1
J = 1
Gosub Berechne_ebene1
I = 2
J = 5
Gosub Berechne_ebene1
I = 3
J = 9
Gosub Berechne_ebene1
Debug "Ebenendaten berechnet"
Debug "Ebene1(1): " ; D(1) ; " , " ; D(2) ; " , " ; D(3) ; " , " ; D(4)
Debug "Ebene1(2): " ; D(5) ; " , " ; D(6) ; " , " ; D(7) ; " , " ; D(8)
Debug "Ebene1(3): " ; D(9) ; " , " ; D(10) ; " , " ; D(11) ; " , " ; D(12)
Else
Print "Fehler: Punkt nicht erreichbar. Ebene nicht berechnet."
End If
Debug "Update_ebene1() beendet"
End Sub
'################################################# ##############################


'Führt einmalige Berechnungen durch, zB für den Arm-Anfangs-Punkt jedes Armes
Sub Init_calc()
Debug "Init_calc() gestartet"
'Arm1 Anfangspunkt
Aa_x(1) = B_x
Aa_y(1) = B_y + Abst_b_aa_xy
Aa_z(1) = B_z - Abst_b_aa_z
'Arm2 Anfangspunkt
Single_hilf(1) = 0.866025403784435 '=Cos(30°)
Long_hilf(1) = Single_hilf(1) * Abst_b_aa_xy
Aa_x(2) = B_x - Long_hilf(1)
Long_hilf(2) = Abst_b_aa_xy / 2 '=Sin(30°)*Abst_b_aa_xy = Abst_b_aa_xy / 2
Aa_y(2) = B_y - Long_hilf(2)
Aa_z(2) = B_z - Abst_b_aa_z
'Arm3 Anfangspunkt
Aa_x(3) = B_x + Long_hilf(1)
Aa_y(3) = B_y - Long_hilf(3)
Aa_z(3) = B_z - Abst_b_aa_z

'definiert minimalen/maximalen Abstand, den Armanfang von Armende haben muss.
'Die Korrektur verhindert, dass die Arme ganz durchgestreckt
'bzw komplett in sich gefaltet werden.
Long_hilf(1) = Oa - Ua
Long_hilf(1) = Abs(long_hilf(1))
'Korrektur:
Abst_min = Long_hilf(1)
Long_hilf(1) = Long_hilf(1) / 7
Abst_min = Abst_min + Long_hilf(1)

Long_hilf(1) = Oa + Ua
Abst_max = Long_hilf(1)
'Korrektur:
Long_hilf(1) = Long_hilf(1) / 8
Abst_max = Abst_max - Long_hilf(1)
Debug "Abst_max=" ; Abst_max
Debug "Abst_min=" ; Abst_min
Debug "Init_calc beendet"
End Sub
'################################################# ##############################


'Überschreibt alle Hilfsvariablen mit Nullen
Sub Clr_hilf()
Debug "Clr_Hilf() gestartet"
For I = 1 To 5
Single_hilf(i) = 0
Long_hilf(i) = 0
Next I
Debug "Clr_Hilf beendet:" ; Single_hilf(1) ; Single_hilf(2) ; Single_hilf(3) ; Single_hilf(4) ; Single_hilf(5) ; Long_hilf(1) ; Long_hilf(2) ; Long_hilf(3) ; Long_hilf(4) ; Long_hilf(5)
End Sub
'################################################# ##############################


Sub Change_t()
Debug "Change_t() gestartet"
Select Case T_z
Case 0
T_x = 20000000
T_y = 30000000
T_z = -103000000
Case -103000000
T_x = 0
T_y = -30000000
T_z = -150000000
Case -150000000
T_x = -20000000
T_y = 60000000
T_z = -180000000
Case -180000000
T_x = -40000000
T_y = -20000000
T_z = -250000000
Case -250000000
T_x = 60000000
T_y = 150000000
T_z = -320000000
Case -320000000
T_x = 0
T_y = 0
T_z = 0
End Select
Debug "T geändert auf ( " ; T_x ; " , " ; T_y ; " , " ; T_z ; ")"
Debug "Change_t beendet"
End Sub
'################################################# ##############################


'Dieses Label wird vom Sub Update-ebene1() benutzt.
'I=Arm-Nummer, J=Erstes Element im Array D(12) für den jeweiligen Arm.
Berechne_ebene1:
D(j) = Aa_x(i) - Ae_x(i)

D(j + 1) = Aa_y(i) - Ae_y(i)

D(j + 2) = Aa_z(i) - Ae_z(i)

Single_hilf(1) = Aa_x(i) * Aa_x(i)
D(j + 3) = Single_hilf(1)
Single_hilf(1) = Aa_y(i) * Aa_y(i)
D(j + 3) = D(j + 3) + Single_hilf(1)
Single_hilf(1) = Aa_z(i) * Aa_z(i)
D(j + 3) = D(j + 3) + Single_hilf(1)
Single_hilf(1) = Oa * Oa
D(j + 3) = D(j + 3) - Single_hilf(1)
Single_hilf(1) = Ae_x(i) * Ae_x(i)
D(j + 3) = D(j + 3) - Single_hilf(1)
Single_hilf(1) = Ae_y(i) * Ae_y(i)
D(j + 3) = D(j + 3) - Single_hilf(1)
Single_hilf(1) = Ae_z(i) * Ae_z(i)
D(j + 3) = D(j + 3) - Single_hilf(1)
Single_hilf(1) = Ua * Ua
D(j + 3) = D(j + 3) + Single_hilf(1)
Return



'Macht nichts und belegt unnoetig Speicherplatz. Die Funktion ist noetig,
'damit sich Nutzer von Windows heimisch fühlen.
Sub Nix()
End Sub



Deine Algebraische Lösung interessiert mich natürlich sehr (und auch alles andere, was du zu diesem Thema so loswerden willst ;) )

Grüße aus Düsseldorf,
Benjamin

[radbruch]

So sehr ich mich auch bemühe, ich blicke einfach noch nicht durch:

Es ist unverzeihlich, solche Fragestellungen zu posten. Seit einer halben Stunde denke ich an nichts anderes.Mich berührt das gar nicht. Ich weiß, dass ich das Problem mathematsch nie lösen kann.

Ich wollte mir das aneignen, aber als Realschüler kenne ich noch nicht mal die Formelzeichen die in der Kinemathik verwendet werden noch verstehe ich wirklich über was ihr jetzt "redet":(

http://www.fh-sw.de/sw/fachb/et/labinfo/elek-masch/media/dok/kempkes-2006.pdf


Kugelgelenke besitzen
an sich drei Freiheitsgrade (Schwenken in Azimuth- und
Elevations-Richtung, sowie Drehen um die Streben-Achse),
von denen bei einem Delta-Roboter aber nur die beiden
Schwenkrichtungen benötigt werden. Der dritte unnötige
Freiheitsgrad wird bei dieser Konstruktion durch eine Halterung
wieder eliminiert.
Zitat von Seite 3. Da liege ich mit meinen Schranieren genau richtig. Ein Lichtblick :)

[vohopri]

Ok,

dann hab ich ja richtig vermutet. Die Lösung ist einfach: Es gibt 3 Zusammenhänge:

Legende:
xz,yz,zz Koordinaten des Ziels, wo der Arm hin soll.
xe,........Koordinaten des Ellenbogens.
xb,........Koordinaten der Befestigung.

Durch die Konstruktion gibts noch ein wenig Versatz, aber das ist vorerst unwesentlich.

Entfernung Ziel-Ellenbogen
EZE ^2 = (xz-xe)^2+(yz-ye)^2+(zz-ze)^2
^2 heisst zum Quadrat
Das ist die Kugel

Die Lage der Ebene, in der der Ellenbogen rotiert
ye=k*xe + d
egal, in welcher Form die Gleichg vorliegt, y kann durch einen Ausdruck, der x enthält ersetzt werden.

Der Schwenkkreis des Ellenbogen
ze^2=r^2-(xb-xe)^2+(yb-ye)^2
r ist der Radius, mit dem der Ellenbogen schwenkt.

Und damit hast du ausreichend viel Zusammenhänge.

Mit der "Lage der Ebene" elimierst du alle y aus beiden anderen Formeln.

Dadurch enthält die Schwenkkreisformel nur mehr z und x. Somit kannst du sie dafür verwenden, alle z aus der Abstandsgleichung (Kugelgleichung) zu eliminieren. Und du hast nur mehr x als einzige Unbekannte in der Abstandsgleichung. Vereinfachen, was sich vereinfachen lässt, und du hast die Lösung.

Y erhältst du aus der 2. Gleichung und anschliessend z aus der dritten.

So, nun bin ich nicht sicher, ob es mir gelungen ist, das nachvollziehbar hin zu schreiben, bitte zu fragen, wenn was unklar ist.

grüsse,
Hannes

[Bensch]

ich habe auch bei aller rechnerrei immer die angst, dass ich mich total verrenne und das alles vieeeel zu kompliziert mache. vielleicht gibts ja eine viel einfachere lösung für das problem...so jetzt les ich erstmal das pdf von radbruch. Danke für din Link!

[radbruch]

Ok,

dann hab ich ja richtig vermutet. Die Lösung ist einfach...

...So, nun bin ich nicht sicher, ob es mir gelungen ist, das nachvollziehbar hin zu schreiben, bitte zu fragen, wenn was unklar ist.

Ich warte mal ab... *heul*

[vohopri]

Nöö,

nicht gleich weinen. Ist doch das tool, das das teachen abkürzen soll.

Ich hoffe Ben entwickelt die Formeln fertig, während ich da Mitnehmer bohre, säge, feile. Wirst sehen, ist gaanz toll, das teachtool.

Bin ja mehr ein Werkbankmensch und kein Formelentwickler.

grüsse,
Hannes

[Bensch]

ich muss erstmal germanys next topmodel gucken :D:D:D
danach schau ich mir das mal gaaaaanz in ruuuuuhe an.

Grüße,
Ben

[SprinterSB]

Geil.

"Ich pack mich aufs Sofa und vor die Glotze. Löst ihr schon mal meine Aufgaben in der Zwischenzeit. Und falls ihr fertig damit seid bevor das Bildung-TV zuende ist, bring mir noch 'n Bier vorbei..."

[Bensch]

Der Schwenkkreis des Ellenbogen
ze^2=r^2-(xb-xe)^2+(yb-ye)^2
r ist der Radius, mit dem der Ellenbogen schwenkt.

grüsse,
Hannes
kommt das von:
(xb-xe)^2 + (yb-ye)^2 + (zb-ze)^2 = r^2
?
Und dann mit zb=0 vereinfacht?
Dann müssten es aber -(yb-ye)^2 sein, also mit anderem vorzeichen, oder hab ich was falsch verstanden?


Geil.

"Ich pack mich aufs Sofa und vor die Glotze. Löst ihr schon mal meine Aufgaben in der Zwischenzeit. Und falls ihr fertig damit seid bevor das Bildung-TV zuende ist, bring mir noch 'n Bier vorbei..."
Aber ein kaltes bitte. Ich war doch eh an der Reihe mit Arbeiten, da werd ich mir die Zeit für'n Hobby doch noch selbst einteilen dürfen, oder :-# ?

[vohopri]

Hallo Ben,

verstehe deine Frage nicht.
Ich bin da von keiner Kugelformel aus gegangen, sondern habe die Kreisformel für das Ellbogengelenk verwendet.

grüsse,
Hannes

[Bensch]

eine Kreisformel im 3D-Raum? Jetzt versteh auch ich nicht mehr.

Aber unabhängig davon hab ich jetzt mal folgendes gemacht:
Ausgehend von deiner idee, das vektorielle Problem algebraisch zu lösen (was mir nie in den Sinn gekommen wäre, also vielen Dank dafür!) habe ich mal das ganze so umgeformt, dass ich jetzt durch einsetzen einer Formel in die zwei Anderen noch zwei Formeln mit zwei Unbekannten habe, nämlich x- und z-Koordinate des Ellenbogen.
Soweit müsste das lösbar sein.
Aber: x und z kommen jeweils als quadratisches und als lineares Monom vor, einen konstanten Anteil gibt's auch. Das GS hat also die Form:

I: ax^2 + bx + cz^2 + dz + e = 0
II: fx^2 + gx + hz^2 + iz + j = 0
mit a-j = konstant und x,z = gesuchte Koordinaten des Ellenbogens. y ist linear von x abhängig (3. Gleichung, hier nicht aufgeführt), kann man also auch ausrechnen wenn man obiges GS gelöst hat.)

Soweit bin ich jetzt. Da das nicht linear ist, entfällt also der Herr Gauss hier schonmal. Wie löst man sowas? Eine Gleichung nach x lösen (ergibt 2 Lösungen weil quadratisch) und dann mit beiden Lösungen (sofern beide reell) parallel weiterarbeiten, also in die andere Gleichung einsetzen, dann gibt es nurnoch z^2 und z, und wieder lösen (wieder quadratisch, also pro eingesetztem x zwei z)? dann hat man ja bis zu 2x2=4 Lösungen.

Dass mehrere Lösungen auftreten können war mit bewusst, allerdings ist 4 meines Erachtens zu viel. Ich hatte 2 Lösungen erwartet, weil der Ellenbogen an zwei verschiedenen Orten sein kann (Arm einmal nach innen und einmal nach aussen geknickt), um einen Ort zu erreichen.
Was ich mir noch vorstellen könnte wäre, dass hier aufgrund der speziellen geometrischen Herkunft der Gleichungen diese sowieso immer für eine Variable doppelte Nullstellen erzeugen, wodurch man dann auch immer nur 2 Punkte erhält. Die schöne Magie der Mathematik sozusagen. Aber dass kann ich erst Prüfen, wenn ich fertig bin und von Bleistift zur Tastatur wechsle

Beste Grüße,

ein freudiger Benjamin, den langsam der Enthusiasmus packt


PS: Vohopri, nochmals vielen Dank für die Idee mit dem algebraischen Ansatz. Ich habe in der Schule gelernt, Geometrische Probleme immer geometrisch zu lösen, also "mach da ne Ebene und fälle da ein Lot" usw. Dass man das ganze auch ganz Abstrakt als Gleichungssystem auffassen kann, wäre mir nie in den Sinn gekommen. Das hat wirklich meinen Horizont erweitert.

[mare_crisium]

Bensch,

Du hast Dich da ja richtig in eine schwierige Vektorrechnung hineingewühlt :-) ! Dein GS würde ich so lösen, wie im angehängten pdf gezeigt. Es kommt eine nicht-lineare Abhängigkeit zwischen z und x heraus.

Ciao,

mare_crisium

Edit: Im pdf den Fehler korrigiert, den Bensch in seinem Posting vom 14.02.2009 anspricht.

Edit: Anhang gelöscht, wg. Upload-Quota

[Bensch]

Hallo mare_crisium,

Vielen Dank für die Anleitung, sogar identische Variablennamen!
Da ich am Montag eine Klausur schreibe, weiß ich noch nicht, ob ich jetzt am WE dazu komm das in Basic umzusetzen. Kommende woche sollte ich aber spätestens Zeit finden.

Viele Grüße,

Benjamin

Edit:

Ich hab, glaub ich, nen Fehler gefunden. Der Konstant-Teil der Differenzfunktion (i) - (ii) muss (ef/a - j) sein, da hast du das e vergessen.