monoleg - Der einbeinige Roboter

[radbruch]

Hallo Roboterfans

Nach Räder-, Ketten- und Raupenantrieben wollte ich mal in die Welt der Spinnenbeine reinschnuppern.
Noch hängt das inzwischen fertige "Fahrwerk" am RP6, geplant ist aber ein
eigenes ATtiny13-Kontrollerplatinchen (http://www.loetstelle.net/projekte/tinydil/tinydil.php) auf Basis meines Trostpreises (http://www.loetstelle.net/forum/%76iewtopic.php?p=4306#4306):

http://radbruch.roboterbastler.de/monoleg/pics/monoleg15.jpg

Ein Demo-Video der Bewegungsmöglichkeiten:

http://img.youtube.com/vi/uUTXzSHQXrM/2.jpg (http://www.youtube.com/v/uUTXzSHQXrM)
Bild anklicken für youtube-Video (http://www.youtube.com/v/uUTXzSHQXrM)
Orginal: 8,4MB mpg mit Ton (http://radbruch.roboterbastler.de/monoleg/pics/monoleg_06.mpg)

Bauteile Fahrwerk:

3 5€-Miniservos
1 Akkuhalter mit 2500er NIMH-Akkus (4,8V)
4 Gummitüllen aus einem alten Videorekorder
1 Kabel einer seriellen Maus mit Buchse
2 80mm Vorderräder eines RC-Cars mit Nylonlagern
2 Inbus (http://de.wikipedia.org/wiki/Inbus)schrauben M5*50
1 22mm Messingrohr (5mm Innendurchmesser)
2 U-Scheiben M5
1 Kunststofftrinkhalm

Bauteile Servoadapter:

1 Stück Lochraster
1 Buchse vom Mauskabel
3 3er-Stiftleisten
1 1uF Tantal
1 Kabelbinder (klein)

Bauteile RP6-Adapter:

1 14-Pol Flachkabelstecker
1 9Pol-SUBD-Stecker mit Gehäuse
2 10K Widerstände (PullDown für SCL/SDA)
1 Stück Klebeband

Stütze, Finger und konstruktive Verbindungen sind aus Heiskleber.

Verdrahtung:

Die Servos hängen am Erweiterungsport des RP6. Ich verwende die Signale E_INT(8 ), SCL(10) und SDA(12) und die geregelten 5V an Pin1/2(-) und Pin3 (+). (Tipp für Nachbauer: Die Pins liegen am 14Pol-Flachkabelstecker nicht nebeneinander!) Der Weg der Signale: Vom 14-Pol über den 9-Pol, das Mauskabel, Buchse Mauskabel, Lochraster zu den Stiftleisten. Parallel zu den Stiftleisten ist noch ein 1uF-Elko zwischen + u - und zwischen Pin 10 und 12 im RP6-Adapter ist noch je ein 10K-PullDown (um elektrisch wie Pin E_INT zu sein).

Funktion und Software:

Das Bein mit seinen drei Achsen (Finger, Arm und Schulter) soll den auf der Stütze stehenden Roboter anheben und bewegen. Das hört sich einfach an, ist aber für einen Realschüler wie mich mathematisch nicht zu lösen. *grummel* Mehr als "stochern" habe ich bisher nicht geschafft, deshalb zeige ich euch hier nur ein kleines Demo der Bewegungsmöglichkeiten. Das Programm dazu ist mit Absicht und Voraussicht auf den kleinen ATtiny13 recht einfach gehalten und verwendet die orginalen Libraries:


#include "RP6RobotBaseLib.h"

uint8_t i, pause, servo_stellzeit, servo_delay;

void servo(uint8_t w0, uint8_t w1, uint8_t w2)
{
unsigned int count=0;
do{
PORTA |= E_INT1; // E_INT1 (Pin8)
sleep(w0);
PORTA &= ~E_INT1;
PORTC |= 1; // SCL (Pin10)
sleep(w1);
PORTC &= ~1;
PORTC |= 2; // SDA (Pin12)
sleep(w2);
PORTC &= ~2;
sleep(servo_delay-(w0+w1+w2));
//sleep(127);
} while (count++ < servo_stellzeit);
mSleep(10*pause);
}

int main(void) {

initRobotBase();
i=0;
servo_stellzeit=15;
DDRA |= E_INT1; // E_INT1 als Ausgang
DDRC |= 3; // SCL und SDA als Ausgang
// 5 - 15 - 25 // Min - Mitte - Max
servo(15,15,15); // Grundstellung
while (1)
{
switch (i)
{
case 0: i++; pause=30; servo_delay=255; mSleep(1000); break;
case 1: i++; pause=10; servo_delay=255; break;
case 2: i++; pause=10; servo_delay=127; break;
case 3: i++; pause=1; servo_delay=127; break;
case 4: i=0; pause=1; servo_delay=127; break;
}
servo(10,15,15); // Finger zurück
servo(15,15,15);
servo(20,15,15); // Finger vor
servo(15,15,15);

servo(15,10,15); // Arm runter
servo(15,15,15);
servo(15,20,15); // Arm hoch
servo(15,15,15);

servo(15,15,10); // Schulter links
servo(15,15,15);
servo(15,15,20); // Schulter rechts
servo(15,15,15);

servo(20,10,15); // Finger vor, Arm runter
servo(25,5,15);
servo(20,10,15);
servo(15,15,15);

servo(20,20,15); // Finger vor, Arm hoch, Schulter links
servo(15,15,10);

servo(10,20,10); // Finger zurück, arm hoch
servo(5,25,10);
servo(10,20,10);
servo(15,15,15);

}
return 0;
}


Ausblick:

Der ATtiny13 hat 6 I/Os, 3 davon sind für die Servos reserviert. Einen share ich zwischen einer LED und einem Taster. Einen weiteren werde ich für einen Lichtsensor opfern, dann kann er mit einer Solarzelle auf dem Rücken nach Energie suchen. Bleibt noch ein Pin zur freien Verfügung. Hier bräuchte ich noch eine Idee...

Softwaremässig soll er das Laufen lernen. Zuerst noch in C über den RP6, später dann in Maschinensprache mit dem ATtiny13. Das wird aber noch etwas dauern, denn ich habe noch keine Kontrollerplatine, keinen ISP-Adapter, keine Programmiersoftware, keinen Assembler und vor allem, AVR-Maschinensprache kann ich auch noch nicht. Es gibt noch viel zu tun.

Impressionen:

http://radbruch.roboterbastler.de/monoleg/pics/monoleg02_klein.jpg (http://radbruch.roboterbastler.de/monoleg/pics/monoleg02.jpg) http://radbruch.roboterbastler.de/monoleg/pics/monoleg16_klein.jpg (http://radbruch.roboterbastler.de/monoleg/pics/monoleg16.jpg) http://radbruch.roboterbastler.de/monoleg/pics/monoleg17_klein.jpg (http://radbruch.roboterbastler.de/monoleg/pics/monoleg17.jpg) http://radbruch.roboterbastler.de/monoleg/pics/monoleg18_klein.jpg (http://radbruch.roboterbastler.de/monoleg/pics/monoleg18.jpg)
http://radbruch.roboterbastler.de/monoleg/pics/monoleg03_klein.jpg (http://radbruch.roboterbastler.de/monoleg/pics/monoleg03.jpg) http://radbruch.roboterbastler.de/monoleg/pics/monoleg04_klein.jpg (http://radbruch.roboterbastler.de/monoleg/pics/monoleg04.jpg) http://radbruch.roboterbastler.de/monoleg/pics/monoleg12_klein.jpg (http://radbruch.roboterbastler.de/monoleg/pics/monoleg12.jpg) http://radbruch.roboterbastler.de/monoleg/pics/monoleg08_klein.jpg (http://radbruch.roboterbastler.de/monoleg/pics/monoleg08.jpg)

Gruß

mic

[radbruch]

Ein paar kleine Änderungen und ein neuer "Schuh":

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

(Das orginale 12MB-Filmchen (http://radbruch.roboterbastler.de/monoleg/pics/monoleg_07.mpg))

mic

[robocat]

ich musste beim ersten video schon lachen (weil das so aussah, als würde es in die kamera glotzen), das 2te ist beinahe noch toller :)
als revolutionäres antriebskonzept wird es sich wohl nicht durchsetzen, aber evtl kann man interessante studien über beinbewegungen durchführen, die sich später auch auf hexapods etc anwenden lassen.

gruesse und respekt für die originelle idee

edit: ich wollte noch anerkennend hinzufügen, dass es sehr schön dokumentiert (bauteile, code, bilder) ist. als name würde sich "long john silver" anbieten, oder einfach "stelzfuss" ;)

[Reeper]

Das ist ja jetzt mal der Hammer, toll gemacht!

[chr-mt]

Hi,
sieht wirklich witzig aus, hat so was "lebendiges" ! Tolle Idee!

Gruß
Christopher

[radbruch]

Hallo

Weil ich das ISP immer noch nicht beherrsche, muss weiterhin mein RP6 als Kontroller dienen. Die Servos sind ein tolles Spielzeug:

http://www.youtube.com/v/JFEP0AQLQ08
(Das orginale 15MB-Video (http://radbruch.roboterbastler.de/monoleg/pics/hallo2.mpg))

pic1 (http://radbruch.roboterbastler.de/monoleg/pics/hallo1.jpg) pic2 (http://radbruch.roboterbastler.de/monoleg/pics/hallo2.jpg)

Inzwischen steuert ein 8Bit-Timer die Servos. Der Code ist nun schon etwas aufwendiger, weil ein 5x8-Zeichensatz (http://www.mikrocontroller.net/topic/37603) und ein Sende-UART (zum Debuggen) eingebaut ist:


#include <avr/io.h> // I/O Port definitions
#include <avr/interrupt.h> // Interrupt macros
#include <stdlib.h> // C standard functions (e.g. itoa...)

#define BAUD_LOW 38400 //Low speed - 38.4 kBaud
#define UBRR_BAUD_LOW ((F_CPU/(16*BAUD_LOW))-1)

uint8_t x, y, z, zeile, bit, zeichen, hub=15;
uint16_t i, j;
uint8_t sinustab[128]= {
0,0,0,0,0,0,0,0,1,1,1,2,2,3,3,4,
4,5,6,6,7,8,9,9,10,11,12,13,14,15,16,17,
18,19,21,22,23,24,25,27,28,29,31,32,33,35,36,38,
39,40,42,43,45,46,48,49,51,53,54,56,57,59,60,62,
64,65,67,68,70,71,73,74,76,78,79,81,82,84,85,87,
88,89,91,92,94,95,96,98,99,100,102,103,104,105,106 ,108,
109,110,111,112,113,114,115,116,117,118,118,119,12 0,121,121,122,
123,123,124,124,125,125,126,126,126,127,127,127,12 7,127,127,127
};
// http://www.mikrocontroller.net/topic/37603
// 5x8-Zeichensatz
uint8_t zeichensatz5x8[80*8]=
{
0x00 , 0x00 , 0x0E , 0x01 , 0x0F , 0x11 , 0x0F , 0x00 // a
, 0x10 , 0x10 , 0x1E , 0x11 , 0x11 , 0x11 , 0x1E , 0x00 // b
, 0x00 , 0x00 , 0x0E , 0x11 , 0x10 , 0x11 , 0x0E , 0x00 // c
, 0x01 , 0x01 , 0x0F , 0x11 , 0x11 , 0x11 , 0x0F , 0x00 // d
, 0x00 , 0x00 , 0x0E , 0x11 , 0x1F , 0x10 , 0x0E , 0x00 // e
, 0x06 , 0x08 , 0x08 , 0x1E , 0x08 , 0x08 , 0x08 , 0x00 // f
, 0x00 , 0x00 , 0x0F , 0x11 , 0x11 , 0x0F , 0x01 , 0x0E // g
, 0x10 , 0x10 , 0x1C , 0x12 , 0x12 , 0x12 , 0x12 , 0x00 // h
, 0x04 , 0x00 , 0x04 , 0x04 , 0x04 , 0x04 , 0x04 , 0x00 // i
, 0x02 , 0x00 , 0x06 , 0x02 , 0x02 , 0x02 , 0x12 , 0x0C // j
, 0x10 , 0x10 , 0x12 , 0x14 , 0x18 , 0x14 , 0x12 , 0x00 // k
, 0x04 , 0x04 , 0x04 , 0x04 , 0x04 , 0x04 , 0x06 , 0x00 // l
, 0x00 , 0x00 , 0x1A , 0x15 , 0x15 , 0x11 , 0x11 , 0x00 // m
, 0x00 , 0x00 , 0x1C , 0x12 , 0x12 , 0x12 , 0x12 , 0x00 // n
, 0x00 , 0x00 , 0x0E , 0x11 , 0x11 , 0x11 , 0x0E , 0x00 // o
, 0x00 , 0x00 , 0x1E , 0x11 , 0x11 , 0x11 , 0x1E , 0x10 // p
, 0x00 , 0x00 , 0x0F , 0x11 , 0x11 , 0x11 , 0x0F , 0x01 // q
, 0x00 , 0x00 , 0x16 , 0x09 , 0x08 , 0x08 , 0x1C , 0x00 // r
, 0x00 , 0x00 , 0x0E , 0x10 , 0x0E , 0x01 , 0x0E , 0x00 // s
, 0x00 , 0x08 , 0x1E , 0x08 , 0x08 , 0x0A , 0x04 , 0x00 // t
, 0x00 , 0x00 , 0x12 , 0x12 , 0x12 , 0x16 , 0x0A , 0x00 // u
, 0x00 , 0x00 , 0x11 , 0x11 , 0x11 , 0x0A , 0x04 , 0x00 // v
, 0x00 , 0x00 , 0x11 , 0x11 , 0x15 , 0x1F , 0x0A , 0x00 // w
, 0x00 , 0x00 , 0x12 , 0x12 , 0x0C , 0x12 , 0x12 , 0x00 // x
, 0x00 , 0x00 , 0x12 , 0x12 , 0x12 , 0x0E , 0x04 , 0x18 // y
, 0x00 , 0x00 , 0x1E , 0x02 , 0x0C , 0x10 , 0x1E , 0x00 // z

, 0x0E , 0x11 , 0x11 , 0x1F , 0x11 , 0x11 , 0x11 , 0x00 // A
, 0x1E , 0x11 , 0x11 , 0x1E , 0x11 , 0x11 , 0x1E , 0x00 // B
, 0x0E , 0x11 , 0x10 , 0x10 , 0x10 , 0x11 , 0x0E , 0x00 // C
, 0x1E , 0x11 , 0x11 , 0x11 , 0x11 , 0x11 , 0x1E , 0x00 // D
, 0x1F , 0x10 , 0x10 , 0x1E , 0x10 , 0x10 , 0x1F , 0x00 // E
, 0x1F , 0x10 , 0x10 , 0x1E , 0x10 , 0x10 , 0x10 , 0x00 // F
, 0x0E , 0x11 , 0x10 , 0x17 , 0x11 , 0x11 , 0x0F , 0x00 // G
, 0x11 , 0x11 , 0x11 , 0x1F , 0x11 , 0x11 , 0x11 , 0x00 // H
, 0x0E , 0x04 , 0x04 , 0x04 , 0x04 , 0x04 , 0x0E , 0x00 // I
, 0x01 , 0x01 , 0x01 , 0x01 , 0x11 , 0x11 , 0x0E , 0x00 // J
, 0x11 , 0x12 , 0x14 , 0x18 , 0x14 , 0x12 , 0x11 , 0x00 // K
, 0x10 , 0x10 , 0x10 , 0x10 , 0x10 , 0x10 , 0x1F , 0x00 // L
, 0x11 , 0x1B , 0x15 , 0x11 , 0x11 , 0x11 , 0x11 , 0x00 // M
, 0x11 , 0x19 , 0x15 , 0x13 , 0x11 , 0x11 , 0x11 , 0x00 // N
, 0x0E , 0x11 , 0x11 , 0x11 , 0x11 , 0x11 , 0x0E , 0x00 // O
, 0x1E , 0x11 , 0x11 , 0x1E , 0x10 , 0x10 , 0x10 , 0x00 // P
, 0x0E , 0x11 , 0x11 , 0x11 , 0x15 , 0x12 , 0x0D , 0x00 // Q
, 0x1E , 0x11 , 0x11 , 0x1E , 0x12 , 0x11 , 0x11 , 0x00 // R
, 0x0E , 0x11 , 0x10 , 0x0E , 0x01 , 0x11 , 0x0E , 0x00 // S
, 0x1F , 0x04 , 0x04 , 0x04 , 0x04 , 0x04 , 0x04 , 0x00 // T
, 0x11 , 0x11 , 0x11 , 0x11 , 0x11 , 0x11 , 0x0E , 0x00 // U
, 0x11 , 0x11 , 0x11 , 0x11 , 0x11 , 0x0A , 0x04 , 0x00 // V
, 0x11 , 0x11 , 0x15 , 0x15 , 0x15 , 0x15 , 0x0A , 0x00 // W
, 0x11 , 0x11 , 0x0A , 0x04 , 0x0A , 0x11 , 0x11 , 0x00 // X
, 0x11 , 0x11 , 0x11 , 0x0A , 0x04 , 0x04 , 0x04 , 0x00 // Y
, 0x1E , 0x02 , 0x04 , 0x08 , 0x10 , 0x10 , 0x1E , 0x00 // Z

, 0x0E , 0x11 , 0x13 , 0x15 , 0x19 , 0x11 , 0x0E , 0x00 // 0
, 0x04 , 0x0C , 0x04 , 0x04 , 0x04 , 0x04 , 0x0E , 0x00 // 1
, 0x0E , 0x11 , 0x01 , 0x06 , 0x08 , 0x10 , 0x1F , 0x00 // 2
, 0x0E , 0x11 , 0x01 , 0x0E , 0x01 , 0x11 , 0x0E , 0x00 // 3
, 0x02 , 0x06 , 0x0A , 0x12 , 0x1F , 0x02 , 0x02 , 0x00 // 4
, 0x1F , 0x10 , 0x10 , 0x1E , 0x01 , 0x11 , 0x0E , 0x00 // 5
, 0x06 , 0x08 , 0x10 , 0x1E , 0x11 , 0x11 , 0x0E , 0x00 // 6
, 0x1F , 0x01 , 0x02 , 0x04 , 0x08 , 0x08 , 0x08 , 0x00 // 7
, 0x0E , 0x11 , 0x11 , 0x0E , 0x11 , 0x11 , 0x0E , 0x00 // 8
, 0x0E , 0x11 , 0x11 , 0x0F , 0x01 , 0x02 , 0x0C , 0x00 // 9

, 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 // Space
, 0x04 , 0x0E , 0x0E , 0x04 , 0x04 , 0x00 , 0x04 , 0x00 // !
, 0x1B , 0x1B , 0x12 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 // Anführungszeichen
, 0x00 , 0x0A , 0x1F , 0x0A , 0x0A , 0x1F , 0x0A , 0x00 // #
, 0x08 , 0x0E , 0x10 , 0x0C , 0x02 , 0x1C , 0x04 , 0x00 // $
, 0x19 , 0x19 , 0x02 , 0x04 , 0x08 , 0x13 , 0x13 , 0x00 // %
, 0x08 , 0x14 , 0x14 , 0x08 , 0x15 , 0x12 , 0x0D , 0x00 // &
, 0x0C , 0x0C , 0x08 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 //
, 0x04 , 0x08 , 0x08 , 0x08 , 0x08 , 0x08 , 0x04 , 0x00 //
, 0x08 , 0x04 , 0x04 , 0x04 , 0x04 , 0x04 , 0x08 , 0x00 //
, 0x00 , 0x0A , 0x0E , 0x1F , 0x0E , 0x0A , 0x00 , 0x00 // *
, 0x00 , 0x04 , 0x04 , 0x1F , 0x04 , 0x04 , 0x00 , 0x00 // +
, 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x0C , 0x0C , 0x08 // ,
, 0x00 , 0x00 , 0x00 , 0x1F , 0x00 , 0x00 , 0x00 , 0x00 // -
, 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x0C , 0x0C , 0x00 // .
, 0x00 , 0x01 , 0x02 , 0x04 , 0x08 , 0x10 , 0x00 , 0x00 // /
};

void writeChar(char ch)
{
while (!(UCSRA & (1<<UDRE)));
UDR = (uint8_t)ch;
}
void writeString(char *string)
{
while(*string)
writeChar(*string++);
}
void writeInteger(int16_t number, uint8_t base)
{
char buffer[17];
itoa(number, &buffer[0], base);
writeString(&buffer[0]);
}

void delay(uint16_t d)
{
uint16_t d1, dummy;
for (d1=d; d1>0; d1--) dummy^=d1;
}
void plot(uint8_t zeichen)
{
for (bit=0;bit<7;bit++)
{
for (zeile=0;zeile<7;zeile++)
{
if (zeichensatz5x8[zeichen*8+zeile] & (1<<bit))
{
for (i=0;i<5;i++)
{
for (j=0;j<hub;j++) { y--; x++; delay(200); }
for (j=0;j<hub;j++) { y++; x--; delay(100); }
z++;delay(100);
}
}else{
z+=5; delay(500);
} // zeichensatz
} // zeile
delay(10000);
x=105; delay(10000);
z=110; y=110; delay(10000);

for (j=0;j<hub*2;j++) { y--; x++; delay(500); }
x+=5; z+=3; delay(500);
for (j=0;j<hub*2;j++) { y++; x--; delay(200); }
x=90; z=90; delay(10000);
} // bit
}
void init(void)
{
cli();
// UART:
UBRRH = UBRR_BAUD_LOW >> 8; // Setup UART: Baudrate is Low Speed
UBRRL = (uint8_t) UBRR_BAUD_LOW;
UCSRA = 0x00;
UCSRC = (1<<URSEL)|(1<<UCSZ1)|(1<<UCSZ0);
UCSRB = (1 << TXEN) | (1 << RXEN) | (1 << RXCIE);

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 = 9; // 100kHz?
sei();
}
ISR(TIMER0_COMP_vect)
{
static uint16_t count=0;
if(count>x+16) PORTA &= ~16; else PORTA |= 16; // E_INT1 (Pin8)
if(count>y+20) PORTC &= ~1; else PORTC |= 1; // SCL (Pin10)
if(count>z+24) PORTC &= ~2; else PORTC |= 2; // SDA (Pin12)
if(count<1000)count++; else count=0;
};
int main(void)
{
init();

z=105; y=110; x=90; delay(50000);
z=90; delay(10000);

while(1)
{
plot(14);
plot(11);
plot(11);
plot(0);
plot(7+26);
y=150; delay(10000);
while(1);
} // mainloop

return 0;
}


Beim ersten Versuch das zu filmen ging der Kamera leider der Speicher aus:

http://www.youtube.com/v/jLvOpHuRhxI
(Orginal (http://radbruch.roboterbastler.de/monoleg/pics/hallo1.mpg))

Gruß

mic

[Drifter2006]

Hello,
I have read your description and watched the videos and I must say; “what an inspiration!”. \:D/
Greetings,
Drifter2006

[robocat]

neulich lief musik und das monoleg schien gar nicht so unmusikalisch zu sein.. :D

http://katze.dead-men.de/vid.htm

(ich werde das video natürlich wieder herunternehmen, wenn radbruch etwas dagegen hat)

gruesse

[Razzorhead]

Echt genial das teil, ist hammer lustig dem zuzugucken.
Das mit der musik ist auch cool :P.

Ich dachte erst " was soll das teil den können ", aber es ist echt fein gemacht und hat nette bewegungen!

mfg
Razzor

[avion23]

Das Bein mit seinen drei Achsen (Finger, Arm und Schulter) soll den auf der Stütze stehenden Roboter anheben und bewegen. Das hört sich einfach an, ist aber für einen Realschüler wie mich mathematisch nicht zu lösen. *grummel*
An meinem Gymnasium wären von 90 Abiturienten keiner in der Lage gewesen, das Problem zu lösen. Das Fraunhofer Institut forscht aktuell an dieser Fortbewegungsmethode, und die kriegen es auch nicht 100% hin. Du hast schließlich mehrer MÖglichkeiten, ein Ziel zu erreichen. Du bist also nicht gerade schlecht :)

Und so abwegig ist das Konzept nicht. Ein Bein zu kontrollieren ist einfacher als 6, also ist es eine gute Übung. Und nach KISS: Nur was nicht vorhanden ist, kann nicht kapput gehen :)

[Klingon77]

hi radbruch,

nun machst Du also doch Ernst mit deinem Namen und verabschiedest dich von drehenden Vortriebselementen...?

Feines Projekt!
Bin mal gespannt, wo es hinläuft...

Mal was anderes:
Habe letzens beim Surfen (leider den Link nicht mehr da) einen Zweibeiner gesehen.
Die Füße waren mit Unterdruck-Saugnäpfen versehen.
Die Beine standen in Ruhe wie beim Spagat auseinander.

Lange Rede, kurzer Sinn:
Das Teil ist mit Hilfe der Saugnäpfe prima gelaufen!
Wände, Treppen, Decken - solang halbwegs glatt - kein Problem.

Hat auch toll ausgesehen, so ein "nur-Beiner".

Gruß, Klingon77

[radbruch]

Hallo

Es freut mich sehr, dass euch mein kleines Projekt so viel Freude bereitet. Eigentlich sollte es nur dazu dienen, Servos für einen Roboterarm zu beherrschen. Aber es verselbständigt sich zunehmend. Hier nun der neuste Stand des Projekts.

Nachdem ich lange genug gejammert hatte, wurde mir von der besten Ehefrau von allen ein USB-ISP-Interface genehmigt. *juhu* Das Teil (ein mysmartusb (http://myavr.de/shop/article.php?artDataID=36) für 30€) wurde gestern geliefert. Hier nun die ersten Videos und Pics nach dem Abnabeln vom RP6:

http://img.youtube.com/vi/6ZNNRiDPIao/1.jpg (http://www.youtube.com/watch?v=6ZNNRiDPIao) http://img.youtube.com/vi/dHDhgpYCXm0/2.jpg (http://www.youtube.com/watch?v=dHDhgpYCXm0) http://img.youtube.com/vi/Z7gb-9V5KY4/2.jpg (http://www.youtube.com/watch?v=Z7gb-9V5KY4)
http://www.youtube.com/watch?v=6ZNNRiDPIao
http://www.youtube.com/watch?v=dHDhgpYCXm0
http://www.youtube.com/watch?v=Z7gb-9V5KY4
Orginalvideos: 1 (http://radbruch.roboterbastler.de/monoleg/pics2/monoleg_autark1.mpg) 2 (http://radbruch.roboterbastler.de/monoleg/pics2/monoleg_autark4.mpg) 3 (http://radbruch.roboterbastler.de/monoleg/pics2/monoleg_autark2.mpg) 4 (http://radbruch.roboterbastler.de/monoleg/pics2/monoleg_autark3.mpg)

Nach meinem heutigen ISP- und ATtiny-Marathon steuert nun ein ATtiny13 den Roboter. Bei 1,2MHz CPU-Taktfrequenz werden die Servos mit einer Counter-ISR angesteuert. Der Code hat im Moment 516 Bytes:


#include <avr/io.h>
#include <avr/interrupt.h>

#define x_mitte 17
#define y_mitte 17
#define z_mitte 17

unsigned int x, y, z, demo;

void delay(uint16_t d) // Warteschleife
{
uint16_t d1, dummy;
for (d1=d; d1>0; d1--) dummy^=d1;
}
ISR(TIM0_COMPA_vect) // Servoansteuerung
{
static uint16_t count=0;
if (count>x) PORTB &= ~(1<<PB0); else PORTB |= (1<<PB0);
if (count>y) PORTB &= ~(1<<PB1); else PORTB |= (1<<PB1);
if (count>z) PORTB &= ~(1<<PB2); else PORTB |= (1<<PB2);

if (count < 200) count++; else count=0;
}

int main(void)
{
x=x_mitte; // Servos Basisposition
y=y_mitte;
z=z_mitte;
demo=5; // 5 Einzelschritte

DDRB = (1<<PB2) | (1<<PB1) | (1<<PB0); // Servoausgänge
PORTB= (1<<PB3); // PullUp Taster ein

TCCR0A = (0 << WGM00) | (1 << WGM01); // CTC-Mode
TCCR0A |= (0 << COM0A0) | (0 << COM0A1); // ohne OCR-Pin
TCCR0B = (0 << CS02) | (0 << CS01) | (1 << CS00); // no prescaler
TIMSK0 = (1 << OCIE0A); // Interrupt ein
OCR0A = 50; // nicht wissenschaltliche Frequenz
sei();

while(1)
{
y=y_mitte+4; delay(400); // Schritt
if (demo) while(PINB & (1<<PB3)); // warten auf Taste
for (; x>x_mitte-12; x--)
{
if (x==5) y=y_mitte+7;
if (x==0) y=y_mitte+5;
if (x==-11) y=y_mitte+3;
delay(120+x);
}
x=x_mitte-15; y=y_mitte+4; delay(100);
y=y_mitte; delay(300);
x=x_mitte+5; delay(1000);
if (demo) demo--;
}
return(0);
}

Lager für die Gelenke sind übrigens Reiszwecken:

http://radbruch.roboterbastler.de/monoleg/pics2/PB010027_klein.jpg (http://radbruch.roboterbastler.de/monoleg/pics2/PB010027.JPG)
http://radbruch.roboterbastler.de/monoleg/pics2/PB010023_klein.jpg (http://radbruch.roboterbastler.de/monoleg/pics2/PB010023.JPG) http://radbruch.roboterbastler.de/monoleg/pics2/PB010024_klein.jpg (http://radbruch.roboterbastler.de/monoleg/pics2/PB010024.JPG) http://radbruch.roboterbastler.de/monoleg/pics2/PB010028_klein.jpg (http://radbruch.roboterbastler.de/monoleg/pics2/PB010028.JPG) http://radbruch.roboterbastler.de/monoleg/pics2/PB010029_klein.jpg (http://radbruch.roboterbastler.de/monoleg/pics2/PB010029.JPG)

Gruß

mic

[oberallgeier]

Hei, irre gut. Find ich herrlich kreativ!! Hat das Ding schon einen Namen? z.B. ALFd ?? (A dvanced L octite F ischertechnik design).

Und ich ](*,) popel immer noch mehr oder weniger mit "Trockenübungen" herum ](*,)

[womb@t]

Ist ja geil das Board hab ich auch, und ich Idiot hab noch nicht damit gearbeitet! Ich kann gar nicht glauben was damit alles möglich ist, fetter Respekt. Ne Idee schnell, unkompliziert und vor allem Zweckmäßig umgesetzt.

[radbruch]

Hallo

Ein kleines Update der Steuerplatine:
http://radbruch.roboterbastler.de/monoleg/kippler/kippler_platine_klein.jpg (http://radbruch.roboterbastler.de/monoleg/kippler/kippler_platine.jpg)
- ein 100uF-Kondensator hilft bei schwachen Akkus die Anlaufströme der Servos zu verkraften.
- 2,2k-Widerstände in den Servo-Impuls-Leitungen.
- Zusätzlicher Jumper trennt GND der Servos um ein Zucken beim Flashen zu verhindern.
- gedrehte hohe ISP-Buchsen.
- Testanschluß für zwei weitere Pins.

Diesen "Boxenstopp" nutzte ich noch für einen kleinen Versuch. Ich nenne ihn "Kippler":

http://radbruch.bplaced.net/monoleg/kippler/kippler1_klein.jpg (http://radbruch.bplaced.net/monoleg/kippler/kippler1.jpg) http://radbruch.bplaced.net/monoleg/kippler/kippler2_klein.jpg (http://radbruch.bplaced.net/monoleg/kippler/kippler2.jpg) http://radbruch.bplaced.net/monoleg/kippler/kippler3_klein.jpg (http://radbruch.bplaced.net/monoleg/kippler/kippler3.jpg) http://radbruch.bplaced.net/monoleg/kippler/kippler4_klein.jpg (radbruch.bplaced.net/monoleg/kippler/kippler4.jpg)

Das Teil besteht aus:

- Der Steuerplatine mit ATtiny13
- Zwei kleine und ein großer 5€-Servos
- Vier Akkus(900mA) mit Halter
- 9V-Batterieklipp
- Servoanschlußadapter vom Einbein
- Zwei Schraubdeckel
- Heißkleber (und zwei Kabelbinder weil die Federn im Akkuhalter diesen auseinanderdrücken)

Selbstverständlich gibt's auch wieder ein Video:

http://img.youtube.com/vi/5ZSN3rLdAOM/1.jpg (http://www.youtube.com/watch?v=5ZSN3rLdAOM)
http://www.youtube.com/watch?v=5ZSN3rLdAOM

Hier noch der Code (mit EEProm-Routinen zum Debugen 534Bytes):

// steuert den Wankenden, 1. Versuch
#include <avr/io.h>
#include <avr/interrupt.h>

#define x_mitte 27
#define y_mitte 27
#define z_mitte 25
#define schritt 15
#define kipp 4

unsigned char x, y, z, demo, count;
unsigned char linie_links, linie_rechts;
int eeprom_adr;

void delay(uint16_t d) // Warteschleife
{
uint16_t d1, dummy;
for (d1=d; d1>0; d1--) dummy^=d1;
}

ISR(TIM0_COMPA_vect) // Servoansteuerung
{
if (count>x) PORTB &= ~(1<<PB0); else PORTB |= (1<<PB0);
if (count>y) PORTB &= ~(1<<PB1); else PORTB |= (1<<PB1);
if (count>z) PORTB &= ~(1<<PB2); else PORTB |= (1<<PB2);
if (count < 200) count++; else count=0;
}

void EEPROM_write(unsigned char ucAddress, unsigned char ucData)
{
/* Wait for completion of previous write */
while(EECR & (1<<EEPE));
/* Set Programming mode */
EECR = (0<<EEPM1)|(0>>EEPM0);
/* Set up address and data registers */
EEARL = ucAddress;
EEDR = ucData;
/* Write logical one to EEMPE */
EECR |= (1<<EEMPE);
/* Start eeprom write by setting EEPE */
EECR |= (1<<EEPE);
}

unsigned char EEPROM_read(unsigned char ucAddress)
{
/* Wait for completion of previous write */
while(EECR & (1<<EEPE));
/* Set up address register */
EEARL = ucAddress;
/* Start eeprom read by writing EERE */
EECR |= (1<<EERE);
/* Return data from data register */
return EEDR;
}

int main(void)
{
x=x_mitte; // Servos Basisposition
y=y_mitte;
z=z_mitte;
demo=3; // 5 Einzelschritte
eeprom_adr=2; // ersten Speicherstelle

DDRB = (1<<PB2) | (1<<PB1) | (1<<PB0); // Servoausgänge
PORTB= (1<<PB3); // PullUp Taster ein

TCCR0A = (0 << WGM00) | (1 << WGM01); // CTC-Mode
TCCR0A |= (0 << COM0A0) | (0 << COM0A1); // ohne OCR-Pin
TCCR0B = (0 << CS02) | (0 << CS01) | (1 << CS00); // no prescaler
TIMSK0 = (1 << OCIE0A); // Interrupt ein
OCR0A = 50; // nicht wissenschaltliche Frequenz
sei();

while(PINB & (1<<PB3)); // warten auf Taste
while(1) {
while(z-- > z_mitte-kipp) delay(150);
delay(5000);
y=y_mitte+schritt;
while(x++ < x_mitte+schritt) delay(100);
delay(1000);

while(z++ < z_mitte+kipp) delay(150);
delay(5000);
x=x_mitte-schritt;
while(y-- > y_mitte-schritt) delay(100);
delay(1000);

if(demo) demo--; else
{
while(z-- > z_mitte-kipp) delay(150);
delay(5000);
y=y_mitte+schritt;
delay(1000);

while(z++ < z_mitte+kipp) delay(150);
delay(5000);
x=x_mitte-schritt;
while(y-- > y_mitte-schritt) delay(100);
delay(1000);
demo=3;
}
}
return(0);
}

Gruß

mic

[vajk]

Super Sache!
Der Kippler gefällt mir .. ulkig .. mal was ganz anderes ... Hmmm .. da fehlen dann nur noch kreisende Umgebungssensoren und eine Möglichkeit Hindernisse zu überwinden ... klasse! Viel Spaß weiterhin!

[squelver]

Das is n Spitze Projekt, komme ausm Schmunzeln garnicht mehr raus =D>
Erinnert mich an eine Comicfigur :mrgreen:

[radbruch]

Hallo

Für die Kippler-Fans hier noch ein letztes Video. Ich muss ihn leider wieder zerlegen, weil ich die Teile brauche.
Für Erweiterungen wie Radar oder Fernbedienung ist der tiny13 vermutlich zu klein.

Die kurzen Stopps im Video werden von den 9V-Klipps verursacht; durch Erschütterung kurzer Spannungsausfall. Hier werde ich wohl auf Modelbaustecker umrüsten.

http://img.youtube.com/vi/j334i_YCwoI/2.jpg (http://www.youtube.com/watch?v=j334i_YCwoI)

http://www.youtube.com/watch?v=j334i_YCwoI
Orginales 12MB-mpeg (http://radbruch.roboterbastler.de/monoleg/kippler/kippler1.mpg)

Gruß

mic

[vajk]

Klasse && schade! Bist Du Schotte? So'n geniales Bürschchen töten :-(

[CowZ]

Respekt! Nette Ideen :)

[radbruch]

Hallo

So, nun gibt es erstmal keinen Kippler mehr:
http://radbruch.bplaced.net/monoleg/kippler/kippler5_klein.jpg (http://radbruch.bplaced.net/monoleg/kippler/kippler5.jpg)

Vollendete Tatsachen. So ist es besser für alle beteiligten, bevor ich schwach werde.
Er litt zuletzt auch sehr unter seinem "Schluckauf":
http://img.youtube.com/vi/tyKPINp0ZLY/default.jpg (http://www.youtube.com/watch?v=tyKPINp0ZLY)
http://www.youtube.com/watch?v=tyKPINp0ZLY

Gruß

mic

[squelver]

Bitte in Ehren halten ;)

Vieleicht gibts ja mal nen neuen "Kippler" \:D/

[radbruch]

Hallo

Das "Projekt" schleppt sich dahin:

http://radbruch.bplaced.net/monoleg/pics3/monoleglong1_klein.jpg (http://radbruch.bplaced.net/monoleg/pics3/monoleglong1.jpg) http://radbruch.bplaced.net/monoleg/pics3/monoleglong2_klein.jpg (http://radbruch.bplaced.net/monoleg/pics3/monoleglong2.jpg) http://radbruch.bplaced.net/monoleg/pics3/monoleglong3_klein.jpg (http://radbruch.bplaced.net/monoleg/pics3/monoleglong3.jpg) http://radbruch.bplaced.net/monoleg/pics3/monoleglong4_klein.jpg (http://radbruch.bplaced.net/monoleg/pics3/monoleglong4.jpg)
http://radbruch.bplaced.net/monoleg/pics3/monoleglong5_klein.jpg (http://radbruch.bplaced.net/monoleg/pics3/monoleglong5.jpg) http://radbruch.bplaced.net/monoleg/pics3/monoleglong6_klein.jpg (http://radbruch.bplaced.net/monoleg/pics3/monoleglong6.jpg) http://radbruch.bplaced.net/monoleg/pics3/monoleglong7_klein.jpg (http://radbruch.bplaced.net/monoleg/pics3/monoleglong7.jpg) http://radbruch.bplaced.net/monoleg/pics3/monoleglong8_klein.jpg (http://radbruch.bplaced.net/monoleg/pics3/monoleglong8.jpg)
http://radbruch.bplaced.net/monoleg/pics3/monoleglong9_klein.jpg (http://radbruch.bplaced.net/monoleg/pics3/monoleglong9.jpg)

Drei Anmerkungen dazu:

Ja, ich weiß, dass die untersten Gliedmasen das gesamte Gewicht tragen müssen, aber ein "Klumpfuss" würde nicht so schick aussehen.

Mit der RC-Anlage wird das Ding gesteuert. Lenkung steuert direkt das Schulterservo, Gas wird mal verschiedene Gangarten steuern, im Moment kann er allerdings nur hopsen am RP6.

Die Beine sind nicht spiegelbildlich. So aufgebaut bewegen sich die Servos beider Beine (soll ich nun den Titel ändern?) in dieselbe Richtung und können mit dem selben Ablauf der Bewegungen angesteuert werden. Da ich im Moment mit dem tiny13 nur drei Servos ansteuern kann, geht mit diesem Aufbau nur ein unelegantes Gehopse mit parallel geschalteten Beinen. Das wollte ich euch aber nicht zumuten und habe es deshalb auch nicht gefilmt.

Nebenbei suche ich ja noch immer das ideale Fahrwerk für meinen ersten selbstgebauten Roboter. Hier ein unterbelichteter Vorkucker:

http://img.youtube.com/vi/KSroFM-yrv0/1.jpg (http://www.youtube.com/watch?v=KSroFM-yrv0)
http://www.youtube.com/watch?v=KSroFM-yrv0

Beim Ausschlachten des RC-Car sind mir auch zwei Servos in die Hände gefallen. Kunstoffgetriebe und Achse mit Gleitlager, da konnte ich nicht widerstehen und mußte mal das Hacken ausprobieren:

http://img.youtube.com/vi/Q2tggwy7uhU/3.jpg (http://www.youtube.com/watch?v=Q2tggwy7uhU)
http://www.youtube.com/watch?v=Q2tggwy7uhU


Die beiden Potis sind die Drehwinkelgeber der gehackten Servos. So kann man den "Nullpunkt" der Servos abgleichen.

Gruß

mic

[vajk]

Also eines ist sicher, Humor und Erfindungsgeist Dein Eigen Du nennen kannst! Genial! Wenn das erste vid auch eine Maus sein könnte, der Du was mit blauer LED an den Schweif gebunden hast :-)

[radbruch]

Hallo

Nein, es ist natürlich keine Maus mit angebundener LED. Und es sind natürlich auch keine Omniwheels, es sind Mecanum-Räder (http://de.wikipedia.org/wiki/Mecanum-Rad) (bzw. sollen es mal werden):

http://radbruch.bplaced.net/monoleg/pics3/mecanumrad1_klein.jpg (http://radbruch.bplaced.net/monoleg/pics3/mecanumrad1.jpg) http://radbruch.bplaced.net/monoleg/pics3/mecanumrad2_klein.jpg (http://radbruch.bplaced.net/monoleg/pics3/mecanumrad2.jpg) http://radbruch.bplaced.net/monoleg/pics3/mecanumrad3_klein.jpg (http://radbruch.bplaced.net/monoleg/pics3/mecanumrad3.jpg)
Blöderweise funktioniert es mit nur zwei Rädern nicht, weil die vor-zurück-Kräfte deutlich größer als die zurseite-Kräfte sind. Mit zwei Rädern und Stütze fährt es fast so wie das Scheibenräderteil. Weil im Lego der Kids keine kleinen Rollen mehr zu finden sind (und ich grad kein Geld dafür übrig habe) sind die Versuchsräder erstmal eingemottet.

Funktionsprinzip:
http://www.miag.de/Produkte/OCS/Mecanumrad/mecanumrad.html

Anwendungsbeispiele:
http://auto.pege.org/2006-ever-monaco/rollstuhl.htm
http://airtrax.com/

Beispiel Kleinroboterfahrwerk bei youtube:
http://img.youtube.com/vi/aXdvLGTW2nQ/default.jpg (http://www.youtube.com/watch?v=aXdvLGTW2nQ)

Mehr Videos:
http://www.youtube.com/results?search_query=Mecanum

Das scheint mir auch ein interessantes Antriebskonzept zu sein.

mic

[Manf]

Wie immer sehr interessant, ganz am Ende suchen wir mal nach einer Überschrift für den Thread. O:)
Das Rad-Prinzip ist interessant und besonders beim Gabelstapler wie auch beim Rollstuhl sieht es sehr überzeugend aus, die Nachbau Ausführung wird noch nicht ganz so gut gehen.

Wie wäre es mit lenkbaren Omiwheels oder Mecanum-Rädern als Getriebe?,
immerhin wäre es stufenlos und mit nach oben offener Geschwindigkeit.
Manfred

[HannoHupmann]

Das Prinzip hab ich schon vor Jahren gesehen, nur leider nie nen Händler gefunden der solche Räder verkauft. Nur die klassischen OmniRäder findet man überall.

[squelver]

Deine Projekte sind Klasse, musste glatt schmunzeln :mrgreen:
Wie schon angesprochen wurde, ist dein Ideenreichtum sehr ausgeprägt, wobei ich denke, wenn du mehr Möglichkeiten (Geld/Material/Zeit) hättest, dann würdest du sicher richtig aus dir rausgehen \:D/

[KJJ]

:shock: compliment also ich bin grade dabei einen "primitiven" Roboter zu bauen und ich mus einfach mal sagen zimlich gute arbeit

[Kroate]

Also finde deine Ideen ziemlich geil. Vorallem hat es mir der "Kippler" angetan. Finde das Teil echt witzig und ich glaube ich Bau es mal und entwickle die Idee weiter :) ...dar ich doch oder?? ;)

MFG Kroate

[roboterzwerg]

mich würde der schaltplan interessieren kanst du dehn mal hir reinstellen sehr interssanet. ich meine den von dem klipper sieht total lustig aus des gerät.

[radbruch]

mich würde der schaltplan interessieren
Schaltplan von was? Im Prinzip ist es immer die gleiche Schaltung und Technik: Pin auf Servo-Eingang. Beim RP6 mit 10k-PullDowns am Pin (weil die schon so verschaltet sind) und beim tiny13 jeweils ein 2,2k zwischen Pin und Servoeingang. Die Servos sind einfach genial.

Der Kippler wird von dieser teilbestückten Platine gesteuert:
http://www.loetstelle.net/projekte/tinydil/tinydil.php (nur der Schaltplan) (http://www.loetstelle.net/content/projekte/tinydil/images/sch.gif)

R1, R2 und R3 sind die 2,2k-Widerstände, die Servos werden anstelle der Transistoren an deren Basis angeschlossen. R5 hat 10k für den Reset-Pin zur Unterstützung des internen PullUps. C1 hat 100nF zum Schutz des tiny13. Den Spannungsregeler habe ich durch einen Schalter und einen parallelen 100nF-Kondensator zwischen IN und OUT ersetzt, weil ich das mit Akkus betreibe (Batterien wären tödlich!!). Zwischen Akkus und IN ist noch eine Diode um die Batteriespannung sicher unter 5,5V zu halten. Zusätzlich ist noch ein 100 uF-Kondensator nach dem Schalter zwischen + und - geschaltet um die Stromspitzen der Servos abzufangen. Spannung für die Servos geht nach dem Schalter ab. Letztlich sind noch der Taster und die ISP-Schnittstelle auf dem Board, das war's aber schon. Ein Bild davon gibt's weiter oben im Thread. (Ein Bild meiner aktuellen 5-Servo-Platine gibt's in Kürze)


...darf ich doch oder??
Na klar, das ist quasi open-source und eigentlich nur ein "Abfallprodukt" meiner Suche nach dem idealen Fahrwerk.

Ich versuche mir die Grundlagen anzueignen. Manche Dinge ergeben sich einfach zwangsläufig als Folge neuer Erkenntnisse. Und ich versuche, möglichst einfache Materialien zu verwenden um meinen Geldbeutel zu schonen und den Nachbau zu erleichtern.

mic

[olee]

Ich find diesen Kippler auch einfach genjal

GROßES Lob

[Günter49]

@ HannoHupmann
für schlappe 375$ kriegst du hier welche:
http://store.andymark.biz/am-0083.html

Gruß, Günter

[Kroate]

Wo hast du die Servos eigentlich gekauft?? :)

MFG Kroate

[radbruch]

Hallo

Die 5€-Servos gibts beim Conrad in Mini und Normal. Beide Ausführungen haben fast die selbe Kraft...

Zwischenstand des "Projekts":

Kontrollerplatine auf 5 Servos erweitert, sub-D-Stecksystem eingebaut, Redesign des monolegs, jetzt als langbein unterwegs:

http://img.youtube.com/vi/jfNy6m57-q0/default.jpg (http://www.youtube.com/watch?v=jfNy6m57-q0)
http://www.youtube.com/watch?v=jfNy6m57-q0

Ausführliche Doku und erste Schritte folgen in Kürze.

Ein glücklicher Zufall hat mir heute 8 echte Omniwheels zugespielt. Aus den 48 Tonnenrollen werde ich wohl meine Mecanum-Räder basteln. Aber zuvor noch ein kleiner Test mit einem stupiden Demo:

http://img.youtube.com/vi/wIwsT-f-TYU/default.jpg (http://www.youtube.com/watch?v=wIwsT-f-TYU)
http://www.youtube.com/watch?v=wIwsT-f-TYU

mic

[HannoHupmann]

@Günther Danke, bischen teuer leider, aber dafür hübsch grosse Dinger (für den Preis sehen sie aber leider auch noch sch... aus)

[vajk]

'radi' Du bist echt klasse ... einstein wohnte nicht zufällig bei euch um die Ecke ;-)

.. was wird das erst, wenn Du die Welt der Quadcopter entdeckst .. ***schubs***

[radbruch]

Hallo

So wird das langbein nie laufen lernen, aber das wollte ich auch schon immer mal versuchen:

http://radbruch.bplaced.net/rp6/mecanum-rp6/mecanum-rp6_1_klein.jpg (http://radbruch.bplaced.net/rp6/mecanum-rp6/mecanum-rp6_1.jpg) http://radbruch.bplaced.net/rp6/mecanum-rp6/mecanum-rp6_2_klein.jpg (http://radbruch.bplaced.net/rp6/mecanum-rp6/mecanum-rp6_2.jpg) http://radbruch.bplaced.net/rp6/mecanum-rp6/mecanum-rp6_3_klein.jpg (http://radbruch.bplaced.net/rp6/mecanum-rp6/mecanum-rp6_3.jpg)
http://radbruch.bplaced.net/rp6/mecanum-rp6/mecanum-rp6_4_klein.jpg (http://radbruch.bplaced.net/rp6/mecanum-rp6/mecanum-rp6_4.jpg) http://radbruch.bplaced.net/rp6/mecanum-rp6/mecanum-rp6_5_klein.jpg (http://radbruch.bplaced.net/rp6/mecanum-rp6/mecanum-rp6_5.jpg)

Nach ein paar Versuchen sieht das Ergebniss nun recht vielversprechend aus. Benötigt werden Hasenstallgitter, die Rollen aus den Omniwheels (die es auch lose zu kaufen gibt) und ein paar Zangen. Bei Bedarf könnte man noch ein paar Streben reinlöten. Anstatt der geplanten 12 Rollen pro Rad sind es nun nur 7. So sind die Räder etwas kleiner und ich habe genug Rollen um die drei schon verbauten Omniräder zu verschonen. Jetzt fehlt nur noch ein passender Antrieb...

Gruß
mic

[Klingon77]

hi radbruch,

Deine Versuche finde ich sehr inspirierend. :idea:

in den letzten Fotos machst du Deinem Namen alle Ehre. Die schönen Omniwheels zerlegt... :cry:

Nein, Spass beiseite!

Wenn Du irgendwo sechskant-Stangenmaterial mit geeigneter Schlüsselweite auftreiben kannst (z.B: aus Kunststoff) könntest Du die Rollen evtl. mit U-Winkel aus Alu daran befestigen.

Die Durchmesserabweichung sollte stark reduziert werden - den Rundlauf also verbessern.

Der Neigungswinkel der Rollen könnte man in bestimmten Grenzen auch einstellen (sofern die U-Winkel mit einer zentralen Schraube auf dem Sechskant befestigt werden).

liebe Grüße,

Klingon77

[radbruch]

Hallo

So in der Richtung hatte ich mir das gedacht:

http://radbruch.bplaced.net/rp6/mecanum-rp6/mecanum-rp6_6_klein.jpg (http://radbruch.bplaced.net/rp6/mecanum-rp6/mecanum-rp6_6.jpg) http://radbruch.bplaced.net/rp6/mecanum-rp6/mecanum-rp6_7_klein.jpg (http://radbruch.bplaced.net/rp6/mecanum-rp6/mecanum-rp6_7.jpg) http://radbruch.bplaced.net/rp6/mecanum-rp6/mecanum-rp6_8_klein.jpg (http://radbruch.bplaced.net/rp6/mecanum-rp6/mecanum-rp6_8.jpg) http://radbruch.bplaced.net/rp6/mecanum-rp6/mecanum-rp6_9_klein.jpg (http://radbruch.bplaced.net/rp6/mecanum-rp6/mecanum-rp6_9.jpg)

Aber so wirklich funktioniert es noch nicht, die Räder sind wohl noch zu unrund:

http://img.youtube.com/vi/4iHfCrslCZo/default.jpg (http://www.youtube.com/watch?v=4iHfCrslCZo) http://img.youtube.com/vi/622prENvZwA/default.jpg (http://www.youtube.com/watch?v=622prENvZwA)
http://www.youtube.com/watch?v=4iHfCrslCZo
http://www.youtube.com/watch?v=622prENvZwA

Da ich die Achsen nur mit roher Gewalt aus den Rollen rausbekomme, muss die Halterung einen Ein-/Ausbau der Rollen mit Achse ermöglichen. Das ist mit Aluprofil nicht so einfach zu verwirklichen.

mic

[Klingon77]

hi,

damit sie besser rund laufen bräuchtest Du die Rollen zwei mal nebeneinander.

Dabei müssten sie so versetzt werden, daß die zweite Reihe immer mit einer Rolle auf dem Boden aufliegt, wenn die erste Reihe so steht, daß zwei Rollen den Boden gleichzeitig berühren.

Das vor- und zurückfahren beim eigendlichen querverfahren resultiert wohl aus der unterschiedlichen "Lagerreibung" der Rollen am Rad und dem unterschiedlichen Abstand der Rollen zum Boden.

Wenn es "nur" eine Studie sein soll, wäre ich damit schon sehr zufrieden.

Mit einfachsten Mitteln, ohne große Kosten einen wirklich guten Erfolg erziehlt.

Wenn es aber eine dauerhafte Anwendung werden soll, würde ich die Rollen mechanisch optimieren.

Du müsstest auch auf die Servolagerung achten.
Die zulässigen Radialkräfte sollten auf Dauer nicht überschritten werden.

liebe Grüße, Klingon77

...der immer wieder beeindruckt ist, mit welcher Geschwindigkeit Du tolle Ideen umsetzt.

Bei mir dauert das immer "ewig", bis was "aus der Maschine fällt"

[radbruch]

Bei mir dauert das immer "ewig", bis was "aus der Maschine fällt"
Dafür sind deine Werke auch handwerklich vorbildlich...

Das soll natürlich erstmal nur eine kleine Studie sein. Ich bin mir nicht sicher ob das zu erwartende Ergebniss den großen Aufwand an Mechanik und Software rechtfertigt. Das Mecanum-sliden sieht zwar sehr geschmeidig aus und ermöglicht einem kamerageführten Greifarm große Beweglichkeit (besser wäre wohl nur noch ein Luftkissen), aber ein einfaches zweirädriges Fahrwerk mit Stützrolle (wie beim Gabelstabler) ist auch sehr beweglich und erheblich einfacher aufzubauen und zu steuern.

btw ist das Steuern der Beine mit einem tiny13 auch nicht so einfach. Zum einen ist da das mathematische Problem. Ich werde die Beine wohl in Dreiecke zerlegen und über trigonomische (integer-)Funktionen die Bewegung des Aufsetzpunktes auf dem Boden errechnen. Zum anderen ist es in dem tiny schon recht eng. Mit internen 9,6MHz-Takt ist er zwar flott, aber mit 1k flash und je 64bytes ram/eeprom ist sehr wenig Platz für komplizierte Formeln oder vorberechnete Bewegungsabläufe.

mic

[oberallgeier]

Hi, mic,


... über trigonomische (integer-)Funktionen ...
Zu Zeiten von Z80 hatte ich das Problem mit Rechengeschwindigkeit und transzendenten wie z.B: trigonometrischen Funktionen. Bei den Winkelfunktionen (hier: bei Koordinatentransformationen) hatte ich mich mit dem Pythagoras gerettet. Mit ein bisschen Grips ging das prächtig, ich musste nur eine Wurzel berechnen. Und hatte tatsächlich einen bedeutenden Geschwindigkeitsvorteil gegenüber den Kollegen die "einfach" mit den Winkelfunktionen gerechnet hatten.

Aber für den tiny13, fürchte ich, ist das alles etwas viel. Denn dummerweise wird üblicherweise in der numerischen Mathematik auf digitalen Rechnern die Wurzel auf logarithmischen Rechenwegen bestimmt. Und der Logarithmus ist schon wieder transzendent - sprich: er braucht ewig lange Rechenzeit.

Daher bewundere ich auch Deine Roboter schon von dieser Seite :) - also ich bewundere Deine Lösung und keinesfalls die Mathematik, die vielleicht dahinter steckt :)

[recycle]

Das Mecanum-sliden sieht zwar sehr geschmeidig aus und ermöglicht einem kamerageführten Greifarm große Beweglichkeit...

Mehr als ein "Dreibein" mit Omniwheels?


Zum anderen ist es in dem tiny schon recht eng. Mit internen 9,6MHz-Takt ist er zwar flott, aber mit 1k flash und je 64bytes ram/eeprom ist sehr wenig Platz für komplizierte Formeln oder vorberechnete Bewegungsabläufe.

So entschlossen wie du alleine hier in diesem Thread mal eben was auseinandernimmst und zu etwas völlig anderem zusammenzauberst, klingt das für deinen RP6 mit seinem ATMega 16 ziemlich gefährlich ;-)

[radbruch]

Hallo

Das ist wohl auch ein Grund für die vielen Basteleien, ich drücke mich vor der Progammierung. 8-[

Nur mit dem Pythagoras wird das umständlich zu rechnen sein. Ich dachte an eine kleine Sinustabelle und 8-Bit-Rechenfunktionen.


Mehr als ein "Dreibein" mit Omniwheels?
Von der Beweglichkeit gleichwertig. Der dreibeinige omniwheeler ist natürlich mathematisch auch fürchterlich. Aber mechanisch bestechend einfach. Vor allem muss man sich von den gewohnten absoluten Positionen verabschieden und fährt dann quasi "auf Sicht" mit der Kamera. Ob das auch so funktioniert wie ich es mir vorstelle wird sich zeigen. Weil ich als Plattform dafür den 4-rädrigen RP6 geplant habe, wäre ein Mecanum-Fahrwerk meine erste Wahl. Vielleicht bringt die klingonische Lösung mit den doppelreihigen Rollen die Wende im Fahrverhalten meiner selbstgebauten Räder...

Den RP6 (der hat übrigens einen 8MHz-ATMega32 an Bord) werde ich vorläufig verschonen. Falls es mit dem tiny13 überhaupt nicht funktionieren sollte, werde ich zu einem tiny45 wechseln. Die 8-Pinner sind so herrlich übersichtlich und als Einstiegskontroller genial. Außerdem passen die 5 Ausgänge super zu den 5 Servos des monolegs.

Wenn er dann mal laufen kann (letztes Ziel ist im Moment RC-gelenkt mit verschieden Gangarten/Schrittweiten/Schrittgeschwindigkeiten, daraus wiederrum könnte dann noch ein Mischer der RC-Signale für den omniwheeler entstehen...) werde ich mich wieder mehr mit dem RP6 beschäftigen. Durch seinen UART und den Bootlader ist er viel bequemer zu programieren und zu debugen wie die tinys.

Das Programmieren in Assembler habe ich aus dem Projekt gestrichen weil auch in C recht schlanker und schneller Code erzeugt werden kann. Möglicherweise reicht das zum Laufen lernen aus.

Gruß

mic

[vajk]

... nimm doch einen mega32 oder größer .. mehr an Ausgängen usw. und Bootloader gibts für alle im Netz zu finden .. ich nutze den hier http://www.lochraster.org/foodloader/, hab auch eine Variante für den 128er von fd0 bekommen :-) Vorallem, er liegt im Quellcode in C vor ...

Deine DreibeinBiWheel-Variante ist super inspirierend ...

[oberallgeier]

Hallo mic,

wenn ich das bisher richtig sehe, fährtst Du öfters mit Servos als Antrieb. Offenbar auch mit dem Billigservo von Conrad (das ich hier vor Ort fürs Doppelte gekauft hatte). Wie lange fahren Deine Servos durch? Ungefähr, in Minuten oder Stunden? Mit welcher Spannung und Stromstärke. Ok, die Spannung macht das Batteriepack, oder? Wie lange hält das?

Ich frage, weil meine "aufgebohrten" Servos nach etwa fünf Minuten bei 5V und maximal angelieferten 0,4A pro Servo stottern und danach stehenbleiben. Vermutlich wegen Überhitzung !?!?

Wie sieht das bei Dir aus?

[radbruch]

Hallo


... nimm doch einen mega32 oder größer ..
Das ist ja nicht Sinn der Übung. Ich wollte mich langsam rantasten, erst ISP beherrschen und mich dann über einen tiny26/2313 zu mehr Pins "hocharbeiten". Außerdem wollte ich dem monoleg noch ein eigenes Steuerplatinchen auf Lochstreifenbasis mit einem tiny13 spendieren.


Ich frage, weil meine "aufgebohrten" Servos nach etwa fünf Minuten ... stottern und danach stehenbleiben. Wie sieht das bei Dir aus?
Dazu kann ich nicht viel sagen. Meine Modelle laufen immer nur ein paar Minuten ohne Unterbrechung. Dabei halten die Akkus aber recht lange. Im Modellbau werden gehackte Servos häufig als einfache und billige Getriebemotoren eingesetzt. Ein RC-Modell (ein Autole oder ein Flieger) fährt aber auch 10-20 Minuten am Stück ohne dass die Servos, trotz ständigen Lastwechsel und Stößen, den Geist aufgeben. Hast du keine RC-Anlage mit der du die Servos mal im Dauerlauf testen könntest. Vielleicht hat deine Ansteuerung ein Problem. (Unbedingt mal anschauen: http://www.goetzbirkner.de. Tolle Mechaniktipps und unter [Elektronik und Werkstatttipps] --> [Servo als Getriebemotor] eine Anleitung zum Servohacken mit einstellbarem "Totpunkt")

Bei den Mecanum-Räder habe ich nun einen neuen Anlauf gestartet. Doppelte Rollenreihen können aus Kosten- und Gewichtsgründen nicht die Lösung sein. Mein neuer Ansatz: Mit einem größeren Durchmesser und mehr Rollen überschneiden sich nun die Berührungen der Rollen auf dem Boden. Das funktioniert aber auch noch nicht richtig, weil der Längsradius der Tonnenrollen zu klein ist, da sind die Legoräder fast gleichwertig.

Nach drei Stunden hatte ich diesen Prototyp aus einer (vollen) Katzenfutterdose, dem Kabelkanalrest von der Dominorutsche und etwas Heiskleber fertiggestellt:

http://img.youtube.com/vi/uezSq_QWPWQ/1.jpg (http://www.youtube.com/watch?v=uezSq_QWPWQ) http://img.youtube.com/vi/5kzZEld3ZlM/1.jpg (http://www.youtube.com/watch?v=5kzZEld3ZlM) http://img.youtube.com/vi/kMvZbL0RfDU/2.jpg (http://www.youtube.com/watch?v=kMvZbL0RfDU) http://img.youtube.com/vi/VRCkhUtZSGQ/3.jpg (http://www.youtube.com/watch?v=VRCkhUtZSGQ)
http://www.youtube.com/watch?v=uezSq_QWPWQ
http://www.youtube.com/watch?v=5kzZEld3ZlM
http://www.youtube.com/watch?v=kMvZbL0RfDU
http://www.youtube.com/watch?v=uezSq_QWPWQ
(mit Teppich fährt's sich deutlich besser http://radbruch.roboterbastler.de/pics/smilies/smile.gif)


Wirklich spannend sind die Stellen an denen beim Drehen nur zwei Räder angetrieben werden. Hier sieht man schön wie er schwenken würde, wenn die Drehzahlen der Räder stimmen. Der Synchronlauf zwischen Servos und RP6-Antrieb ist auch noch das größte Problem. Aber da könnte die Lösung schon gefunden sein: Im RP6 sind vier Antriebe vorgesehen, die Getriebegehäuse zum Antrieb der Leerlaufrollen sind im Fahrwerk schon vorhanden, aber nicht bestückt. Vielleicht kann ich irgendwie die zusätzlich benötigten Motoren und Getriebeteile "besorgen". Dann wäre der RP6 die optimale Plattform für einen Mecanum-Antrieb!

Gruß

mic

[Klingon77]

hi,

So hatte ich mir die Radbefestigung eingangs vorgestellt.

habe nun mal ein wenig rumgelesen und das mit dem Mecanum-Rad wohl verstanden.

Der Trick mit dem Rad scheint der zu sein, den Rad-Außendurchmesser in Kombination mit der Laufrollenwölbung und dem Winkel der Laufrollen zur Achse so zu wählen, daß unabhängig von der Radstellung immer mindestens eine Laufrolle an einer Stelle den Boden berührt.

Dann benötigt man keine zweite Laufrollenanordnung.

Das Rad läuft sauber über den Boden.

Wieder was gelernt! Vielen Dank! :idea: :mrgreen:

Gruß und weiterhin gutes Gelingen!

Klingon77

[oberallgeier]

...Der Trick mit dem Rad ... Kombination mit der Laufrollenwölbung und dem Winkel ... zur Achse ...
Stimmt - die Achsen der Laufrollen bilden Mantellinien zu einem einschaligen Hyperboloid
http://de.wikipedia.org/wiki/Hyperboloid
und daher gibts zur konstruktiven Ausgestaltung bei bestehender Tonnenwölbung nur noch wenige Freiheitsgrade. Eigentlich garkeine - denn wenn der Achswinkel nicht exakt stimmt, dann bildet die Umfangslinie der Laufrollen eine Ellipse - und das ganze Rad hoppelt auf einer Multi-Ellipsen-Hüllkurve.

[HannoHupmann]

Weis einer schon in welchem Winkel genüber der Hauptachse die kleinen Laufrollen am Rad befestigt werden? Ist das 45°?

[Manf]

Weis einer schon in welchem Winkel genüber der Hauptachse die kleinen Laufrollen am Rad befestigt werden? Ist das 45°?
Bei 90° entspräche das dann Omniwheels und das Fahrzeug könnte in Querrichtung frei rollen. Bei 0° könnte das Fahrzeug in Längsrichtung frei rollen. Um sich von beiden Fällen möglichst weit abzusetzen wird wohl 45° die beste Lösung sein. Ein abweichender und für alle Räder gleicher Winkel ist sicher möglich, sollte aber keinen Vorteil haben, er wird das Spiel vergrößern.


aus einer (vollen) Katzenfutterdose ... und etwas Heiskleber
genau

[radbruch]

..die Achsen der Laufrollen bilden Mantellinien zu einem einschaligen Hyperboloid
Na wunderbar, ich hatte keine Ahung dass ich sowas kann. Mit mathematischen Grundlagen kann ich leider nicht dienen.

Ein Rollenwinkel von 45° dürfte optimal sein. Das Futterdosenrad scheint zu funktionieren. Ich werde nun die "Großserienproduktion" starten (50 Haltebügel) und erwarte dadurch noch eine Verbesserung durch geringere Massabweichung der einzelnen Teile.

mic

[olee]

Viel glück dann mal

[Klingon77]

hi,

stimmt denn auch Dein Rad-Außendurchmesser zur Wölbund der Laufrollen unter dem angegebenen Winkel der Laufrollen?

liebe Grüße, Klingon77

[HannoHupmann]

Eine Frage noch @radbruch du hast gesagt die Achsen der Laufrollen wären fest, haben die innen ein Kugellager oder dreht sich die Rolle in der Befestigung. Sprich ist die Achse starr oder dreht die sich?

[radbruch]

Hallo


stimmt denn auch Dein Rad-Außendurchmesser ....
Nein. Die Rollen sind aus den omniwheeels und haben einen Längsradius der zu den 48mm Durchmesser dieser Räder passt. (Datenblatt Seite 3 (http://radbruch.roboterbastler.de/rp6/mecanum-rp6/interroll_omniwheels.pdf)). Dadurch hebt und senkt sich das Rad wenn der Berührungspunkt der Rolle von dünn auf dick und zurück wandert. Der selbe Effekt, allerdings in entgegengesetzter Richtung, tritt auch bei den Legorädchen auf. Diese sind wie zylindrische Rollen anzusehen und haben beim Aufsetzen einen größeren Abstand zum Mittelpunkt des gesamten Rades als beim Abrollen. Das wirkt sich aber mit zunehmenden Durchmesser des Rades nicht mehr so stark aus. Ich vermute, man kann auch funktionierende große Räder mit einfacher zu beschaffenden zylindrischen Rollen bauen. Dieser Aufbau mit den einzelnen Haltern war auch meine erste Idee, aber der für meine Verhältnisse recht große Aufwand schreckte mich davon ab.


Sprich ist die Achse starr oder dreht die sich?
Die Achse ist fest in der Rolle und beides zusammen dreht sich in der Halterung. Meine Halter sind etwas breiter als die Rollen, deshalb passen da noch gut ein paar Schleissscheiben dazwischen.

Ich bin eigentlich sehr zuversichtlich dass dieser Aufbau die gewünschten Fahreigenschaften hat. Auf den Teppichvideos kann man das seitlich fahren mehr als erahnen (ich sollte mal das Demo ändern). Verblüfft bin ich auch von der Wiederholgenauigkeit der Drehungen des gesamten Roboters mit diesem gemischten Rädersatz. Die Räder sind natürlich in erster Linie für einen Innenraum-Kleinroboter (der RP6-Klasse) ausgelegt.

mic

[HannoHupmann]

alles klar danke, damit hab ich alle Daten um bei zeiten meine eigenen marcanium Räder zu konstruieren. Muss mich nur noch um ein paar Omnidirektionale Räder Samples bemühen. Aber auch dafür hab ich schon eine Idee.

[Roberto]

Hallo Mic
Glückwunsch zu deinen NICHT üblichen Konstruktionen ;-)

Finde sie zwar nicht sonderlich effizient in der Fortbewegung aber auf diese Ideen muss man auch mal kommen :)

Lese interessiert weiter
l.G. Roberto

[radbruch]

Zufällig gefunden:

http://www.youtube.com/watch?v=l4A48AoA2Vg
http://letsmakerobots.com/node/19165

[vajk]

der hier ist goil: http://www.youtube.com/watch?v=jBRLAcDIGR8

[MArc_]

Ich frage, weil meine "aufgebohrten" Servos nach etwa fünf Minuten bei 5V und maximal angelieferten 0,4A pro Servo stottern und danach stehenbleiben. Vermutlich wegen Überhitzung !?!?

Hey Oberallgeier,

was meinst du denn mit aufgebohrt ?
Ich selbst nutzte oft sehr günstige Servos von diesem Lieferant:
Hobbyking.com (http://hobbyking.com/hobbyking/store/uh_listCategoriesAndProducts.asp?catname=Turnigy+S ervo&idCategory=286&ParentCat=189)
Habe die auch teilweise in Modellflugzeugen und die laufen, und laufen, und laufen ... Mir ist noch nicht untergekommen, dass die überhitzt sind oder sogar einfach stehenbleiben. (Wobei meine Nutzungsdauer max 1H durchgehend ist, dann ist Akku leer : D )
Ich würde schätzen, dass deine Servos defekt sind oder es liegt an dem "aufgebohrten", was auch immer das heißt ?

[oberallgeier]

Hallo MArc,

danke für Deinen Lieferantennachweislink. So etwas ist immer gut zu wissen.
... was meinst du denn mit aufgebohrt ...Als ich noch nicht viel - ähhhh - noch viel weniger als jetzt - von Ser vos verstand, hatte ich die auf Endlosdrehen umgebaut (interne Anschläge entfernt, Poti entkuppelt und auf Mittelstellung). Einsatzaufgabe waren zwei Stück als Antrieb eines Zweirädrers. Dabei war die Laufzeit gering, das entsprach auch etlichen Postings, die ich damals gelesen hatte. Fazit: meine Fehlersuche. (https://www.roboternetz.de/phpBB2/viewtopic.php?p=437282#437282) In der Folge hatte ich die Elektronik komplett entfernt (sprich "Hack 2" (http://www.rn-wissen.de/index.php/Servo#Servos_hacken) - so hatte ich das im RN-Wissen genannt oder hier (https://www.roboternetz.de/phpBB2/viewtopic.php?p=516553#516553)), eine Gabellichtschranke eingebaut und die Ser vos als reine Getrie bemotoren benutzt. So laufen sie in meinen autonomen Döschen (https://www.roboternetz.de/phpBB2/viewtopic.php?t=40507) und laufen und laufen und . . . . Ich bin also mit den bei mir vorhandenen Billigdingern absolut zufrieden. Allerdings: es sind eben keine "richtigen" Ser vos mehr.


... was auch immer das heißt ...Wie gesagt, damals hatte ich noch mehr Lernbedarf als heute. Das ist mittlerweile über drei Jahre her. Ungehackt nutze ich derzeit nur ein Stück im Deckel meines MiniD0. (https://www.roboternetz.de/phpBB2/viewtopic.php?p=514969#514969)

[MArc_]

Hey oberallgeier,

oh pardon, hatte garnicht gesehen, dass deine Antwort schon 3 Jahre alt ist : )
Dann ist natürlich der Versuch hinterfällig Dir zu antworten.

[inka]

Der Synchronlauf zwischen Servos und RP6-Antrieb ist auch noch das größte Problem. Aber da könnte die Lösung schon gefunden sein: Im RP6 sind vier Antriebe vorgesehen, die Getriebegehäuse zum Antrieb der Leerlaufrollen sind im Fahrwerk schon vorhanden, aber nicht bestückt. Vielleicht kann ich irgendwie die zusätzlich benötigten Motoren und Getriebeteile "besorgen". Dann wäre der RP6 die optimale Plattform für einen Mecanum-Antrieb!

hallo mic,

hat sich bei Dir bezüglich des 4fach mecanumantrieb mit zwei zusätzlichen original RP6 motoren was getan? Die alternative dazu wären ja - was den synchronlauf betrifft - auch 4 servos, denke ich...

[radbruch]

Hallo

Nein, da hatte sich nichts mehr getan. Ein Sponsor für die zwei zusätzlichen Antriebe war nicht aufzutreiben und den Kauf eines zweiten RP6-Fahrwerkes zum Ausschlachten der Antriebe verhinderte meine schwäbische Sparsamkeit.

Der Syncronlauf bei mehreren gehackten Servos ist, zumindest, wenn man die orginale Ansteuerplatine mit ersetztem Poti weiterverwendet, immer schlecht. Aber grundsätzlich scheint mir das nicht mehr als kritisch, denn da die Mecanums eh extrem viel Schlupf aufweisen, kann man ohne übergeordenete Lage-/Richtungsregelung (Kompass, Kamera..) nicht sinnvoll cruisen. Zum Finden einer IR-Bake könnten Servos aber ausreichen...

Gruß

mic

[inka]

hallo mic,


Nein, da hatte sich nichts mehr getan. Ein Sponsor für die zwei zusätzlichen Antriebe war nicht aufzutreiben und den Kauf eines zweiten RP6-Fahrwerkes zum Ausschlachten der Antriebe verhinderte meine schwäbische Sparsamkeit.
tja, die sparsamen Schwaben.. Aber erfindungsreich sind sie...
noch eine frage hinzu, denn ich würde gerne den 4radantrieb schon noch weiterverfolgen: lässt die baseplatine einen betrieb mit vier motoren überhaupt zu? Man wird sicher noch zwei H-brücken brauchn, wie sieht es mit der software/elektronik ansteuerung - sind an dem baseprozessor noch ports frei die man nutzen könnte? Oder wäre es eine möglichkeit die motorsteuerung aufzuteilen zwischen der base und der m32?


da die Mecanums eh extrem viel Schlupf aufweisen, kann man ohne übergeordenete Lage-/Richtungsregelung (Kompass, Kamera..) nicht sinnvoll cruisen. Zum Finden einer IR-Bake könnten Servos aber ausreichen...
das sieht mir aber nicht nach sehr viel schlupf (https://www.youtube.com/watch?v=q0UeV1BRjyA) aus?

danke...

[radbruch]

Hallo


das sieht mir aber nicht nach sehr viel Schlupf aus?

Hier mal drei Ausschnitte vom Start, nach 8 und 19 Sekunden aus dem von dir gezeigten Video.
Das waren nur Fahrten mit 90 und 45 Grad Richtung ohne Drehungen:

https://www.roboternetz.de/community/attachment.php?attachmentid=28262&stc=1&d=1400655700

https://www.roboternetz.de/community/attachment.php?attachmentid=28263&stc=1&d=1400655713

https://www.roboternetz.de/community/attachment.php?attachmentid=28264&stc=1&d=1400655724
(Ausschnitte aus https://www.youtube.com/watch?v=q0UeV1BRjyA)

Gruß

mic

[oberallgeier]

... Der Syncronlauf ... wenn man die orginale Ansteuerplatine ... immer schlecht ...Na ja, zwei Bauteile mit reichlichen Fertigungsunterschieden sind eben - unterschiedlich in der Funktion. Daher meine Aktivitäten zum "Hack 2" (http://www.rn-wissen.de/index.php/Servo#Servos_hacken) - mit ziemlich guten Erfolg (https://www.roboternetz.de/community/threads/36121-Autonom-in-kleinen-Dosen-R2_D03-Nachfolger-R3D01?p=503279&viewfull=1#post503279): zwei Billigservos als zwei unabhängige Antriebe (mit EPDM-Reifen!!, Shore 65) ergeben auf 1 m Laufstrecke eine Abweichung von max ca 1 mm. Vermutlich aber NUR MIT einem exakt ausgelegten PID (https://www.roboternetz.de/community/threads/36121-Autonom-in-kleinen-Dosen-R2_D03-Nachfolger-R3D01/page20?p=427784&viewfull=1#post427784) *gg*.

[inka]

hallo,

@mic,

so kann man sich täuschen :-( ....- wäre das mit normalen rädern besser?

die frage nach der platine und 4 motoren ist evtl. untergegangen? Wie wären die möglichkeiten mit 4 motoren?

@oberallgeier,

das projekt ist super, hab schon mal ein (digitales) servo aufgeschraubt und bin - entsprechend meinen feinlöt- und klebfähigkelien erschrocken, wenn ich mir vorstelle dort auch noch eine lichtschranke unterbringen zu müssen. Von rasierklingen-schneiden mal ganz abgeasehen :-)