Delta Roboter

Hallo

Inzwischen habe ich meine Konstuktion etwas geändert. Die Servos sind nicht mehr tragendes Element und können so schneller ersetzt werden. Durch die Untersetzung wird der Drehbereich der Servos (~180°) besser an die Drehbereiche des Deltaarms (~120°) angepasst:

Externes Bild anzeigen   

Externes Bild anzeigen    Externes Bild anzeigen    Externes Bild anzeigen    Externes Bild anzeigen   

Ein bisschen FT erleichtert das Testen verschiedener Aufbauversionen :) Rechts die freihändig gefertigten Oberarmstreben.

Das Filmchen dazu:
Externes Bild anzeigen   
http://www.youtube.com/watch?v=7bQRXfLwBgU

Obwohl ich mit der Antriebslösung noch nicht wirklich zufrieden bin plane ich jetzt einen "Greifer" und eine kleine Aufgabe. Das ist schon eine sehr geniale Roboterarmtechnik ;)

Gruß

mic

Ich kann nur sagen, respect, es ist toll zu sehen, wie du auf die schnelle was zusammenbaust, weiterentwickelst und immer weiter probierst. Dafür, dass der Thread erst vor einigen Tagen gestartet wurde, machst du ja riesige Fortschritte, wenns bei mir auch so laufen würde.

Mensch radbruch,
das sieht ja wirklich seeeehr fein aus. auch das Verhältnis von Geschwindigkeit zu Genaueigkeit ist ja schon vieeeeel besser! Wird nur ein bisserl instabil, wenn alle Arme durchgestreckt sind. Aber das liegt wohl an der Konstruktionsart an sich, nicht an deiner Umsetzung, denke ich.

Welches Verhältnis von Antriebsseitigem zu Antriebsfernem Armteil-Länge hast du da cirka? Ich wollte so in Richtung 1:2,5 - 1:3 gehen.

Nach einem sehr erhellenden PN-Austausch mit MeckPommER haben wir jetzt auch unsere Mißverständnisse aus dem Weg geräumt und sind nun auf einem Nenner. Er wird die Sache etwas anders realisieren, als es in radbruchs Bot gemacht ist.

radbruch, hast du schon eine idee zur Rückwärtskinematik? Ich habe bisher folgenden Ansatz:

1. Um die Punkte "Armanfang" und "Armende" eine Kugel legen, deren r = der Armteil-Länge des jew. angrenzenden Armteils ist.
2. Schnittkreis der Kugeln = Mögliche Positionen des Arm-Gelenkes
3. Ebene, auf der der Antriebsseitige Armteil sich bewegt, festlegen (ist ein Fixwert)
4. Schnittpunkte des Kreises aus 2. mit der Ebene aus 3. = Mögliche Punkte des Arm-Gelenks (sollten zwei sein).
5. Jenen Punkt wählen, der weiter weg ist von der Mitte des nicht bewegten Teil des Roboters.
6. Von der Ebene, auf der der Bot steht ein Lot auf den Punkt aus 5. fällen.
7. das Lot, die Strecke (Lot-Fußpunkt - Punkt aus 5.) und (Punkt aus 5. - Armfixpunkt) Bilden ein Dreieck, in dem der gesuchte Winkel liegt (Cosinussatz bzw. Skalarprodukt anwenden)

Das ganze dann natürlich für jeden Arm einzeln. Wenn man 4 Arme hat, kann man auch den Greifer (oder sonst was) drehen, siehe hier von 1:05 bis 1:20. Dazu sollte man, wenn man obige idee umgesetzt hat, nur die Armendpunkt ändern müssen.

Hat jemand Lust, obiges mal in Bascom umzusetzen :-# ?

Beste Grüße,

Benjamin

Hallo

