Robi

Diese Bauanleitung beschreibt einen Roboter. Robi kann laufen, tanzen und den Moonwalk. Jedes Bein hat zwei Gelenke die von Servo-Motoren bewegt werden. Als Steuerung dient ein Arduino NANO, gespeist von einer 9V-Batterie.
Das Robi-Gehäuse wird aus einer 3mm Sperrholzplatte gelasert oder mit dem 3D-Drucker erstellt.

Entwerfe dein eigenes Robi Design für das Lasercutter Gehäuse:

Hardware

Die Stückliste für Robi:

• 1 Sperrholzplatte 300x300
• 1 Arduino NANO V3
• 1 NANO-Shield
• 2 40 Pin Male 2,54mm Stiftleisten einreihig
• 1 40 Pin Female 2,54 mm Buchsenleiste einreihig
• 1 Schalter
• 2 Jumbo LEDs
• 1 1K Ohm Widerstand
• 1 9V Batterie
• 1 9V Batterie-Klipp
• 4 Servo Motore SG90 (alternativ MG90)
• 2 Schrauben M2,5x8
• 2 Schrauben M3x8
• 1 Kabelbinder 10cm
• 1 Holzleim
• 1 Sekundenkleber
• 1 20cm Schaltlitze 0,5mm²




Bauteilbilder der Stückliste







Der NANO mit Shield und Stiftleisten

Aufbau und Montage

Der Aufbau und die Montage von Robi ist in mehrere Schritte unterteilt

Schritt 1: Überprüfe die Laserteile auf Vollständigkeit

• Verwende die LightBurn Vorlage (LightBurn Vorlage 2), bestehend aus:
• 1 x Kopfoberteilteil
• 1 x Kopfunterteil
• 2 x Füße
• 2 x Schuhe

Lasercutter-Datei (3mm Sperrholz))

Füße und Schuhe (3mm Sperrholz)

Schritt 2: Das Kopfoberteil montieren

Schritt 3: Das Kopfunterteil montieren

• Achtung: Das rechte und linke Seitenteil mit dem Gelenk zum Schluss mit dem Kopf Oberteil montieren!







• Im Kopf Unterteil die Halterungen für die Servos kleben





• Die Hülle der beiden Füße verkleben.
• Achtung: Wir benötigen zwei Füße. Die Öffnungen für die Servokabel sind jeweils innen und die Servos zeigen nach vorne!













• Die beiden Oberteile der Füße deckungsgleich verkleben (noch nicht an die Füße kleben!).





• Die Oberteile der Füße werden an den Servo im Kopfteil geschraubt.






Schritt 4: Den Robi verdrahten, die Bauteile jedoch noch nicht in das Gehäuse montieren.







Schritt 5: Vor der Montage der Servos ist ein Funktionstest sinnvoll: Den Robi mit der Arduino IDE in C++ oder in Blocksprache programmieren. Ist der Robi programmiert und sind die Servos in 90° Stellung, können sie in das Kopf-Unterteil und in die Füße montiert werden.





Schritt 6: Die beiden Servos in 90° Stellung mit den unteren Kopfteil und den Oberteil der Füße verschrauben. Die Servos sollten durch die Verschraubung fest am Kopfteil sitzen. Anschließend die 9V-Batterie mit den Kabelbinder befestigen.














• Die Schrittmotore in die Fußhülle montieren und das Fuß Unterteil ankleben




Die Schuhe an die Füße montieren






Die Servo-Kabel in den Body führen und die Füße an die Fußoberteile kleben



Schritt 7: Den NANO in das obere Kopfteil montieren
• Platinenhalter auf das Shield kleben und das Shield anschließend in das innere, obere Kopfteil kleben. Daneben den Schalter montieren und verdrahten. Vor dem endgültigen verkleben des NANOs in das Obere Kopfteil, sollte er fertig programmiert sein. Optional noch zwei LEDs mit 1kOhm Vorwiderstand an 9V als Augen verwenden.




Anschlüsse der LED



Anschluss des Batterieclips, des Schalters und der LEDs

Schritt 8: Das Programm in den Robi laden und evtl. die Servo-Ausgänge anpassen

• Der NANO wird mit der Arduino IDE oder mit OttoBlocky programmiert.

Programm 1

Robi C++ Programm

/*************************************************************************************************
                                      PROGRAMMINFO
**************************************************************************************************
Funktion: Robi tanzt
**************************************************************************************************
Version: 03.02.2022
**************************************************************************************************
Board: NANO V3

**************************************************************************************************
C++ Arduino IDE V1.8.13
**************************************************************************************************
Librarys
- Otto.h
**************************************************************************************************
**************************************************************************************************/

#include <Otto.h>
Otto Otto;

#define LeftLeg 2 // left leg pin, servo[0]
#define RightLeg 3 // right leg pin, servo[1]
#define LeftFoot 4 // left foot pin, servo[2]
#define RightFoot 5 // right foot pin, servo[3]
#define Buzzer 13 //buzzer pin


void setup() {
  Otto.init(LeftLeg, RightLeg, LeftFoot, RightFoot, true, Buzzer);
Otto.home();


}

void loop() {
    for (int count=0 ; count<2 ; count++) {
      Otto.walk(1,1000,1); // FORWARD
      Otto.walk(1,1000,-1); // BACKWARD
    }
    for (int count=0 ; count<5 ; count++) {
      Otto.moonwalker(1, 1000, 25, 1);
    }
    for (int count=0 ; count<5 ; count++) {
      Otto.moonwalker(1, 1000, 25, -1);
    }
    for (int count=0 ; count<2 ; count++) {
      Otto.swing(1, 1000, 25);
      Otto.jitter(1, 1000, 25);
    }

}

RAW code



• Das Programm mit OttoBlocky (Die Configuration an die eigene Verdahtung anpassen)







Programm 2

Robi C++ Programm

/*************************************************************************************************
                                      PROGRAMMINFO
**************************************************************************************************
Funktion: Robi tanzt
**************************************************************************************************
Version: 03.02.2022
**************************************************************************************************
Board: NANO V3

**************************************************************************************************
C++ Arduino IDE V1.8.13
**************************************************************************************************
Librarys
- Otto.h
**************************************************************************************************
**************************************************************************************************/


#include "VarSpeedServo.h"
#include <NewPing.h>
//#include <Servo.h>

VarSpeedServo RU;  //rechts oben
VarSpeedServo RL;  //rechts unten
VarSpeedServo LU;  //links oben
VarSpeedServo LL;  //links unten

NewPing sonar(4,3,200);
                                                     //vel(min), delay_Forward(max) = (5, 2000)
const int vel = 40, vel_Back = 15;                   //vel(mid), delay_Forward(mid) = (20, 750)
const int delay_Forward = 300, delay_Back = 750;     //vel(max), delay_Forward(min)= (256, 50)
                                                     //Empfelung ---> (10, 700) (50, 500) (100, 100) (100, 300) (100, 500)

