-
        

Seite 1 von 8 123 ... LetzteLetzte
Ergebnis 1 bis 10 von 71

Thema: monoleg - Der einbeinige Roboter

  1. #1
    Moderator Robotik Visionär Avatar von radbruch
    Registriert seit
    27.12.2006
    Ort
    Stuttgart
    Alter
    54
    Beiträge
    5.782
    Blog-Einträge
    8

    monoleg - Der einbeinige Roboter

    Anzeige

    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:



    Ein Demo-Video der Bewegungsmöglichkeiten:


    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:




    Gruß

    mic

    Atmel’s products are not intended, authorized, or warranted for use
    as components in applications intended to support or sustain life!

  2. #2
    Moderator Robotik Visionär Avatar von radbruch
    Registriert seit
    27.12.2006
    Ort
    Stuttgart
    Alter
    54
    Beiträge
    5.782
    Blog-Einträge
    8
    Ein paar kleine Änderungen und ein neuer "Schuh":

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

    (Das orginale 12MB-Filmchen)

    mic

    Atmel’s products are not intended, authorized, or warranted for use
    as components in applications intended to support or sustain life!

  3. #3
    Erfahrener Benutzer Roboter Genie Avatar von robocat
    Registriert seit
    18.07.2006
    Beiträge
    935
    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"

  4. #4
    Erfahrener Benutzer Roboter Experte
    Registriert seit
    17.08.2005
    Alter
    33
    Beiträge
    685
    Das ist ja jetzt mal der Hammer, toll gemacht!

  5. #5
    Erfahrener Benutzer Roboter Genie
    Registriert seit
    11.04.2005
    Beiträge
    1.469
    Hi,
    sieht wirklich witzig aus, hat so was "lebendiges" ! Tolle Idee!

    Gruß
    Christopher

  6. #6
    Moderator Robotik Visionär Avatar von radbruch
    Registriert seit
    27.12.2006
    Ort
    Stuttgart
    Alter
    54
    Beiträge
    5.782
    Blog-Einträge
    8
    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

    Atmel’s products are not intended, authorized, or warranted for use
    as components in applications intended to support or sustain life!

  7. #7
    Benutzer Stammmitglied
    Registriert seit
    28.08.2006
    Beiträge
    48
    Hello,
    I have read your description and watched the videos and I must say; “what an inspiration!”. \/
    Greetings,
    Drifter2006

  8. #8
    Erfahrener Benutzer Roboter Genie Avatar von robocat
    Registriert seit
    18.07.2006
    Beiträge
    935
    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

  9. #9
    Erfahrener Benutzer Roboter-Spezialist
    Registriert seit
    06.05.2007
    Alter
    28
    Beiträge
    305
    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

  10. #10
    Erfahrener Benutzer Roboter Experte
    Registriert seit
    30.09.2006
    Beiträge
    734
    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

Seite 1 von 8 123 ... LetzteLetzte

Berechtigungen

  • Neue Themen erstellen: Nein
  • Themen beantworten: Nein
  • Anhänge hochladen: Nein
  • Beiträge bearbeiten: Nein
  •