Es freut mich dass euch die Spielerei gefällt. Leider flutschen bei mir nur die Projekte die mich interessieren, viele andere eigentlich sehr wichtige Dinge erledige ich dagegen eher schleppend. Und keines meiner Projekte habe ich bisher wirklich beendet :(

Das Verhältniss der Armlängen ist bei meinem Modell 6cm zu 13cm. Das hat sich aus Bauchgefühl und vorhandenem Messingrohr eher zufällig so ergeben. Am Ende der Hubbewegung werden die Unterschiede der Servostellungen besonders deutlich weil nicht alle Servos gleichzeitig die Endlage erreichen. Der nutzbare Arbeitsbereich ist kleiner als das maximal machbare.

Servos sind auch nicht wirklich ideal weil man ihre Stellgeschwindigkeit nicht gut steuern kann. Besser ist natürlich ein Getriebemotor (ich liebäugle mit kleinen Akkuschraubern), der erfordert allerdings einen erheblichen Aufwand beim Ansteuern. Ausserdem benötigt man dann auch eine Wegmessung an den Antriebwellen. Damit wären sicher auch sehr feinfühlige Bewegungen möglich (plotten/schreiben?), mit Servos kann mal eigentlich nur Positionen anfahren ohne dabei die Wege genau festzulegen.

Den mathematischen Ansatz verdränge ich weiterhin energisch und bleibe vorerst bei der Teachlösung. Selbst wenn es mir gelingen würde die erforderlichen Servowinkel auszurechen, ich wüsste nicht, wie ich diese dann in Servoimpulslängen umrechnen sollte. Zudem sind meine Billigservo alles andere als liniar.

Schönen Abend noch

mic

Das Umrechnen Servowinkel -> Impulslänge ist eine einfache lineare Zuordnung. Wenn du mir eine Formel für die Servowinkel lieferst, mach ich dir den Rest :D
Nein mal im Ernst: Ich finde, dass bei dieser Bauart gerade die Ansteuerung der Witz an der Sache ist. Ohne diese ist es nur eine mechanische Spielerei, man kann sich an der immerwährenden Parallelität der bewegten Plattform freuen, aber wirklich nützlich ist das so nicht. Man kann nicht einmal eine lineare Bewegung der Plattform erzeugen. Ich würde deshalb wirklich gerne eine elegante Ansteuerung, verzeihung: Rückwärtskinematik für den Delta entwickeln.

Zitat:

---

Zitat von radbruch

... Damit wären sicher auch sehr feinfühlige Bewegungen möglich (plotten/schreiben?), mit Servos kann mal eigentlich nur Positionen anfahren ohne dabei die Wege genau festzulegen...

---

Nun ja, du hast eine Position, die du anfahren willst, schickst diese an die Servos und ScHwUpS nimmt der Arm die Position ein. Die Kunst besteht meiner Meinung nach darin, eben diese Position "oft und flüssig" an die Steuerung weiterzugeben.

Wenn ich zwei entfernte Punkte ansteuern will und diese ohne errechnete Zwischenpunkte anfahre, dann ergeben sich mit Sicherheit unschöne Bewegungen.

Wenn ich aber eine steuerungstechnische Zwischenstufe einfüge, die mir aus meinen Ansteuerungspunkten zunächst eine Reihe von Zwischenpunkte errechnet, die ich so schnell als möglich anfahre, dann habe ich auch geschmeidige Bewegungen ohne Gezappel :)

Eben diese Zwischenstufe muss realisieren können, wie schnell die Mechanik ist. Je weiter der Weg ist, desto höher muss sie diese Bahn auflösen können.

Gruß MeckPommER

Hallo

Mit lausig geteachten Positionen (zwei Stunden Arbeit, ich muss mir wohl ein kleines Tool schreiben) sieht das Ergebniss recht nett aus:

Externes Bild anzeigen   
http://www.youtube.com/watch?v=QeY_KkZRlDc

Ehrlich, das Demo lief minutenlang ohne Probleme. Aber für das Filmchen musste ich ja unbedingt noch die Akkus laden. Naja, der Kater hat seinen Spass dabei.

Dass die Wiederholgenauigkeit der Billigservos ziemlich schlecht ist wußte ich schon seit den Dominosteinen. Ohne eine getrennte Wegmessung direkt an den Armen wird das wohl nichts werden.

"Hat schonmal jemand versucht einen Delta Robot selber zu bauen?" Ja, habe ich und das macht Spaß! *lol*

Gruß

mic

find ich super. wie hast du die Positionen geteacht? du hast doch gar keine Sensorik?!
Ich code Grad eine Ansteuerung, hier mein Stand der Dinge:
Leider fehlt noch alles, was kompliziert ist :-# :-# :-#

Code:

---

'
' Alle Berechnungen gehen von Folgendem aus:
' Der Bot ist an einer Ebene befestigt, die parallel zur xy-Ebene liegt
' Der Arm 1 liegt in y-Richtung.
' Der Arm 2 liegt, von oben gesehen, 120° links gedreht (Negative y- und x-Richtung).
' Der Arm 3 liegt, von oben gesehen, 120° rechts gedreht (Negative y-, positive x-Richtung).
' Alle Werte für Längen, Abstände und Positionen werden in Nanometern (nm) angegeben!
'


Declare Function Tastenabfrage() As Byte
Declare Sub Eins()
Declare Sub Zwei()
Declare Sub Drei()
Declare Sub Vier()
Declare Sub Fuenf()