int vel_Dance1 = 30,    vel_Dance2 = 25,    vel_Dance3 = 40;
int delay_Dance1 = 300, delay_Dance2 = 750, delay_Dance3 = 200;

int vel_Dance4 = 40,    vel_Dance5 = 40,    vel_Dance6 = 30;
int delay_Dance4 = 400, delay_Dance5 = 400, delay_Dance6 = 500;

const int array_cal[4] = {90,90,90,90};
int RU_Degree = 0, LU_Degree = array_cal[2] + 5;

const int num_dance1 = 10;
const int array_dance1[num_dance1][4] =
{
//slide links 0-4
    {0,-20,0,0},
    {0,-40,0,20},
    {0,-20,0,40},
    {0,0,0,20},
    {0,0,0,0},

//slide rechts 5-9
    {0,0,0,20},
    {0,-20,0,40},
    {0,-40,0,20},
    {0,-20,0,0},
    {0,0,0,0},
};

const int num_dance2 = 32;
const int array_dance2[num_dance2][4] =
{
//linker Fuß 0-15
    {20,0,40,0},
    {20,-30,40,-30},
    {20,-30,10,-30},
    {20,-30,40,-30},
    {20,-30,10,-30},

    {20,-30,40,-30},
    {20,0,40,-30},
    {20,80,40,-30},
    {20,0,40,-30},
    {20,-80,40,-30},
    {20,0,40,-30},
    {20,80,40,-30},
    {20,0,40,-30},
    {20,-30,40,-30},
    {20,0,40,0},
    {0,0,0,0},

//rechter Fuß 16-31
    {-40,0,-20,0},
    {-40,40,-20,30},
    {-20,40,-20,30},
    {-40,40,-20,30},
    {-20,40,-20,30},

    {-40,40,-20,30},
    {-40,40,-20,0},
    {-40,40,-20,-80},
    {-40,40,-20,0},
    {-40,40,-20,80},
    {-40,40,-20,0},
    {-40,40,-20,-80},
    {-40,40,-20,0},
    {-40,40,-20,30},
    {-40,0,-20,0},
    {0,0,0,0},
};

const int num_dance3 = 8;        //split step
const int array_dance3[num_dance3][4] =
{
    {0,-40,0,0},
    {20,-30,20,20},
    {40,0,40,30},
    {0,0,0,40},
    {-20,-20,-20,30},
    {-40,-30,-40,0},

    {0,-40,0,0},
    {0,0,0,0},
};

const int num_dance4 = 20;      //nach innen und beschleunigen
const int array_dance4[num_dance4][4] =
{
    {0,-20,0,20},
    {0,0,0,0},
    {0,-20,0,20},
    {0,0,0,0},
    {0,-20,0,20},
    {0,0,0,0},
    {0,-20,0,20},
    {0,0,0,0},

    {0,-50,0,50},
    {0,0,0,0},
    {0,-50,0,50},
    {0,0,0,0},
    {0,-50,0,50},
    {0,0,0,0},
    {0,-50,0,50},
    {0,0,0,0},

    {0,-40,0,40},
    {0,-50,0,50},
    {0,-60,0,60},
    {0,0,0,0,},
};

const int num_dance5 = 17;
const int array_dance5[num_dance5][4] =
{
    {35,0,15,0},    //beide Beine berühren lassen
    {35,30,15,30},
    {-35,30,15,30},
    {-20,0,15,0},
    {0,0,0,0},

    {0,-40,0,40},    //nach innen und drehen Beine
    {-30,-40,-20,40},
    {0,-40,0,40},
    {20,-40,30,40},


    {0,-40,0,40},    //An Ort und Stelle auf und ab gehen und Beine drehen
    {20,-40,-20,40},
    {20,-20,-20,20},
    {20,0,-20,0},
    {-20,-10,20,10},
    {-10,-30,10,30},

    {0,-40,0,40},
    {0,0,0,0},
};

const int num_dance6 = 32;
const int array_dance6[num_dance6][4] =
{
    {0,-40,0,-20},        //weitergehen
    {25,-40,18,-20},
    {25,0,18,0},
    {0,20,0,40},
    {-18,20,-25,40},
    {-18,0,-25,0},

    {0,-40,0,-20},        //rausziehen
    {25,-40,18,-20},
    {0,0,0,0},
    {0,20,0,40},
    {-18,20,-25,40},
    {0,0,0,0},

    {0,-40,0,-20},        //rausziehne - zurück
    {-25,-40,-18,-20},
    {-25,0,-18,0},
    {0,20,0,40},
    {18,20,25,40},
    {18,0,25,0},

    {0,-40,0,-20},        //vorwärts
    {30,-40,30,-20},
    {30,0,30,0},
    {0,20,0,40},
    {-30,20,-30,40},
    {-30,0,-30,0},

    {0,-40,0,-20},        //zurück
    {-30,-40,-30,-20},
    {-30,0,-30,0},
    {0,20,0,40},
    {30,20,30,40},
    {30,0,30,0},

    {15,0,15,0},
    {0,0,0,0},
};

//Programmauswahl - Nur EIN Programm aktivieren!!!
//#define INSTALL
//#define CALIBRATION
#define RUN

void Servo_Init()
{
    RU.attach(9);    // Servo rechts oben an pin 9
    RL.attach(10);   // Servo rechts unten an pin 10
    LU.attach(11);   // Servo links oben an pin pin 11
    LL.attach(12);   // Servo links unten an pin 12
}

void Adjust()                            // Vermeide das schnelle Spinnen des Servos bei der Initialisierung
{                                        // RU,LU geht von array_cal[0] - 5 ,array_cal[2] + 5 Grad auf array_cal[0],array_cal[2] Grad
    for(RU_Degree = array_cal[0] - 5; RU_Degree <= array_cal[0]; RU_Degree += 1) {
        RU.write(RU_Degree);             // in Schritten von 1 Grad
        LU.write(LU_Degree--);           // sage den Servo, dass er zu RU_Degreeition gehen soll, LU_Degreeition in der Variable "RU_Degree", "LU_Degree"
        delay(15);                       // wartet 15ms, bis der Servo die RU_Degreeition erreicht hat
    }
}

bool TooClose()
{
    int tooclose = 0;
    for(int a=0; a<5; a++) {
        delay(50);
        int din = sonar.ping_in();
        if (din < 7 && din > 0) tooclose++;
    }
    if (tooclose < 5) return 1;
    return 0;
}

void Slide_2_Left(int times)
{
    for(int time1 = 0; time1 < times; time1++) {
        for(int z=0; z<5; z++) {
            RU.slowmove (array_cal[0] + array_dance1[z][0] , vel_Dance1);
            RL.slowmove (array_cal[1] + array_dance1[z][1] , vel_Dance1);
            LU.slowmove (array_cal[2] + array_dance1[z][2] , vel_Dance1);
            LL.slowmove (array_cal[3] + array_dance1[z][3] , vel_Dance1);
            delay(delay_Dance1);
        }
    }
}

