Created my own Copter design.

Quadcopter/Copter.scad

@@ -1,108 +1,154 @@
-//parametric micro quadcopter frame for lulfro and others
-//Patrick Sapinski
-//v1
-//22/05/15
-
-motorDiameter = 7;
-motorHeight = 18;
-shellThickness = 3;
-armThickness = 6;
-m2mDistance = 90;
-batteryWidth = 40;
-
-propLength = 50;
-
-module makeArm() {
-    translate([m2mDistance/2,0,0]) 
+/*
+ * Created by:
+ * Thomas Buck <xythobuz@xythobuz.de> in April 2016
+ *
+ * Licensed under the
+ * Creative Commons - Attribution - Share Alike license.
+ *
+ * Idea based on the "Parametric brushed micro quadcopter"
+ * by "drkow" / Patrick Sapinski:
+ * http://www.thingiverse.com/thing:843597
+ */
+
+// -----------------------------------------------------------
+
+wallSize = 2;
+armSize = 6;
+motorDiameter = 7.3;
+baseWidth = 41;
+diameter = 78;
+height = 5;
+bodyHeight = 8;
+
+motorHeight = 15;
+
+wireWidth = 2;
+wireHeight = 1;
+
+// size of a Turnigy nano-tech 1S 750mAh LiPo
+batteryWidth = 25;
+batteryLength = 45;
+batteryHeight = 10;
+
+// Hubsan compatible propellers/motors
+propeller = 55;
+realMotorHeight = 20;
+
+$fn = 25;
+
+// -----------------------------------------------------------
+
+baseLength = baseWidth + (2 * wallSize);
+realBaseLength = 2 * sqrt(2 * (baseLength / 2) * (baseLength / 2));
+armDiameter = motorDiameter + (wallSize * 2);
+realDiameter = 2 * sqrt(2 * (diameter / 2) * (diameter / 2));
+armLength = ((realDiameter - realBaseLength) / 2) - armDiameter;
+
+// -----------------------------------------------------------
+
+module arm() {
     difference() {
-        //create the motor holder and arm
-        union(){
-            translate([-m2mDistance/2 + motorDiameter/2,-armThickness/2,motorHeight/2 - armThickness]) 
-                cube([m2mDistance/2,armThickness,armThickness]);
-            cylinder(h = motorHeight/2, r=motorDiameter/2 + shellThickness/2);
-            sphere(r=motorDiameter/2 + shellThickness/2);
+        // arm
+        translate([0, -armSize / 2, 0])
+            cube([armLength, armSize, height]);
+        
+        // wire grooves
+        translate([armLength / 3, -wireWidth / 2, 0])
+            cube([armLength * 2 / 3, wireWidth, wireHeight]);
+        translate([armLength / 3, -wireWidth / 2, 0])
+            cube([wireWidth, armSize, wireHeight]);
+        translate([armLength / 3, armSize / 2 - wireHeight, -height / 2])
+            cube([wireWidth, wireHeight, height * 2]);
+        translate([armLength / 3, -wireWidth / 2, height - wireHeight])
+            cube([wireWidth, armSize, wireHeight]);
+        translate([-wireWidth, -wireWidth / 2, height - wireHeight])
+            cube([armLength / 2, wireWidth, wireHeight]);
+    }
+    
+    // motor mount
+    translate([armLength + (armDiameter * 2 / 5), 0, 0])
+    union() {
+        difference() {
+            // wall
+            cylinder(d = armDiameter, h = motorHeight);
+        
+            // motor hole
+            cylinder(d = motorDiameter, h = motorHeight);
             
-        //prop preview
-        %rotate([0,0,45])cube([propLength,5,5],center=true);
+            // wire groove
+            translate([-(motorDiameter / 2) - (wallSize * 3 / 2), -wireWidth / 2, 0])
+                cube([2 * wallSize, wireWidth, wireHeight]);
         }
-        //hollow out the motor holder
-        sphere(r=motorDiameter/2);
-        cylinder(h = motorHeight/2, r=motorDiameter/2);
         
-        //hollow out the groove for the wire in the motor holder
-        translate([-shellThickness,0,-shellThickness]) 
-            cube([m2mDistance,armThickness - shellThickness,motorHeight],center=true);
+        // visualize motors
+        %cylinder(d = motorDiameter, h = realMotorHeight);
         
-        //???
-        translate([-shellThickness*2,-armThickness/2 + shellThickness/2,-motorHeight/2]) 
-            cube([motorHeight,armThickness - shellThickness,motorHeight + shellThickness]);
+        // visualize propellers
+        %translate([0, 0, realMotorHeight])
+            cylinder(d = propeller, h = 2);
     }
 }
 
+// -----------------------------------------------------------
+
+// visualize real diameter (print bed size)
+%translate([-diameter / 2, -diameter / 2, -height - batteryHeight])
+    cube([diameter, diameter, height]);
+
+// four arms
+rotate([0, 0, 45])
+for (i = [0 : 90 : 360]) {
+    rotate([0, 0, i])
+        translate([realBaseLength / 2 - (wallSize * 11 / 7), 0, 0])
+        arm();
+}
+
 difference() {
-    union(){
-        //create each arm
-        rotate([0,0,45]){
-                rotate([0,0,90]) makeArm();
-                rotate([0,0,180]) makeArm();
-                rotate([0,0,270]) makeArm();
-                rotate([0,0,360]) makeArm();
-        }
-        
-        //create the FC cube
-        translate([0,0,motorHeight/2 - armThickness/2]) 
-            cube([batteryWidth + shellThickness,batteryWidth + shellThickness,armThickness],center=true);
-    }
-    translate([0,0,motorHeight/2 - armThickness/2 - motorHeight/2 + shellThickness/2])
-    union(){
-        //hollow out some grooves in the arms for the wires
-        rotate([0,0,45])
-            cube([armThickness - shellThickness,m2mDistance/2,motorHeight/1.5],center=true);
-        rotate([0,0,45])
-            cube([m2mDistance/2,armThickness - shellThickness,motorHeight/1.5],center=true);
-    }
+    // body
+    translate([-baseLength / 2, -baseLength / 2, 0])
+        cube([baseLength, baseLength, bodyHeight]);
     
-    //hollow out the FC hole
-    translate([0,0,motorHeight/2 - armThickness/2 - shellThickness/2]) 
-    cube([batteryWidth,batteryWidth,armThickness],center=true);
+    // space for flight control
+    translate([-baseWidth / 2, -baseWidth / 2, -bodyHeight / 2])
+        cube([baseWidth, baseWidth, bodyHeight * 2]);
     
-    //drunk code below
-    b = 20;
-    h = 20;
-    w = 4;
-    rotate(a=[0,0,45])
-        translate([2,2,motorHeight/2]) 
-            linear_extrude(height = w, center = true, convexity = 10, twist = 0)
-                polygon(points=[[0,0],[h,0],[0,b]], paths=[[0,1,2]]);
-        
-    rotate(a=[0,0,45 + 180])
-        translate([2,2,motorHeight/2]) 
-            linear_extrude(height = w, center = true, convexity = 10, twist = 0)
-                polygon(points=[[0,0],[h,0],[0,b]], paths=[[0,1,2]]);
-        
-    rotate(a=[0,0,45 + 90])
-        translate([2,2,motorHeight/2]) 
-            linear_extrude(height = w, center = true, convexity = 10, twist = 0)
-                polygon(points=[[0,0],[h,0],[0,b]], paths=[[0,1,2]]);
-        
-    rotate(a=[0,0,45 + 270])
-        translate([2,2,motorHeight/2]) 
-            linear_extrude(height = w, center = true, convexity = 10, twist = 0)
-                polygon(points=[[0,0],[h,0],[0,b]], paths=[[0,1,2]]);
+    // wire grooves
+    for (i = [0 : 3]) {
+        a = (i % 2) ? 1 : -1;
+        b = (i < 2) ? 1 : -1;
+        translate([a * (baseWidth + wallSize) / 2
+                        - ((a == 1) ? (
+                            (b == 1) ? wallSize / 2 : wallSize / 2)
+                        : 0),
+                    b * (baseWidth + wallSize) / 2
+                        - ((a == 1) ? (
+                            (b == 1) ? wallSize / 2 : -wallSize / 2)
+                        : 0),
+                    height - wireHeight])
+            rotate([0, 0, a * b * 45])
+            translate([-wallSize, -wireWidth / 2, 0])
+            cube([wallSize * 3, wireWidth, bodyHeight]);
+    }
 }
-/*
-//parabolic arm attempt...
 
-module oval(w,h, height, center = false) {
-    scale([1, h/w, 1]) cylinder(h=height, r=w, center=center);
+// battery holder / bottom part
+union() {
+    translate([-baseWidth / 2, -batteryWidth / 3, 0])
+        cube([baseWidth, batteryWidth * 2 / 3, wallSize]);
+
+    translate([baseWidth / 4, batteryWidth / 3, 0])
+        cube([baseWidth / 8, (baseWidth - batteryWidth * 2 / 3) / 2, wallSize]);
+    
+    translate([-baseWidth * 6 / 16, batteryWidth / 3, 0])
+        cube([baseWidth / 8, (baseWidth - batteryWidth * 2 / 3) / 2, wallSize]);
+    
+    translate([baseWidth / 4, - batteryWidth / 2 - (baseWidth - batteryWidth) / 2, 0])
+        cube([baseWidth / 8, (baseWidth - batteryWidth * 2 / 3) / 2, wallSize]);
+    
+    translate([-baseWidth * 6 / 16, - batteryWidth / 2 - (baseWidth - batteryWidth) / 2, 0])
+        cube([baseWidth / 8, (baseWidth - batteryWidth * 2 / 3) / 2, wallSize]);
 }
 
-    translate([0,0,2]) 
-    difference() {
-        cube([m2mDistance,m2mDistance,fcHeight],center=true);
-            for (i = [0 : 3])
-                rotate([0,0,i * 90])
-                    translate([m2mDistance + 10,0,0]) 
-                        oval(m2mDistance/2 + 40,m2mDistance/2, 5);
-    }
-*/
+// visualize battery
+%translate([-batteryLength / 2, -batteryWidth / 2, -batteryHeight])
+    cube([batteryLength, batteryWidth, batteryHeight]);