$regfile = "m32def.dat"
$framesize = 32
$swstack = 32
$hwstack = 32
$crystal = 16000000                                        'Quarzfrequenz
$baud = 9600

Config Adc = Single , Prescaler = Auto                      'Für Tastenabfrage und Spannungsmessung
Config Pina.7 = Input                                      'Für Tastenabfrage
Porta.7 = 1                                                'Pullup Widerstand ein

Dim Taste As Byte

' Deklaration der Variablen, die die Proportionen des Roboters beschreiben
' Alle Angaben in nm und als "Long" (32bit genauigkeit)
' Zulässig sind Werte zwischen -2147483648 und +2147483647

Print
Print "= = = = Delta-Steuerung = = = ="
Print
Print "Lade Konstruktionsparameter..."

' Fixer Befestigungspunkt B im Raum
Dim B_x As Long
Dim B_y As Long
Dim B_z As Long
                          B_x = 0
                          B_y = 0
                          B_z = 0


' Länge des Servoseitigen Armteils ("Oberer Armteil" -> Oa)
Dim Oa As Long
                          Oa = 100000000                  '=10cm


' Länge des Servofernen Armteils ("Unterer Armteil" -> Ua)
Dim Ua As Long
                          Ua = 200000000                  '=20cm


' Abstand der Armservoachsen vom Befestigungspunkt B auf der xy-Ebene
Dim Abst_b_aa_xy As Long
                          Abst_b_aa_xy = 70000000          '=7cm


' Abstand der Armservoachsenvom von der xy-Ebene
Dim Abst_b_aa_z As Long
                          Abst_b_aa_z = 30000000          '=3cm


' Abstand der Armenden vom Tool auf der xy-Ebene
Dim Abst_t_ae_xy As Long
                          Abst_t_ae_xy = 40000000          '=4cm

' Abstand der Armenden von der xy-Ebene
Dim Abst_t_ae_z As Long
                          Abst_t_ae_z = 10000000          '=1cm

Print "Konstruktionsparameter geladen"
Print
Print "Montagepunkt = (" ; B_x ; "," ; B_y ; "," ; B_z ; ")"
Print "Armanfangs-Versatz:"
Print Abst_b_aa_xy ; "nm vom Montagepunkt in xy-Ebene"
Print "und " ; Abst_b_aa_z ; "nm in z-Richtung"
Print "Armende-Versatz:"
Print Abst_t_ae_xy ; "nm vom Toolpunkt in xy-Ebene"
Print "und " ; Abst_t_ae_z ; "nm in z-Richtung"
Print
Print "Berechne Konstruktionsabhaengige Fixwerte"

' Arm-Anfangspunkte:
' Arm1: (Der von oben gesehen hintere Arm, genau in y-Richtung)
Dim A1a_x As Long
Dim A1a_y As Long
Dim A1a_z As Long
A1a_x = B_x
A1a_y = B_y + Abst_b_aa_xy
A1a_z = B_z - Abst_b_aa_z

'Arm2: (Der von oben gesehen linke Arm)
Dim A2a_x As Long
Dim A2a_y As Long
Dim A2a_z As Long
Dim Hilf1 As Single                                        'Hilfsvariable für Zwischenergebnisse
Dim Hilf2 As Long
Dim Hilf3 As Long
Hilf1 = 0.866025403784435                                  '=Cos(30°)
Hilf2 = Hilf1 * Abst_b_aa_xy
A2a_x = B_x - Hilf2
Hilf3 = Abst_b_aa_xy / 2                                    '=Sin(30°)*Abst_b_aa_xy = Abst_b_aa_xy / 2
A2a_y = B_y - Hilf3
A2a_z = B_z - Abst_b_aa_z

'Arm3: (Der von oben gesehen rechte Arm)
Dim A3a_x As Long
Dim A3a_y As Long
Dim A3a_z As Long
A3a_x = B_x + Hilf2
A3a_y = B_y - Hilf3
A3a_z = B_z - Abst_b_aa_z

Print "Fixwert-Berechnung abgeschlossen."
Print "Arm1-Anfang = ( " ; A1a_x ; " , " ; A1a_y ; " , " ; A1a_z ; " )"
Print "Arm2-Anfang = ( " ; A2a_x ; " , " ; A2a_y ; " , " ; A2a_z ; " )"
Print "Arm3-Anfang = ( " ; A3a_x ; " , " ; A3a_y ; " , " ; A3a_z ; " )"

Do
  Taste = Tastenabfrage()
  If Taste <> 0 Then

      Select Case Taste
        Case 1
            Call Eins
        Case 2
            Call Zwei
        Case 3
            Call Drei
        Case 4
            Call Vier
        Case 5
            Call Fuenf
      End Select
  End If
  Waitms 1000