void Slide_2_Right(int times)
{
    for(int time1 = 0; time1 < times; time1++) {
        for(int z=5; z<10; z++) {
            RU.slowmove (array_cal[0] + array_dance1[z][0] , vel_Dance1);
            RL.slowmove (array_cal[1] + array_dance1[z][1] , vel_Dance1);
            LU.slowmove (array_cal[2] + array_dance1[z][2] , vel_Dance1);
            LL.slowmove (array_cal[3] + array_dance1[z][3] , vel_Dance1);
            delay(delay_Dance1);
        }
    }
}

void Left_Foot_Support()
{
    for(int z=0; z<16; z++) { //z<12
        if ( z > 5 && z < 14) {   //z(1,10)
            vel_Dance2 = 50;
            delay_Dance2 = 200;
        }
        else {
        vel_Dance2 = 25;
        delay_Dance2 = 750;
        }

        RU.slowmove (array_cal[0] + array_dance2[z][0] , vel_Dance2);
        RL.slowmove (array_cal[1] + array_dance2[z][1] , vel_Dance2);
        LU.slowmove (array_cal[2] + array_dance2[z][2] , vel_Dance2);
        LL.slowmove (array_cal[3] + array_dance2[z][3] , vel_Dance2);
        delay(delay_Dance2);
    }
}

void Right_Foot_Support()
{
    for(int z=16; z<32; z++) { //z<24
        if ( z > 21 && z < 30) {   //z(13,22)
            vel_Dance2 = 50;
            delay_Dance2 = 200;
        }
        else {
        vel_Dance2 = 25;
        delay_Dance2 = 750;
        }

        RU.slowmove (array_cal[0] + array_dance2[z][0] , vel_Dance2);
        RL.slowmove (array_cal[1] + array_dance2[z][1] , vel_Dance2);
        LU.slowmove (array_cal[2] + array_dance2[z][2] , vel_Dance2);
        LL.slowmove (array_cal[3] + array_dance2[z][3] , vel_Dance2);
        delay(delay_Dance2);
    }
}

void Dancing1_2()
{
    Slide_2_Left(2);
    Left_Foot_Support();

    Slide_2_Right(2);
    Right_Foot_Support();
}

void Dancing3(int Times = 1, int Vel = 40, int Delay = 250, int low = 0, int high = 0)
{
    for(int time3 = 0; time3 < Times; time3++) {
        for(int z=0; z<6; z++) {
            if ( time3 > 1 && time3 < 4) {
            vel_Dance3 = Vel;
            delay_Dance3 = Delay;
            }
            else {
            vel_Dance3 = 40;
            delay_Dance3 = 200;
            }

            RU.slowmove (array_cal[0] + array_dance3[z][0] , vel_Dance3);
            RL.slowmove (array_cal[1] + array_dance3[z][1] , vel_Dance3);
            LU.slowmove (array_cal[2] + array_dance3[z][2] , vel_Dance3);
            LL.slowmove (array_cal[3] + array_dance3[z][3] , vel_Dance3);
            delay(delay_Dance3);
        }
    }
    for(int z=6; z<8; z++) {
            RU.slowmove (array_cal[0] + array_dance3[z][0] , vel_Dance3);
            RL.slowmove (array_cal[1] + array_dance3[z][1] , vel_Dance3);
            LU.slowmove (array_cal[2] + array_dance3[z][2] , vel_Dance3);
            LL.slowmove (array_cal[3] + array_dance3[z][3] , vel_Dance3);
            delay(delay_Dance3);
        }
}

void Dancing4()
{
    for(int z=0; z<num_dance4; z++) {
        if ( z > 17) {
            vel_Dance4 = 10;
            delay_Dance4 = 1500;
            }
        else {
            vel_Dance4 = 40;
            delay_Dance4 = 400;
            }

        RU.slowmove (array_cal[0] + array_dance4[z][0] , vel_Dance4);
        RL.slowmove (array_cal[1] + array_dance4[z][1] , vel_Dance4);
        LU.slowmove (array_cal[2] + array_dance4[z][2] , vel_Dance4);
        LL.slowmove (array_cal[3] + array_dance4[z][3] , vel_Dance4);
        delay(delay_Dance4);
    }
}

void Dancing5()
{
    for(int x = 0; x < 3; x++) {
        for(int z=0; z<5; z++) {
            RU.slowmove (array_cal[0] + array_dance5[z][0] , vel_Dance5);
            RL.slowmove (array_cal[1] + array_dance5[z][1] , vel_Dance5);
            LU.slowmove (array_cal[2] + array_dance5[z][2] , vel_Dance5);
            LL.slowmove (array_cal[3] + array_dance5[z][3] , vel_Dance5);
            delay(delay_Dance5);
        }
    }

    for(int x = 0; x < 2; x++) {
        for(int z=5; z<9; z++) {
            RU.slowmove (array_cal[0] + array_dance5[z][0] , 30);
            RL.slowmove (array_cal[1] + array_dance5[z][1] , 30);
            LU.slowmove (array_cal[2] + array_dance5[z][2] , 30);
            LL.slowmove (array_cal[3] + array_dance5[z][3] , 30);
            delay(550);
        }
    }

    for(int x = 0; x < 3; x++) {
        for(int z=9; z<15; z++) {
            RU.slowmove (array_cal[0] + array_dance5[z][0] , vel_Dance5);
            RL.slowmove (array_cal[1] + array_dance5[z][1] , vel_Dance5);
            LU.slowmove (array_cal[2] + array_dance5[z][2] , vel_Dance5);
            LL.slowmove (array_cal[3] + array_dance5[z][3] , vel_Dance5);
            delay(300);
        }
    }
    for(int z=15; z<17; z++) {
            RU.slowmove (array_cal[0] + array_dance5[z][0] , 10);
            RL.slowmove (array_cal[1] + array_dance5[z][1] , 10);
            LU.slowmove (array_cal[2] + array_dance5[z][2] , 10);
            LL.slowmove (array_cal[3] + array_dance5[z][3] , 10);
            delay(1500);
        }
}

