monoleg - Der einbeinige Roboter

**radbruch** · 07.10.2007, 19:21

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 auf Basis meines Trostpreises:

Bild hier

Ein Demo-Video der Bewegungsmöglichkeiten:

Bild hier
Bild anklicken für youtube-Video
Orginal: 8,4MB mpg mit Ton

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 Inbusschrauben 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:

Code:

#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:

Bild hier Bild hier Bild hier Bild hier
Bild hier Bild hier Bild hier Bild hier

Gruß

mic

**radbruch** · 12.10.2007, 23:50

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

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

(Das orginale 12MB-Filmchen)

mic

**robocat** · 13.10.2007, 11:24

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** · 13.10.2007, 19:06

Das ist ja jetzt mal der Hammer, toll gemacht!

**chr-mt** · 13.10.2007, 21:37

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

Gruß
Christopher

**radbruch** · 20.10.2007, 22:49

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)

pic1 pic2

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

Code:

#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,120,121,121,122,
123,123,124,124,125,125,126,126,126,127,127,127,127,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)

Gruß

mic

**Drifter2006** · 20.10.2007, 23:32

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

/
Greetings,
Drifter2006

**robocat** · 28.10.2007, 20:17

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

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

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

gruesse

**Razzorhead** · 29.10.2007, 18:42

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** · 29.10.2007, 20:32

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

Thema: monoleg - Der einbeinige Roboter

Themen-Optionen

Thema durchsuchen

Anzeige

monoleg - Der einbeinige Roboter

Lesezeichen

Lesezeichen

Berechtigungen