Loop

End

Sub Eins()
Print "Sub 1"
End Sub


Sub Zwei()
Print "Sub 2"
End Sub


Sub Drei()
Print "Sub 3"
End Sub


Sub Vier()
Print "Sub 4"
End Sub


Sub Fuenf()
Print "Sub 5"
End Sub


'Diese Unterfunktion fragt die Tastatur am analogen Port ab
Function Tastenabfrage() As Byte
Local Ws As Word

  Tastenabfrage = 0
  Start Adc
  Ws = Getadc(7)
  ' Print "Tastenabfrage anpassen!ADC Wert ws=" ; Ws
  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

---

Zitat:

---

wie hast du die Positionen geteacht?

---

teachen=solange an den Servopositionen fummeln bis es halbwegs passt.

In C sieht das bei mir dann so aus:

Code:

---

// Deltaarm ansteuern mit dem RP6                                  3.2.09  mic

#include "rblib.h"
#include "rblib.c"

volatile uint16_t p=0;
uint8_t  xpos=120, ypos=120, zpos=120, demo;
uint16_t speed;

void servo_init(void);
void pause(uint16_t p_10ms);
void moveto(uint8_t x, uint8_t y, uint8_t z, uint8_t pause_10ms);
void holen1(void);
void holen2(void);
void holen3(void);
void bringen1(void);
void bringen2(void);
void bringen3(void);
int main(void)
{
        rblib_init();
        servo_init();
        pause(100);
/*  for(demo=120; demo<190; demo++) moveto(demo,demo,demo,5);
  for(demo=189; demo>120; demo--) moveto(demo,demo,demo,4);
  for(demo=121; demo<190; demo++) moveto(demo,demo,demo,3);
  for(demo=189; demo>120; demo--) moveto(demo,demo,demo,2);
  for(demo=121; demo<190; demo++) moveto(demo,demo,demo,2);
  for(demo=189; demo>120; demo--) moveto(demo,demo,demo,1);
  moveto(190,190,190,50);
        moveto(120,120,120,50);
*/

        // heben und legen
        holen1(); bringen1();
        holen3(); bringen3();

        while(1)
        {
        // tauschen
                holen1(); bringen2();
                holen3(); bringen1();
                holen2(); moveto(90,160,90,40); bringen3();
        }
        return(0);
}
ISR(TIMER0_COMP_vect)
{
        static uint16_t count=0;
        if(count>xpos) PORTA &= ~16; else PORTA |= 16;        // E_INT1 (Pin8)
        if(count>ypos) PORTC &= ~1;  else PORTC |= 1;        // SCL (Pin10)
        if(count>zpos) PORTC &= ~2;  else PORTC |= 2;        // SDA (Pin12)
        if(count<1000)count++; else { count=0; if(p) p--; }
}
void servo_init(void)
{
        DDRA |= 16;                                // E_INT1 als Ausgang
        DDRC |= 3;                                // SCL und SDA als Ausgang

        TCCR0 =  (0 << WGM00) | (1 << WGM01);                                        // CTC-Mode
        TCCR0 |= (0 << COM00) | (0 << COM01);                                        // ohne OCR-Pin
        TCCR0 |=        (0 << CS02)  | (1 << CS01) | (0 << CS00);        // prescaler /8
        TIMSK =  (1 << OCIE0);                                                                                // Interrupt ein
        OCR0  = 10; // 100kHz?
}
void pause(uint16_t p_10ms)
{
        p=p_10ms;
        while(p);
}
void moveto(uint8_t x, uint8_t y, uint8_t z, uint8_t p_10ms)
{
        xpos=x;
        ypos=y;
        zpos=z;
        p=p_10ms;
        while(p);
}
void holen1(void)
{
                moveto(99,104,91,50);
                moveto(80,90,73,20);
                moveto(99,104,91,30);
}
void holen2(void)
{
                moveto(60,111,83,50);
                moveto(50,95,65,20);
                moveto(60,111,83,30);
}
void holen3(void)
{
                moveto(84,110,52,50);
                moveto(69,95,47,20);
                moveto(84,110,52,30);
}
void bringen1(void)
{
                moveto(99,104,91,50);
                pause(200);
}
void bringen2(void)
{
                moveto(60,111,83,50);
                pause(200);
}
void bringen3(void)
{
                moveto(81,107,50,50);
                pause(200);
}

---

*GG*

fein fein,
ich bin zwar nicht der Knaller in C, aber ich glaube ich versteh's.

Wirst du eine Rückwärtskinematik umsetzen?