void Dancing6()
{
    const int array_cal_0 = array_cal[0] + 10 , array_cal_2 = array_cal[2] - 10;

    for(int x = 0; x < 3; x++) {
        for(int z=0; z<6; z++) {
            RU.slowmove (array_cal_0 + array_dance6[z][0] , vel_Dance6);
            RL.slowmove (array_cal[1] + array_dance6[z][1] , vel_Dance6);
            LU.slowmove (array_cal_2 + array_dance6[z][2] , vel_Dance6);
            LL.slowmove (array_cal[3] + array_dance6[z][3] , vel_Dance6);
            delay(delay_Dance6);
        }
    }

    for(int x = 0; x < 3; x++) {
        for(int z=6; z<12; z++) {
            RU.slowmove (array_cal_0 + array_dance6[z][0] , 40);
            RL.slowmove (array_cal[1] + array_dance6[z][1] , 40);
            LU.slowmove (array_cal_2 + array_dance6[z][2] , 40);
            LL.slowmove (array_cal[3] + array_dance6[z][3] , 40);
            delay(400);
        }
    }

    for(int x = 0; x < 3; x++) {
        for(int z=12; z<18; z++) {
            RU.slowmove (array_cal_0 + array_dance6[z][0] , vel_Dance6);
            RL.slowmove (array_cal[1] + array_dance6[z][1] , vel_Dance6);
            LU.slowmove (array_cal_2 + array_dance6[z][2] , vel_Dance6);
            LL.slowmove (array_cal[3] + array_dance6[z][3] , vel_Dance6);
            delay(delay_Dance6);
        }
    }
    for(int x = 0; x < 3; x++) {
        for(int z=18; z<24; z++) {
            RU.slowmove (array_cal[0] + array_dance6[z][0] , vel_Dance6);
            RL.slowmove (array_cal[1] + array_dance6[z][1] , vel_Dance6);
            LU.slowmove (array_cal[2] + array_dance6[z][2] , vel_Dance6);
            LL.slowmove (array_cal[3] + array_dance6[z][3] , vel_Dance6);
            delay(delay_Dance6);
        }
    }

    for(int x = 0; x < 3; x++) {
        for(int z=24; z<30; z++) {
            RU.slowmove (array_cal[0] + array_dance6[z][0] , vel_Dance6);
            RL.slowmove (array_cal[1] + array_dance6[z][1] , vel_Dance6);
            LU.slowmove (array_cal[2] + array_dance6[z][2] , vel_Dance6);
            LL.slowmove (array_cal[3] + array_dance6[z][3] , vel_Dance6);
            delay(delay_Dance6);
        }
    }
    for(int z=30; z<32; z++) {
            RU.slowmove (array_cal[0] + array_dance5[z][0] , 10);
            RL.slowmove (array_cal[1] + array_dance5[z][1] , 10);
            LU.slowmove (array_cal[2] + array_dance5[z][2] , 10);
            LL.slowmove (array_cal[3] + array_dance5[z][3] , 10);
            delay(1500);
        }
}

void setup()
{
#ifdef INSTALL
    Servo_Init();

    RU.slowmove (90 , vel);
    RL.slowmove (90 , vel);
    LU.slowmove (90 , vel);
    LL.slowmove (90 , vel);
    while(1);
#endif

#ifdef CALIBRATION
    Servo_Init();
    Adjust();

    RL.slowmove (array_cal[1] , vel);
    LL.slowmove (array_cal[3] , vel);
    delay(2000);
    while(1);
#endif

#ifdef RUN
    Servo_Init();
    Adjust();

    RL.slowmove (array_cal[1] , vel);
    LL.slowmove (array_cal[3] , vel);
    delay(2000);
#endif
}

void loop()
{
    Dancing1_2();
    delay(500);
    Dancing3(5,20,400);
    delay(500);
    Dancing4();
    delay(500);
    Dancing5();
    delay(500);
    Dancing6();
    delay(500);
    while(1);

}

RAW code

Download Programm 2


OpenSCAD Programm für den 3D-Druck

Robi OpenSCAD Programm

//*****************************************************************
//                  Robi (Arduino NANO 4x SG90 9V Batterie)
//                  KHF 02-2022
//*****************************************************************

//*********************  Robi Print-Auswahl *************************************
//                  +++3D-Druck Auswahl+++
part="all"; // [all, head, body, leg, foot_left, foot_right], 0=nothing
Hut = 1; // Hut 1= Ja 0= NEIN
Brille = 1; // Brille 1= Ja 0= NEIN
Feets = 0; // Watschlfuesse 1= Ja 0= NEIN setze part, Hut und Brille auf 0!
USB = 0; // seitlicher USB Durchbruch 1= Ja 0= NEIN
Schalter = 1; // Top Schalter 1= Ja 0= NEIN
Name = 1; // 1= Name, 0= kein Name
Robi="Robi"; //Name
Mundausschnitt = 1; // 1= Ja 0= NEIN
//*************************************************************************

//*********************  Robi Parameter ***********************************
headcolor="White";
bodycolor="Lime";
legcolor="LightSeaGreen";
footcolor="SlateGray";

// Aussparungen im Kopfteil
brain_type="0"; // [nano_shield:Stock (Arduino Nano + Servo Shield),nano_proto:Arduino Nano + Proto board,uno_shield:Arduino Uno + Servo Shield,uno:Arduino Uno (and wires)]

// Servo Typ
servo_type_hip="sg90"; // [sg90:SG90 (nylon gear micro servo),mg90s:MG90S (metal gear micro servo)]

// Servo Type fuer Winkel
servo_type_ankle="sg90"; // [sg90:SG90 (nylon gear micro servo),mg90s:MG90S (metal gear micro servo)]

// Body Breite
body_width=69; // [67:200] V1.5-> 67+2

// Body Tiefe
body_depth=70; // [68:200] 68+2

// Body Hoehe
body_height=38; // [20:200]

// Kopf Hoehe
head_height=34; // [20:200]

// Body Wand-Dicke
body_thickness=1.75; // [0.25:0.25:8]

// Kopf Wand-Dicke
head_thickness=2; // [0.25:0.25:8]

// Kippschalter Durchmmesser
SchalterD=6.1;

//Durchmesser der Augen
nose_diameter=6; // [0:24]

// Vertikaler Abstand zwischen den Augen
nose_distance=15; // [-8:190]

// Kopfteil Schraubenduchmesser
brain_screw_size=2; // [2:5]

// Schrauben im Kopfteil
brain_screw_thru=0; // [1:Ja,0:Nein]

//  Festes Bein, kein Servo im Body
leg_solid=0; // [1:Ja, solid,0:Nein]

/* [Versteckt] */
part_clearance=0.25;

arduino_holes=[[-27,-7],[-27,20.9],[25.2,26.1],[23.825,-22.25]];

proto_holes=[[27,-10],[-17.9,-10],[26,25.5],[-17.7,25.5]];

//*****************************************************************************
//                             PROGRAMM
//*****************************************************************************

//*********************** Watschl Fuesse ****************************
//************** Watschl Fuss links ********************************
module Feets(){
  difference(){
linear_extrude(height = 3, center = true, convexity = 10)
                import(file = "Fuss_li.svg");
color ("red")
translate([11,38.9,-2.5])
cube(size = [30,31.8,3]);
  }
  servohornoff=(servo_type_ankle=="sg90"?2:0);

  servohornoff=(servo_type_ankle=="sg90"?2:0);
  translate([20,55,0.5])
 rotate([0,180,90])

