Delta X 4 Robot

Hallo zusammen,

ich besuche dieses Forum schon seit einiger Zeit, und wollte nun auch meinen Beitrag dazu leisten.

Das Gestell für diesen Roboter habe ich aus Aluminium gefertigt. Der Hauptcontroller ist ein Atmega 1284. Jedes Bein hat dann noch mal seinen eigenen Controller (Atmega 32) die die Befehle des Hauptcontrollers per SPI empfangen. Als Servos habe ich die MC 620 MG benutzt. Gesteuert wird das ganze über eine 35 Mhz Modellbau Funkanlage die ich schon seit 15 Jahren im Keller liegen hatte. Die Bauzeit betrug, mit vielen Unterbrechungen, ca. 6 Monate. Dies ist auch mein erstes Projekt gewesen.

Hier nun noch ein Video und 2 Bilder.

http://www.youtube.com/watch?v=G9RhdZQy3xo

Hallo,

das ist mal eine geniale idee der fortbewegung! gefällt mir ;-)

grad mich persönlich interessiert auch die ansteuerung eines Deltapod's

die fussspitzen beschreiben die einfach eine gerade oder auch kurven? also wenn den drehungen machst.

planst du noch die drehung des körpers ein?

soll er auch autonom agieren?

Gruß, Bammel

Hallo

Sehr schön. Gedanklich bin ich auch schon soweit, allerdings plane ich die Beine aus Gewichtsgründen inzwischen "Upside Down":

https://www.roboternetz.de/community...lker-3D-Modell

Gruß

mic

Hallo LetsBuildBots,

sehr gute Arbeit! Besonders gefällt mir die Ansteuerung der Servos, kannst Du darüber etwas mehr preisgeben?
Zum Beispiel wie Du den SPI Bus anbindest, die Controller der Beine zeitnah auswählst und ganz besonders wie das Timing der Servos aussieht.


Gruß
tucow

Hallo,

@ Bammel

Da dies ja auch bisher mein erste Programm für einen Microcontroller ist, hab ichs mir erst mal einfach gemacht und die ganzen Bewegungen linearisiert. Der Haupcontroller sendet einen Punkt (x,y,z) an den Beincontroller. Dieser berechnet daraus die Position der Fussspitze und bewegt die Servos dementsprechend auf dem direkten weg dorthin. Bei den Drehungen hab ich auch einfach die Punkte der Tangente eines Kreises hergenommen.

Das Autonome agieren des Bots währe der nächste Schritt, nur weis ich noch nicht genau was hier am zielführensten wäre. Hab Ihr vielleicht einen Vorschlag?

@radbruch
Ein Delta Bot mit 2 Beinen ist auch eine super Idee!

@ tucow
ich hab für jedes Bein erstmal die Punkte fest im Hauptcontroller hinterlegt für eine Bewegungsfolge z.b.:

void left(void)
{
send_koordinates(1,50,50,-110); // Bein 1 hoch und nach vorne heben
send_koordinates(3,-50,-50,-110); // Bein 3 gleichzeitig ebenso
_delay_ms(300);
send_koordinates(1,50,50,-140); // Bein 1 absetzen
send_koordinates(3,-50,-50,-140); // Bein 3 absetzen
_delay_ms(300);
send_koordinates(2,50,-50,-110); // Bein 2 hoch und nach vorne heben
send_koordinates(4,-50,50,-110);// Bein 4 gleichzeitig ebenso
_delay_ms(300);
send_koordinates(2,50,-50,-140);// Bein 2 absetzen
send_koordinates(4,-50,50,-140); // Bein 4 absetzen
_delay_ms(300);
send_koordinates(1,-50,-50,-140); // Bein 1 nach hinten schieben , bewirk das der Körper sich nach vorne bewegt
send_koordinates(2,-50,50,-140); // Bein 2 nach hinten schieben , bewirk das der Körper sich nach vorne bewegt
send_koordinates(3,50,50,-140); // Bein 3 nach hinten schieben , bewirk das der Körper sich nach vorne bewegt
send_koordinates(4,50,-50,-140); // Bein 4 nach hinten schieben, bewirk das der Körper sich nach vorne bewegt
_delay_ms(300);

// unterschiedliche Vorzeichen, da die Beine jeweils um 90 Grad gedreht angeordnet sind
}

(Beinnummer, x,y,z)

Der Slave (Beincontroller) läuft dann in einer Schleife von 16ms (= PWM für die analogen Servos). Am Anfang der Schleife wird gewartet bis die PWM Pulse fertig sind (max 3 Millisekunden). Dann berechnet der Controller aus den Koordinaten den anzusteuernden Punkt (inverse kinematik, ca. 7 ms) und stellt die Timer dementsprechend für den Anfang des nächsten Schleifendurchlaufs ein. Der Rest ist wieder Wartezeit.
Für die Kommunikation benutz ich das Hardware SPI der Controller mit jeweils einem Pin als Select für das Bein und den Interrupt im Chip wenn neue Daten angekommen sind.
Die nächste Bewegungsfolge schickt der Master 500ms nach dem Abschluss der letzten. Ich hab viel mit delays gearbeitet um das zu timen (was warscheinlich nicht gerade das optimale Vorgehen ist.)