  difference(){
    union(){
      translate([15.8,-9.5,15.75]) sphere(d=4,$fn=30);
      for(m=[0,1]) mirror([m,0])
      translate([-21.15,-20,0]) difference() {
        intersection(){
          cube([4+(m?1.1:1.5),21,24.5+(m?0:2)]);
          box_chamfer3([41.8,21,25+(m?0:2)],2);
          *translate([2.8,2.8,0]) box_chamfer2([36.2,15.4,22.5],4);
        }
        translate([5.5,-.01,-.01]) cube([31.3,21.02,25.02]);
        if(m==0)
        translate([-.01,10.5,15.5]) rotate([0,90]) {
            cylinder(d=7.3,h=6+servohornoff,$fn=30);
            translate([-8,0]) cylinder(d=1,h=6+servohornoff,$fn=10);
            rotate([0,0,90]) linear_extrude(2+servohornoff) {
            polygon([[-3.5,0],[-2,10+(m?0:2)],[2,10+(m?0:2)],[3.5,0]]);
          }
        }
      }
    }
    translate([-15.7,-21.01,1]) {
      translate([0,-1,0]) box_chamfer3([31.8,26.02,10],2);
      *intersection(){
        cube([31.8,25.02,10]);
        translate([2,0,2.8]) box_chamfer2([27.3,22,8],4);
      }
    }
  }



module box_chamfer3(dims,ch=1,bot=1)
{
  render() intersection() {
    cube(dims);
    minkowski()
    {
      translate([ch,ch,ch]) cube([dims[0]-ch*2,dims[1]-ch*2,dims[2]-ch*2]);
      *sphere(r=ch/sin(60),$fn=10);
      for(m=[0,1]) mirror([0,0,m])
        cylinder(r1=ch,r2=m?(bot?0:ch):0,h=ch,$fn=4);
    }
  }
}

//******************** Watschl Fuss rechts ********************************************
  difference(){
      translate([-60,0,0])
linear_extrude(height = 3, center = true, convexity = 10)
                import(file = "Fuss_re.svg");
color ("red")
translate([-29,38.9,-2.5])
cube(size = [30,31.8,3]);
  }

  servohornoff=(servo_type_ankle=="sg90"?2:0);
  translate([-27,55,0.5])
 rotate([0,180,90])

  difference(){
    union(){

      translate([15.8,-9.5,15.75]) sphere(d=4,$fn=30);
      for(m=[0,1]) mirror([m,0])
      translate([-21.15,-20,0]) difference() {
        intersection(){
          cube([4+(m?1.1:1.5),21,24.5+(m?0:2)]);
          box_chamfer3([41.8,21,25+(m?0:2)],2);
          *translate([2.8,2.8,0]) box_chamfer2([36.2,15.4,22.5],4);
        }
        translate([5.5,-.01,-.01]) cube([31.3,21.02,25.02]);
        if(m==0)
        translate([-.01,10.5,15.5]) rotate([0,90]) {
            cylinder(d=7.3,h=6+servohornoff,$fn=30);
            translate([-8,0]) cylinder(d=1,h=6+servohornoff,$fn=10);
            rotate([0,0,90]) linear_extrude(2+servohornoff) {
            polygon([[-3.5,0],[-2,10+(m?0:2)],[2,10+(m?0:2)],[3.5,0]]);
          }
        }
      }
    }
    translate([-15.7,-21.01,1]) {
      translate([0,-1,0]) box_chamfer3([31.8,26.02,10],2);
      *intersection(){
        cube([31.8,25.02,10]);
        translate([2,0,2.8]) box_chamfer2([27.3,22,8],4);
      }
    }
  }



module box_chamfer3(dims,ch=1,bot=1)
{
  render() intersection() {
    cube(dims);
    minkowski()
    {
      translate([ch,ch,ch]) cube([dims[0]-ch*2,dims[1]-ch*2,dims[2]-ch*2]);
      *sphere(r=ch/sin(60),$fn=10);
      for(m=[0,1]) mirror([0,0,m])
        cylinder(r1=ch,r2=m?(bot?0:ch):0,h=ch,$fn=4);
    }
  }
}
}
//*********************************************************************************
if (Feets == 1)
rotate([0, 180, 0])
translate([0,-150,50])
color( footcolor, 1.0 ){
Feets();
}
//*********************************************************************************
//*********************************************************************************


print_part();

module print_part() {
  warnings()
    draw_part();
}

//********************* Part ***************************

module draw_part() {
  if(part=="head")
    head();
  else if(part=="body")
    body();
  else if(part=="leg")
    leg();
  else if(part=="foot_left")
    foot();
  else if(part=="foot_right")
    mirror([1,0]) foot();
  else if(part=="all")
    rotate([0,0,-90]) robi();
}


//********************* Module robi ***************************
module robi() {
  head(move=1);
  body(move=1);
  mirrory() {
    translate([0,body_width/2-33.5,0])
    {
      mirror([1,0]) foot(move=1);
      translate([0,24,-1]) mirror([0,0,1]) leg(move=0);
    }
  }
}
function brain_type_text() = (
  brain_type=="nano_shield"?"Arduino Nano + Servo Shield":(
  brain_type=="uno_shield"?"Arduino Uno + Servo Shield":(
  brain_type=="nano_proto"?"Arduino Nano + Proto board":"Unknown")));
module warnings() {
  if(brain_type=="nano_shield")
  {
    if(body_width<67)
      error(str("If ",brain_type_text()," is used, Body Width must be >= 67!"));
    else if(body_depth<67)
      error(str("If ",brain_type_text()," is used, Body Depth must be >= 67!"));
    else children();
  } else if(brain_type=="uno_shield"||brain_type=="uno")
  {
    if(body_width<81)
      error("If Arduino Uno is used, body width MUST be greater than 81!");
    else children();
  } else children();
}
//********************* Module error ***************************
module error(s) {
  echo(str("***ERROR*** ",s));
  rotate([0,0,-45])
        rotate([80,0,0]) color("red") text(s);
}
//********************* Module body ***************************
module body
(dims=[body_depth-1,body_width,body_height]) {
  left=dims[0]/-2; // -33.5
  botm=dims[1]/-2; // -33.5
  right=dims[0]/2; // 34
  servozoff=servo_type_hip=="sg90"?2:0;
  *#import("Otto_DIY/files/OTTO_body_v3.stl");
  mirrorx(0.4) mirrory(0.25) translate([left+body_thickness,botm+body_thickness+13.775,body_thickness]) {
      cube([dims[0]/2-9,2.5,12.4]);
      translate([0,2.5,12.39]) rotate([90,0,90]) mirror([1,0]) linear_extrude(dims[0]/2-9,convexity=10) polygon([[0,0],[1.2,0.825],[2.5,0.825],[2.5,0]]);
  }
  mirrory() mirrorx() translate([left+body_thickness-.01,botm+6,dims[2]-16]) difference(){
    cube([2,13.7,5]);
    translate([0,-.01]) rotate([0,41]) cube([3,13.72,5]);
  }
  mirrory() for(x=[0,28.2]) translate([x-9.5,botm+body_thickness,body_thickness]) difference() {
    union(){
      cube([2,13.775,6.18-servozoff]);
      translate([0.98,6.85,0]) cylinder(d1=5.7,d2=4.4,h=0.85,$fn=30);
      translate([0.98,6.85,0.84]) cylinder(d=4.4,h=5.35-servozoff,$fn=40);
    }
      translate([0.98,6.85,-.01]) cylinder(d=1.9,h=7,$fn=20);
  }
  for(mx=[0,1],my=[0,1]) mirror([mx,0]) mirror([0,my]) translate([mx?-11:0,0])
  translate([left+body_thickness+22.2,botm+body_thickness,body_thickness]) difference() { union() {
      if(!mx&&!my)
        translate([-10.7,6.61])
          cylinder(d=16,h=6.25-servozoff,$fn=50);
      else if(!mx&&my)
        translate([-17.5,0,.01]) cube([11.9,13.2,6-servozoff]);
      translate([-1-(left+33),5.64,0]) mirror([1,0]) cube([(mx?-22:-12)-left,2,6.1-servozoff]);
    }
    if(!mx&&!my)
      translate([-10.72,6.61,-.01]) cylinder(d=12,h=6.27,$fn=40);
    else if(!mx&&my)
      translate([-15.9,5,-.01]) {
        cube([8.35,8.2,7]);
        translate([0,-6]) cube([8.35,4,7]);
      }
  }


        color( bodycolor, 1.0 ){

  difference() {
      translate([left,botm,0]) box_chamfer(dims,ch=2,chvx=5,chvy=5);
//    translate([left+1.75,botm+1.75,2]) box_chamfer([dims[0]-3.5,dims[1]-3.5,dims[2]],ch=1,chvx=4,chvy=4,inside=1);
    translate([left+body_thickness,botm+body_thickness,2]) box_chamfer([dims[0]-body_thickness*2,dims[1]-body_thickness*2,dims[2]],ch=1,chvx=4,chvy=4,inside=1);
    translate([0,0,-1]) linear_extrude(10,convexity=10) {
      mirrory() {
        translate([.1,botm+8.5]) circle(d=12,$fn=30);
        translate([6,botm+8.5]) circle(d=servo_type_hip=="mg90s"?6.5:7,$fn=20);
        offset(-1) offset(1)
        translate([-14.5,-15]) square([29,4]);
      }
      //translate([left+9,-botm-13.5]) square([5.2,5.2]);  //Schalter-Loch seitlich
      translate([left+12.8,botm+8.35]) {
  //      circle(d=2,$fn=20); //Buzzer-Löcher
  //      for(r=[2:360/7:359]) rotate([0,0,r]) translate([4.1,0]) circle(d=2,$fn=20);
      }
    }
    mirrory() translate([-11.7,right-body_thickness-.51,dims[2]-11]) {  cube([22.35,body_thickness+0.6,4]);
      translate([0,body_thickness+.02,4.1]) rotate([-35,0]) mirror([0,0,1]) mirror([0,1,0]) cube([22.35,4,5.4]);
    }

//******* Mund *******
if(Mundausschnitt == 1)
    {rotate([90,0,90])
    translate(v = [-23.5, 13, 30])
    linear_extrude(height = 10)
    import ("Robitmund.svg");}


//******* Name ********
if(Name == 1)
{color("SlateGray")
rotate([-90,180,90])
translate([-8.5, 17,33])
linear_extrude(2.0)
text(Robi,  font = "Arial", size = 6);}

    }
  }
}
//********************* Module head ***************************
module head
(dims=[
    body_width-(body_thickness+part_clearance)*2,
    body_depth-(body_thickness+part_clearance)*2,
    head_height],brain_type=brain_type,head_thickness=head_thickness,move=0) {
  left=dims[0]/-2; // -31.5
  botm=dims[1]/-2; // -32.25
  right=dims[0]/2; // 31.5
  translate(move?[0,0,body_height+head_height-3]:[]) rotate(move?[180,0,-90]:[]) {
    //#import("robi_DIY/files/robi_head_v3.stl");

      color( headcolor, 1.0 ){
//3 x NANO-Shied-PINs
translate([20,-5,1])
cylinder(d=brain_screw_size+2.3,h=4,$fn=30);
translate([20,-20,1])
cylinder(d=brain_screw_size+2.3,h=4,$fn=30);

translate([-20,-12,1])
cylinder(d=brain_screw_size+2.3,h=4,$fn=30);


difference(){
       translate([left,botm,0]) box_chamfer(dims,ch=2,chy1=3.5,chvx=5.5,chvy=4);
      translate([left+head_thickness,botm+head_thickness+1.501,head_thickness]) box_chamfer([dims[0]-head_thickness*2,dims[1]-head_thickness*2-1.5,dims[2]],ch=1,chvx=2.75,chvy=2.75,inside=1);
      translate([left,botm-.01,dims[2]-3.8]) cube([dims[0],1.5,10]);
      for(x=[-13.25,13.25])
                                                           //Loch LED
        translate([x,botm-.01,15]) rotate([-90,0]) cylinder(d=9.6,h=4,$fn=50);
      brain_holes(brain_type,top=dims[1]/2-20,right=dims[0]/2);
      translate([-5.6,-29.555,3.75]) {
        translate([11.25,0]) rotate([-90,0]) rotate([0,0,180]) intersection() {
          box_chamfer([11.3,7.6,2],ch=0,chvx=1.6,chvy=1.6);
          translate([0,0,-.8]) box_chamfer([11.3,7.6,4],ch=1.6,chvx=0,chvy=0);
        }
      }
      if(nose_diameter>0&&dims[2]-(nose_diameter/2+nose_distance)>18)
      {
        translate([0,botm-.01,15+nose_distance]) rotate([-90,0]) cylinder(d=nose_diameter,h=head_thickness+2.02,$fn=30);
      } else echo(str("Warning: Hiding nose."));

       //Schalter Loch Top

      if (Schalter == 1)
       translate(v = [0, 20, -10]) cylinder(h=15, d=SchalterD,$fn=60) ;

      //USB Durchbruch

      if (USB == 1)
      translate([right-65.76,-12,16.5]) rotate([0,90]) rotate([0,0,90])usb_mini();
    }

    // tabs
    mirrorx() translate([-left-2,-9.25,dims[2]]) rotate([-90,0]) mirror([0,1,0]) linear_extrude(21,convexity=10) polygon([[0,0],[0,8.4],[1.98,8.4],[4.1,6.3],[4.1,4.2],[2,2.5],[2,0],]);
    mirrory(0.75) mirrorx(0) translate([left+4.5,botm+1.5,dims[2]]) rotate([90,0])
    //Schenkel
    mirror([0,0,1]) linear_extrude(2) polygon([[0,0],[0,6],[2,8],[6,8],[8,6],[8,0],[15.5,0]]);
    brain(brain_type=brain_type,top=dims[1]/2-20,right=dims[0]/2);
  }
 }
}