Gruß LetsBuildBots

Vielen Dank, für die Infos, das hat den Ausschlag gegeben wie ich mein Praxisprojekt (FH) realisiere. (Mehr Infos später, und nicht an dieser Stelle, soll ja dein Beitrag bleiben.)


Was hast Du dir denn für das autonome Agieren vorgestellt, was soll er genau machen?
Wenn er nur Sachen ausweichen soll würde ich auf Ultraschall setzen. Wobei sowas rudimentäres bei einem solchen Bot schon sehr kläglich wäre, wenn es das Einyige bleibt. Vielleicht solltest Du dich mit Bildverarbeitung beschäftigen?


Gruß
tucow

Hallo

freut mich wenn ich gleich helfen konnte. Falls noch weiter Fragen aufkommen einfach jederzeit bescheid sagen.
An Bildverarbeitung hab ich auch schon gedacht. Muss ich mal bei Gelegenheit anschauen.

Gruß
LetsBuildBots

Hey,

was mich noch interessieren würde: Wie nimmst du die Befehle auf den µC der Beine entgegen?
Wenn Du z.B. send_koordinates(4,50,-50,-140); aufrufst, was macht send_koordinates() mit den Variablen, wie verarbeitet sie diese und wie sendet sie die?


Gruß
tucow

Hallo,

also ich hab das so programmiert:

*********Master Seite***********
void send_koordinates(uint8_t bein,int16_t x, int16_t y, int16_t z)
{
if (bein == 1)
{
send_word_B1(x);
send_word_B1(y);
send_word_B1(z);
}
if (bein == 2)
.
.
.

void send_word_B1(int16_t word)
{
uint8_t high_byte;
uint8_t low_byte;

high_byte = word >> 8; //High anteil herrausnehmen
low_byte = word & 0xff; //Low anteil herrausnehmen
PORTB &= ~(1 << DDB3); //low (Chip des Beines 1 auswählen)
SPI_MasterTransmit(high_byte);
PORTB |= (1 << DDB3); // high
PORTB &= ~(1 << DDB3); //low
SPI_MasterTransmit(low_byte);
PORTB |= (1 << DDB3); // high
}

void SPI_MasterTransmit(char cData)
{
SPDR = cData;/* Start transmission */
while (!(SPSR & (1<<SPIF)));/* Wait for transmission complete */
}

********Slave Seite**********

volatile unsigned char dataarray[6];// global
volatile int i = 0; // global


ISR(SPI_STC_vect) //interrupt auf SPI
{
unsigned char data;
data=SPDR;
dataarray[i]=data;
i++;
}

Es muss mit den timings sicher gestellt werden, dass i nicht mal falsch mitzählt sonst werden die Koordinaten falsch zugewiesen.
Kann man sicher noch verbessern.

Daten wieder zu einem 16 bit Wert zusammensetzen: word = (high_byte << 8 )|low_byte;

Hoffe das hilft dir weiter

Gruß
LetsBuildBots

Zitat:

---

Zitat von LetsBuildBots

freut mich wenn ich gleich helfen konnte. Falls noch weiter Fragen aufkommen einfach jederzeit bescheid sagen.

---

Hi
Ich versuche gerade selbst eiene "2d" delta roboter zu bauen aber ich komme mit der mathematische/kinematischen beschreibung nicht weiter das erste gelenk ist noch einfach sin x und cos x aber wo sich dann der gemeinsame punkt befindet weiß ich nicht, müsste eine quadratische gleichung ergeben weil er teoretisch an zwei stellen sein kann oder? Und in 3d ist es noch aufwändiger...
Ich würde mich sehr freuen wenn dazu jemand etwas sagen könnte? Eine link zu einem projekt? Oder ein teil des programmes?
Vielen dank
Gruß 3gfisch

Hallo
am Wochenende kann ich gerne mal posten wie ichs gemacht habe. Spätestens am Sonntag melde ich mich hier wieder.

bis dann
ciao

LetsBuildBots

Hi

ich hab mich bei meiner Umsetzung an diesen Artikel gehalten:

http://forums.trossenrobotics.com/tu...nematics-3276/

Hier wird das ganze sehr gut beschrieben und ein Beispiel Programm ist auch vorhanden. Dieses Beispiel hab ich im AVR GCC nachgebaut. Braucht bei einem ATMEGA328 mit 20MHz ca. 7ms um alle 3 Winkel zu berechnen. Da ich ja für jedes Bein einen davon verbaut habe und die Servo PWM 20ms lang ist reicht diese Implementierung erst mal für mich so aus. Habs bisher nicht weiter optimiert oder so.
Den Winkel rechne ich anschließend linear in die Pulslänge für die Servo PWM um.

Falls noch Fragen offen sind einfach bescheid sagen.

ciao

LetsBuildBots