//********************* Module leg ***************************
module leg(move=0) {
        color( legcolor, 1.0 ){

  bo=servo_type_ankle=="sg90"?0:(
    servo_type_ankle=="mg90s"?1.6:0);
  translate(move?[0,24,-40]:[]) rotate([0,0,0]) union(){

  difference() {
    translate([-14.5,-8.25,0]) {
      intersection() {
        cube([29,16.5,38.5]);
        union(){
          box_chamfer([29,16.5,20],2);
          translate([0,0,38.6]) mirror([0,0,1]) box_chamfer([29,16.5,20],1.25,chvx=2,chvy=2);
          *translate([1,1,30])
            box_chamfer2([29-2,16.5-2,7],2);
        }
      }
    }
    translate([-12.5,-6.25,4.25]) cube([25,12.5,50]);
    translate([12,-3,5]) cube([6,6,7.5]);
    translate([0.5,0,2.6-(servo_type_hip=="mg90s"?0:1)]) rotate([0,0,90]) {
      linear_extrude(3.4)
        polygon([[-3.1,0],[-2.5,20],[2.5,20],[2.8,0]]); //Breite Durchbruch 2>2.5!!!!
      translate([0,0,-3.01]) cylinder(d=servo_type_ankle=="mg90s"?7.8:7.4,h=8,$fn=30);

    }
    translate([-14.5-.01,0,28.5]) rotate([0,90,0]) {  cylinder(d=0,h=5,$fn=30);
      rotate([0,0,90]) translate([0,0,5]) {
        cylinder(d=12,h=30,$fn=30);
        translate([0,-5.5]) cylinder(d=servo_type_ankle=="mg90s"?6.5:7,h=30,$fn=20);
        translate([-6,0]) cube([12,30,30]);
      }
    }
    if(!leg_solid)
      mirrory() translate([-11.525,-8.3,4.9]) mirror([0,1,0]) rotate([90,0]) linear_extrude(5) {
      //square([21.565,12.93]);
      polygon([[0,0],[0,5.7],[6.1,12.93],[21.565-5.7,12.93],[21.565,5.7],[21.565,0]]);
    }
    translate([-15,0,9]) rotate([0,90,0]) cylinder(d=4,h=5,$fn=20);
  }
  difference() {
    translate([8.55-bo,-3.8,4]) cube([4+bo,7.6,7.5]);
    translate([10-bo,-3,5]) cube([4+bo,6,8]);
    translate([8.5-bo,0,9]) rotate([0,90,0]) cylinder(d=2.2,h=2,$fn=20);
  }
}
}
}

//********************* Module foot ***************************
module foot(move=0) {

    color( footcolor, 1.0 ){


  servohornoff=(servo_type_ankle=="sg90"?2:0);
  translate(move?[0,34.5,-48]:[])

  difference(){
    union(){
      translate([-31,-20,0]) {
        intersection() {
          cube([62,40,5]);
          translate([0,0,-3]) box_chamfer3([62,40,8.01],2);
          *translate([2.8,2.8,0]) box_chamfer2([56.3,34.4,2.5],4);
        }
      }
      translate([15.8,-9.5,15.75]) sphere(d=4,$fn=30);
      for(m=[0,1]) mirror([m,0])
      translate([-21.15,-20,0]) difference() {
        intersection(){
          cube([4+(m?1.1:1.5),21,24.5+(m?0:2)]);
          box_chamfer3([41.8,21,25+(m?0:2)],2);
          *translate([2.8,2.8,0]) box_chamfer2([36.2,15.4,22.5],4);
        }
        translate([5.5,-.01,-.01]) cube([31.3,21.02,25.02]);
        if(m==0)
        translate([-.01,10.5,15.5]) rotate([0,90]) {
            cylinder(d=7.3,h=6+servohornoff,$fn=30);
            translate([-8,0]) cylinder(d=1,h=6+servohornoff,$fn=10);
            rotate([0,0,90]) linear_extrude(2+servohornoff) {
            polygon([[-3.5,0],[-2,10+(m?0:2)],[2,10+(m?0:2)],[3.5,0]]);
          }
        }
      }
    }
    translate([-15.7,-21.01,1]) {
      translate([0,-1,0]) box_chamfer3([31.8,26.02,10],2);
      *intersection(){
        cube([31.8,25.02,10]);
        translate([2,0,2.8]) box_chamfer2([27.3,22,8],4);
      }
    }
  }
}
}

//********************* Module brain_holes ***************************
module brain_holes(brain_type=brain_type,
    right=(body_width-(body_thickness+part_clearance)*2)/2,
    top=(body_depth-(body_thickness+part_clearance)*2)/2-20) {
    blo=(brain_type=="uno_shield"||brain_type=="uno"?14:0);
    bto=(brain_type=="uno_shield"?4:(brain_type=="nano_shield"?-.5:0));
  if(brain_type=="nano_proto") {
    translate([right-2.76,-.2,20.5]) rotate([0,90]) rotate([0,0,90]) usb_mini();
  }
  if(brain_type=="nano_shield"||brain_type=="uno_shield"||brain_type=="uno")
  {
    translate([right-31.5-blo,top-12.5-bto,brain_screw_thru?-.01:head_thickness]) for(pos=arduino_holes) translate(pos) cylinder(d=brain_screw_size,h=3+head_thickness+.02,$fn=24);
  }
  if(brain_type=="nano_shield") {
    translate([0,top-12])
    {
                                                          //Schalter
    translate([right+.01,18.163,12.875]) rotate([0,-90]) cylinder(d=0,h=4,$fn=24);

    }
  } else if(brain_type=="uno_shield"||brain_type=="uno") {
    translate([right-head_thickness-.01,top,7]) {
      cube([head_thickness+.02,8.9+part_clearance*2,10.9+part_clearance*2]);
      translate([0,-31.7]) cube([head_thickness+.02,12+part_clearance*2,10.9+part_clearance*2]);
    }
  }
}

//********************* Module brain ***************************
module brain(brain_type=brain_type,
  right=(body_width-(body_thickness+part_clearance)*2)/2,
  top=(body_depth-(body_thickness+part_clearance)*2)/2-20)
{
  blo=(brain_type=="uno_shield"||brain_type=="uno"?14:0);
  bto=(brain_type=="uno_shield"?4:(brain_type=="nano_shield"?-.5:0));
  translate([right-31.5-blo,top-12.5-bto]) {
  if(brain_type=="nano_shield"||brain_type=="uno_shield"||brain_type=="uno") {
    translate([-25.4,-25,2]) mirror([0,1]) cube([2,4.9+(top-12),3.9]);
    translate([-27-brain_screw_size/2,-8,2]) mirror([1,0]) cube([3-brain_screw_size/2+(right-34),2,3]);
    translate([-27-brain_screw_size/2,20,2]) mirror([1,0]) cube([3-brain_screw_size/2+(right-34),1.98,3]);
    translate([-25.375,29.075,2]) cube([2,1.5+bto,3.9]);
    translate([23.626,29.075,2]) cube([2,1.5+bto,3.9]);
    translate([27,25,2]) cube([4,2,3]);
    translate([22.877,-24,2]) mirror([0,1]) {
      translate([0,1.125]) cube([2,4.875+(top/2+bto-6),3.9]);
      cube([2,6,3]);
    }
    translate([0,0,1.99]) for(pos=arduino_holes)
      translate(pos) brain_screw();
  } else if(brain_type=="nano_proto") {
    translate([0,2,2]) cube([10,4,3]);
    translate([0,0,2]) for(pos=proto_holes)
       translate(pos) {
         difference() {
           union() {
             brain_screw();
             if(pos[1]>0)
              translate([-1,2]) cube([2,4,3]);
             else if(pos[0]>15)
               translate([0,-1]) cube([4,2,3]);
           }
           translate([0,0,-.01]) cylinder(d=2,h=4.02,$fn=20);
       }
     }
     }
  }
}

//********************* Module brain_screw ***************************
module brain_screw(brain_screw_size=brain_screw_size) {
  difference() {
    union(){
      cylinder(d=brain_screw_size+2.3,h=3,$fn=30);
      cylinder(d1=brain_screw_size+4,d2=brain_screw_size+2.3,h=1,$fn=30);
    }
   translate([0,0,-.01]) cylinder(d=brain_screw_size,h=4.02,$fn=20);
  }

}

 //********************* Module usb_mini***************************
module usb_mini() {
  linear_extrude(3,convexity=10) {
    translate([0.6,0]) union() {
      translate([0,0.1]) square([8-1.202,4]);
      for(x=[0.1,6.7]) translate([x,0.1]) circle(r=0.1,$fn=20);
      translate([0.1,0]) square([8.6,5]);
    }
  }
}

//********************* Module box_chamfer3 ***************************
module box_chamfer3(dims,ch=1,bot=1)
{
  render() intersection() {
    cube(dims);
    minkowski()
    {
      translate([ch,ch,ch]) cube([dims[0]-ch*2,dims[1]-ch*2,dims[2]-ch*2]);
      *sphere(r=ch/sin(60),$fn=10);
      for(m=[0,1]) mirror([0,0,m])
        cylinder(r1=ch,r2=m?(bot?0:ch):0,h=ch,$fn=4);
    }
  }
}
//********************* Module box_chamfer2 ***************************
module box_chamfer2(dims,ch=1)
{
  render() minkowski()
  {
    cube(dims);
    intersection()
    {
      rotate([45,0,45]) cube(ch,center=true);
      rotate([45,0,-45]) cube(ch,center=true);
    }
  }
}
//********************* Module box_chamfer ***************************
module box_chamfer(dims,ch=1,chx1="auto",chx2="auto",chy1="auto",chy2="auto",chvx="auto",chvy="auto",inside=0) {
  x1=chx1=="auto"?ch:chx1;
  x2=chx2=="auto"?ch:chx2;
  y1=chy1=="auto"?ch:chy1;
  y2=chy2=="auto"?ch:chy2;
  vx=chvx=="auto"?ch:chvx;
  vy=chvy=="auto"?ch:chvy;
  difference(){
    cube(dims);
    if(x1)
    {
      translate([x1,-.01]) rotate([0,-45]) mirror([1,0]) cube([x1*2,dims[1]+.02,x1*2]);
      *if(vx)
      translate([9.9,0]) rotate([0,0,45]) translate([-5+x1,0]) translate([x1,-.01]) rotate([0,-45]) mirror([1,0])  cube([x1*2,dims[1]+.02,x1*2]);
    }
    if(x2)
      translate([dims[0]-x2,-.01]) rotate([0,45]) cube([x2*2,dims[1]+.02,x2*2]);
    if(y1)
      translate([-.01,y1]) rotate([45,0]) mirror([0,1,0]) cube([dims[0]+.02,y1*2,y1*2]);
    if(y2)
      translate([-.01,dims[1]-y2]) rotate([-45,0]) cube([dims[0]+.02,y2*2,y2*2]);
    if(vx)
    {
      mirrorx(dims[0]/2) {
        translate([vx,0,-.01]) rotate([0,0,45]) mirror([1,0]) cube([vx*2,vx*2,dims[2]+.02]);
        translate([inside?-1.4:-1.5,inside?0:-1.1]) rotate([0,0,45])
        mirror([1,0,0]) rotate([0,45,0])
        translate([-vx,-vx]) translate([0,0,vx/-.75]) cube([10,vx*2,vx*2]);
      }
    }
    if(vy)
      mirrorx(dims[0]/2) {
        translate([0,dims[1]-vy,-.01]) rotate([0,0,-45]) mirror([1,0]) cube([vy*2,vy*2,dims[2]+.02]);
        translate([0,dims[1]+(inside?-0.25:0.5),-.01])
          rotate([0,0,-45]) mirror([1,0,0])
          rotate([0,-45,0])
          translate([-vx,-vx]) translate([0,0,vx/-.75])
          cube([10,vx*2,vx*2]);
      }
  }
}
//********************* Module box_mirror y ***************************
module mirrory(offset=0)
{
  translate([0,offset,0]) for(m=[0,1]) mirror([0,m,0]) translate([0,offset*-1,0]) children();
}
//********************* Module box_mirror x ***************************
module mirrorx(offset=0)
{
  translate([offset,0]) for(m=[0,1]) mirror([m,0]) translate([offset*-1,0]) children();
}
//********************* Print Robi ***************************

if(Brille == 1)
translate([-13,-35,54])
rotate([90,0,0])
color("black")
import("Brille.stl", convexity=3);

if(Hut == 1)
translate([5,-35,70])
color("DimGray")

import("Hut.stl", $fn=160);


module robi_stl()

RAW code

OpenSCAD Dateien

Robi 3D-Druck Gehäuse





Fertig, Glückwunsch!

Technische Hinweise




• Anschlüsse des Servo-Motor SG90/MG90:




Servo-Motor Impulsdiagramme:



• Impulsdiagramm: Ansteuerung des Servos mit einer Frequenz von 50 Hz:





• Impulsdiagramm: Ansteuerung des Servos mit einer Impulsbreite von 2,5ms (180°):





• Programm Download Robi kalibirieren



• Programm Download Robi geht vorwärts



• Programm Download Robi tanzt I



• Programm Download Robi tanzt II