add am8 mounting plates

am8/bottom_corner_5mm.scad

@@ -0,0 +1,38 @@
+$fn = 42;
+
+module prism(l, w, h) {
+    polyhedron(
+        points = [[0,0,0], [l,0,0], [l,w,0], [0,w,0], [0,w,h], [l,w,h]],
+        faces = [[0,1,2,3],[5,4,3,2],[0,4,5,1],[0,3,4],[5,2,1]]
+    );
+}
+
+difference() {
+    union() {
+        color("green")
+        hull() {
+            cube([60, 20, 5]);
+            cube([20, 60, 5]);
+        }
+        
+        color("red")
+        translate([25, 7.5, 5])
+        cube([35, 5, 1]);
+        
+        color("red")
+        translate([7.5, 25, 5])
+        cube([5, 35, 1]);
+    }
+    
+    translate([20, 20 + 23, -1])
+    rotate([0, -90, 180])
+    prism(7, 23, 23);
+    
+    for (i = [10, 30, 50])
+    translate([i, 10, -1])
+    cylinder(d = 5.2, h = 8);
+    
+    for (i = [30, 50])
+    translate([10, i, -1])
+    cylinder(d = 5.2, h = 8);
+} 

am8/cable_tie.scad

@@ -0,0 +1,107 @@
+wall = 4.0;
+screw_dia = 5.2;
+screw_head = 10.0;
+screw_bottom = 2.0;
+width = 40.0;
+height = 25.0;
+screw_off_x = 10.0;
+screw_off_y = 10.0;
+screw_dist = 24.15 - 9.35;
+
+tie_off_z = 2.0;
+cabletie_width = 3.2;
+cabletie_height = 2.0;
+tie_wall_side = 1.0;
+tie_wall_top = 1.0;
+tie_wall = 5.0;
+tie_width = cabletie_width + 2 * tie_wall_side;
+tie_height = cabletie_height + 2 * tie_wall_top;
+tie_add_bottom = 2.0;
+
+$fn = 42;
+
+module cable() {
+    translate([-(tie_width + tie_add_bottom) / 2, -(tie_wall + tie_add_bottom) / 2, 0])
+    translate([tie_add_bottom / 2, tie_add_bottom / 2, 0])
+    difference() {
+        hull() {
+            cube([tie_width, tie_wall, tie_height + tie_off_z]);
+            
+            translate([-tie_add_bottom / 2, -tie_add_bottom / 2, 0])
+            cube([tie_width + tie_add_bottom, tie_wall + tie_add_bottom, 0.1]);
+        }
+        
+        translate([(tie_width - cabletie_width) / 2, -1, (tie_height - cabletie_height) / 2 + tie_off_z])
+        cube([cabletie_width, tie_wall + 2, cabletie_height]);
+    }
+}
+
+module x_tie() {
+    difference() {
+        union() {
+            cube([width, height, wall]);
+            
+            translate([5 + 1, 20 - 1, wall])
+            rotate([0, 0, -45])
+            cable();
+        }
+        
+        for (i = [0, screw_dist])
+        translate([width - screw_off_x - i, screw_off_y, 0]) {
+            translate([0, 0, -1])
+            cylinder(d = screw_dia, h = wall + 2);
+            
+            translate([0, 0, screw_bottom])
+            cylinder(d = screw_head, h = wall + 2);
+        }
+    }
+}
+
+rail = 20;
+rail_wall = 2.0;
+rail_h = cabletie_height + 2 * rail_wall;
+rail_screw = 3.2;
+rail_screw_head = 6.0;
+rail_screw_len = 3.5;
+
+module rail_tie(rot) {
+    difference() {
+        union() {
+            cube([rail, rail, rail_h]);
+            
+            translate([(rail - (rail / 4)) / 2, 0, rail_h])
+            cube([rail / 4, rail, 1]);
+        }
+        
+        translate([rail / 2, rail / 2, -1]) {
+            cylinder(d = rail_screw, h = rail_h + 3);
+            cylinder(d = rail_screw_head, h = rail_screw_len + 1);
+        }
+        
+        for (x = [1, 4])
+        if (rot) {
+            translate([-1, (rail - rail_screw) / x - cabletie_width / 2, rail_wall])
+            cube([rail + 2, cabletie_width, cabletie_height]);
+        } else {
+            translate([(rail - rail_screw) / x - cabletie_width / 2, -1, rail_wall])
+            cube([cabletie_width, rail + 2, cabletie_height]);
+        }
+    }
+}
+
+module rail_assembly() {
+    %translate([0, -50, rail_h])
+    cube([20, 100, 20]);
+    
+    translate([0, 10, 0])
+    rail_tie(0);
+    
+    translate([0, -10 - rail, 0])
+    rail_tie(1);
+}
+
+rail_assembly();
+
+//x_tie();
+//rail_tie(0);
+//rail_tie(1);

am8/mosfet_mount.scad

@@ -0,0 +1,80 @@
+mosfet_width = 70;
+mosfet_height = 60;
+mosfet_depth = 2;
+
+mosfet_holes_x = 63;
+mosfet_holes_y = 53;
+mosfet_dia = 3.2;
+
+wall = 5.0;
+mosfet_wall_dist = 5.0;
+mosfet_mount_dist = 2.0;
+mount_dia = 4.2;
+
+cutout_len = 30;
+cutout_dist = 4;
+
+$fn = 42;
+
+module prism(l, w, h) {
+    polyhedron(
+        points = [[0,0,0], [l,0,0], [l,w,0], [0,w,0], [0,w,h], [l,w,h]],
+        faces = [[0,1,2,3],[5,4,3,2],[0,4,5,1],[0,3,4],[5,2,1]]
+    );
+}
+
+module mosfet() {
+    cube([mosfet_width, mosfet_height, mosfet_depth]);
+    
+    for (x = [-1, 1])
+    for (y = [-1, 1])
+    translate([mosfet_width / 2 + x * mosfet_holes_x / 2, mosfet_height / 2 + y * mosfet_holes_y / 2, -mosfet_mount_dist - wall - 1])
+    cylinder(d = mosfet_dia - 0.2, h = mosfet_mount_dist + wall + 1);
+}
+
+module mount() {
+    translate([0, -wall, 0])
+    difference() {
+        union() {
+            cube([mosfet_width + mosfet_wall_dist + 20, wall, mosfet_height]);
+            
+            translate([mosfet_width + mosfet_wall_dist + 7.5, wall, 0])
+            cube([5, 1, mosfet_height]);
+            
+            for (x = [-1, 1])
+            for (y = [-1, 1])
+            translate([mosfet_width / 2 + x * mosfet_holes_x / 2, wall, mosfet_height / 2 + y * mosfet_holes_y / 2])
+            rotate([-90, 0, 0])
+            cylinder(d = 7, h = mosfet_mount_dist);
+        }
+        
+        for (i = [-15, 15])
+        translate([mosfet_width + mosfet_wall_dist + 10, -1, mosfet_height / 2 + i])
+        rotate([-90, 0, 0])
+        cylinder(d = mount_dia, h = wall + 3);
+        
+        for (x = [-1, 1])
+        for (y = [-1, 1])
+        translate([mosfet_width / 2 + x * mosfet_holes_x / 2, -1, mosfet_height / 2 + y * mosfet_holes_y / 2])
+        rotate([-90, 0, 0])
+        cylinder(d = mosfet_dia, h = wall + mosfet_mount_dist + 2);
+        
+        for (i = [0, 1, 2, 3])
+        translate([mosfet_width / 2, 0, mosfet_height / 2])
+        rotate([0, 90 * i, 0])
+        translate([cutout_len * sqrt(2) / 2 + cutout_dist, -1, -cutout_len * sqrt(2) / 2])
+        rotate([45, 0, 90])
+        prism(wall + 2, cutout_len, cutout_len);
+    }
+}
+
+module assembly() {
+    %translate([0, mosfet_mount_dist, mosfet_height])
+    rotate([-90, 0, 0])
+    mosfet();
+    
+    mount();
+}
+
+rotate([90, 0, 0])
+assembly();

am8/pi_mount.scad

@@ -0,0 +1,85 @@
+pi_width = 85;
+pi_height = 56;
+pi_hole_dist_x = 58;
+pi_hole_dist_y = 49;
+pi_hole_off_x = 3.5;
+pi_hole_off_y = 3.5;
+pi_hole = 2.8;
+
+wall = 5.0;
+pi_wall_dist = 10;
+pi_mount_dist = 5.0;
+pi_mount_post_top = 6.3;
+pi_mount_post_bot = 10.0;
+mount_dia = 4.2;
+
+mount_width = pi_hole_dist_x + pi_wall_dist + 20 + pi_hole_off_x + pi_hole / 2 + wall;
+mount_height = pi_height + 5;
+
+$fn = 42;
+
+module prism(l, w, h) {
+    polyhedron(
+        points = [[0,0,0], [l,0,0], [l,w,0], [0,w,0], [0,w,h], [l,w,h]],
+        faces = [[0,1,2,3],[5,4,3,2],[0,4,5,1],[0,3,4],[5,2,1]]
+    );
+}
+
+module cutout(l, o) {
+    for (r = [0, 90, 180, 270])
+    rotate([r + 45, 0, -90])
+    translate([0, -l - o, o])
+    prism(wall + 2, l, l);
+}
+
+module holes(h, d1 = pi_hole, d2 = pi_hole) {
+    for (x = [0, pi_hole_dist_x])
+    for (y = [0, pi_hole_dist_y])
+    translate([pi_hole_off_x + x, 0, pi_hole_off_y + y])
+    rotate([90, 0, 0])
+    cylinder(d1 = d1, d2 = d2, h = h);
+}
+
+module pi() {
+    cube([pi_width, 2.0, pi_height]);
+    
+    translate([0, 10, 0])
+    holes(20);
+}
+
+module mount() {
+    difference() {
+        union() {
+            cube([mount_width, wall, mount_height]);
+            
+            translate([7.5, wall, 0])
+            cube([5, 1, mount_height]);
+            
+            translate([20 + pi_wall_dist, pi_mount_dist + wall, (mount_height - pi_height) / 2])
+            holes(pi_mount_dist, pi_mount_post_top, pi_mount_post_bot);
+        }
+        
+        for (z = [mount_height / 4, mount_height / 4 * 3])
+        translate([10, -1, z])
+        rotate([-90, 0, 0])
+        cylinder(d = mount_dia, h = wall + 3);
+        
+        translate([20 + pi_wall_dist, wall + pi_mount_dist + 1, (mount_height - pi_height) / 2])
+        holes(wall + pi_mount_dist + 2);
+        
+        translate([63, wall + 1, 30])
+        cutout(30, 2);
+    }
+}
+
+module assembly() {
+    %cube([20, 40, 100]);
+    
+    %translate([20 + pi_wall_dist, pi_mount_dist, 20])
+    pi();
+    
+    translate([0, -wall, 20 - (mount_height - pi_height) / 2])
+    mount();
+}
+
+assembly();

am8/psu_mount.scad

@@ -0,0 +1,237 @@
+
+psu_width = 112.7;
+psu_height = 49.8;
+psu_length = 216;
+psu_screw = 4.2;
+psu_screw_off_x = 29.5 + 3.2 / 2;
+psu_screw_off_y = 29.35 + 3.2 / 2;
+psu_screw_dist_x = 53.3 - 3.2;
+psu_screw_dist_y = 154.3 - 3.2;
+
+psu_wall_dist = 10;
+mount_wall = 5.0;
+mount_width = 12.0;
+mount_height = 70;
+mount_screw = 4.2;
+
+$fn = 42;
+
+module prism(l, w, h) {
+    polyhedron(
+        points = [[0,0,0], [l,0,0], [l,w,0], [0,w,0], [0,w,h], [l,w,h]],
+        faces = [[0,1,2,3],[5,4,3,2],[0,4,5,1],[0,3,4],[5,2,1]]
+    );
+}
+
+module psu() {
+    cube([psu_width, psu_height, psu_length]);
+    
+    for (x = [0, psu_screw_dist_x])
+    for (y = [0, psu_screw_dist_y])
+    translate([psu_screw_off_x + x, 0, psu_screw_off_y + y])
+    rotate([90, 0, 0])
+    cylinder(d = psu_screw - 1.0, h = 10.0);
+}
+
+module mount_geo() {
+    difference() {
+        union() {
+            hull() {
+                translate([psu_width - psu_screw_off_x - psu_screw_dist_x - mount_width, -mount_wall, -mount_width / 2])
+                cube([psu_screw_dist_x + psu_screw_off_x + psu_wall_dist + mount_width, mount_wall, mount_width]);
+                
+                translate([psu_width + psu_wall_dist, -mount_wall, -mount_width / 2])
+                cube([20, mount_wall, mount_height]);
+            }
+            
+            translate([psu_width + psu_wall_dist + 7.5, 0, -mount_width / 2])
+            cube([5, 1, mount_height]);
+        }
+        
+        translate([psu_screw_off_x + 8, 1, mount_width / 2])
+        rotate([0, 0, -90])
+        prism(mount_wall + 2, psu_width - psu_screw_off_x + psu_wall_dist - 8, mount_height - mount_width - mount_wall - 8);
+        
+        for (x = [0, psu_screw_dist_x])
+        translate([psu_screw_off_x + x, 1, 0])
+        rotate([90, 0, 0])
+        cylinder(d = psu_screw, h = mount_wall + 2);
+        
+        for (y = [0, (mount_height - mount_width) / 2, mount_height - mount_width])
+        translate([psu_width + psu_wall_dist + 10, 2, y])
+        rotate([90, 0, 0])
+        cylinder(d = mount_screw, h = mount_wall + 3);
+    }
+}
+
+module mount(type) {
+    scale([1, 1, -1 * (type * 2 - 1)])
+    mount_geo();
+}
+
+relais_width = 50;
+relais_height = 26;
+relais_depth = 17;
+relais_screw = 3.2;
+relais_screw_dist_x = 44.8;
+relais_screw_dist_y = 21.1;
+relais_mount_off_y = 30;
+
+relais_wall_dist = relais_mount_off_y;
+mount_relais_wall = 5.0;
+mount_relais_screw = 4.2;
+relais_screw_off_x = (relais_width - relais_screw_dist_x) / 2;
+relais_screw_off_y = (relais_height - relais_screw_dist_y) / 2;
+mount_relais_width = relais_width + 2 * mount_relais_wall;
+mount_relais_width_add = (psu_width - relais_width) / 2 + mount_relais_wall + 20;
+mount_relais_height = relais_height + 2 * mount_relais_wall;
+
+module relais() {
+    cube([relais_width, 5, relais_height]);
+    
+    translate([relais_width / 2 - 5, 5, relais_height / 2 - 5])
+    cube([10, relais_depth - 5, 10]);
+    
+    for (x = [-1, 1])
+    for (y = [-1, 1])
+    translate([relais_width / 2 + x * relais_screw_dist_x / 2, 0, relais_height / 2 + y * relais_screw_dist_y / 2])
+    rotate([90, 0, 0])
+    cylinder(d = relais_screw, h = 10);
+}
+
+module cutout(l, o) {
+    for (r = [0, 90, 180, 270])
+    rotate([r + 45, 0, -90])
+    translate([0, -l - o, o])
+    prism(mount_relais_wall + 2, l, l);
+}
+
+module mount_relais() {
+    difference() {
+        union() {
+            translate([-mount_relais_wall, -mount_relais_wall, -mount_relais_wall])
+            cube([mount_relais_width + mount_relais_width_add, mount_relais_wall, mount_relais_height]);
+                
+            translate([mount_relais_width + mount_relais_width_add - mount_relais_wall - 12.5, 0, -mount_relais_wall])
+            cube([5, 1, mount_relais_height]);
+        }
+        
+        for (x = [-1, 1])
+        for (y = [-1, 1])
+        translate([relais_width / 2 + x * relais_screw_dist_x / 2, 1, relais_height / 2 + y * relais_screw_dist_y / 2])
+        rotate([90, 0, 0])
+        cylinder(d = relais_screw, h = 10);
+        
+        for (y = [0, mount_relais_height - mount_relais_wall * 2])
+        translate([mount_relais_width + mount_relais_width_add - mount_relais_wall - 10, 2, y])
+        rotate([90, 0, 0])
+        cylinder(d = mount_relais_screw, h = mount_relais_wall + 3);
+        
+        translate([24, 1, 13])
+        cutout(15, 2);
+        translate([70, 1, 13])
+        cutout(15, 2);
+    }
+}
+
+psu2_width = 70.25;
+psu2_height = 31.2;
+psu2_length = 39.0;
+psu2_screw = 3.2;
+psu2_screw_off_x = 5.0 - 3.2 / 2;
+psu2_screw_off_y = 11.6 + 3.2 / 2;
+psu2_screw_dist_x = 59.6 + 3.2;
+psu2_screw_dist_y = 0;
+
+module psu2() {
+    cube([psu2_width, psu2_height, psu2_length]);
+    
+    for (x = [0, psu2_screw_dist_x])
+    for (y = [0, psu2_screw_dist_y])
+    translate([psu2_screw_off_x + x, 0, psu2_screw_off_y + y])
+    rotate([90, 0, 0])
+    cylinder(d = psu2_screw - 1.0, h = 10.0);
+}
+
+psu2_mount_off_y = relais_mount_off_y;
+psu2_wall_dist = (psu_width - psu2_width) / 2 + psu_wall_dist;
+mount2_wall = 5.0;
+mount2_width = 8.0;
+mount2_height = 50;
+mount2_screw = 4.2;
+
+module mount2() {
+    difference() {
+        union() {
+            hull() {
+                translate([psu2_width - psu2_screw_off_x - psu2_screw_dist_x - mount2_width, -mount2_wall, -mount2_width / 2])
+                cube([psu2_screw_dist_x + psu2_screw_off_x + psu2_wall_dist + mount2_width, mount2_wall, mount2_width]);
+                
+                translate([psu2_width + psu2_wall_dist, -mount2_wall, -mount2_width / 2])
+                cube([20, mount2_wall, mount2_height]);
+            }
+            
+            translate([psu2_width + psu2_wall_dist + 7.5, 0, -mount2_width / 2])
+            cube([5, 1, mount2_height]);
+        }
+        
+        translate([psu2_screw_off_x + 8, 1, mount2_width / 2])
+        rotate([0, 0, -90])
+        prism(mount2_wall + 2, psu2_width - psu2_screw_off_x + psu2_wall_dist - 8, mount2_height - mount2_width - mount2_wall - 8 + 5);
+        
+        for (x = [0, psu2_screw_dist_x])
+        translate([psu2_screw_off_x + x, 1, 0])
+        rotate([90, 0, 0])
+        cylinder(d = psu2_screw, h = mount2_wall + 2);
+        
+        for (y = [0, mount2_height - mount2_width])
+        translate([psu2_width + psu2_wall_dist + 10, 2, y])
+        rotate([90, 0, 0])
+        cylinder(d = mount2_screw, h = mount2_wall + 3);
+    }
+}
+
+module assembly() {
+    %psu();
+    
+    %translate([psu_width + psu_wall_dist, 0, 0])
+    cube([20, 40, 400]);
+    
+    for (i = [0, 1])
+    translate([0, 0, psu_screw_off_y + i * psu_screw_dist_y])
+    mount(i);
+    
+    %translate([(psu_width - relais_width) / 2, 0, psu_length + relais_mount_off_y])
+    relais();
+    
+    %translate([(psu_width - psu2_width) / 2, 0, psu_length + relais_mount_off_y + relais_height + psu2_mount_off_y])
+    psu2();
+    
+    translate([(psu_width - psu2_width) / 2, 0, psu_length + relais_mount_off_y + relais_height + psu2_mount_off_y + psu2_screw_off_y])
+    mount2();
+    
+    translate([(psu_width - relais_width) / 2, 0, psu_length + relais_mount_off_y])
+    mount_relais();
+}
+
+module print() {
+    translate([0, 0, mount_wall])
+    rotate([90, 0, 0])
+    mount(0);
+    
+    translate([0, 40, mount_wall])
+    rotate([90, 0, 0])
+    mount(1);
+    
+    translate([-150, 40, mount2_wall])
+    rotate([90, 0, 0])
+    mount2();
+    
+    translate([-150, -30, mount_relais_wall])
+    rotate([90, 0, 0])
+    mount_relais();
+}
+
+//assembly();
+//print();
+mount_relais();

am8/skr_mini_mount.scad

@@ -0,0 +1,116 @@
+pcb_width = 70.25;
+pcb_height = 103.75;
+pcb_depth = 2;
+
+pcb_holes = [
+    [ 32.05, 5.53 ],
+    [ 29.41, 37.34 ],
+    [ pcb_width - 3.22, 23.39 ],
+    [ pcb_width - 3.02, pcb_height - 18.20 ],
+    [ 2.56, pcb_height - 2.53 ]
+];
+hole_support_dia = 2.53 * 2; // min value of pcb_holes * 2
+pcb_dia = 3.2;
+
+wall = 5.0;
+pcb_wall_dist = 15;
+pcb_mount_dist = 5.0;
+mount_dia = 4.2;
+
+mounting_holes = [
+    pcb_height * 1 / 8,
+    pcb_height * 4 / 8,
+    pcb_height * 7 / 8
+];
+
+cutouts = [
+    [ 12.5, 2, 10, -30 ],
+    [ 12.5, 2, 35, -30 ],
+    [ 12.5, 2, -15, -30 ],
+    
+    [ 12.5, 2, 10, -5 ],
+    [ 12.5, 2, 35, -5 ],
+    [ 12.5, 2, -15, -5 ],
+    
+    [ 12.5, 2, 10, 30 ],
+    [ 12.5, 2, 35, 30 ],
+    [ 12.5, 2, -15, 30 ],
+    
+    /*
+    [ 20, 4, -5, -22.5 ],
+    [ 20, 4, 35, -22.5 ],
+    [ 25, 4, 32.5, 22.5 ],
+    [ 10, 4, -12.5, 35 ],
+    [ 10, 4, -12.5, 10 ],
+    */
+];
+
+$fn = 42;
+
+module prism(l, w, h) {
+    polyhedron(
+        points = [[0,0,0], [l,0,0], [l,w,0], [0,w,0], [0,w,h], [l,w,h]],
+        faces = [[0,1,2,3],[5,4,3,2],[0,4,5,1],[0,3,4],[5,2,1]]
+    );
+}
+
+module holes(dia, height) {
+    for (h = [0 : len(pcb_holes) - 1])
+    translate([pcb_width - pcb_holes[h][0], pcb_holes[h][1], 0])
+    cylinder(d = dia, h = height);
+}
+
+module pcb() {
+    cube([pcb_width, pcb_height, pcb_depth]);
+    
+    translate([0, 0, -pcb_mount_dist - wall - 1])
+    holes(pcb_dia - 0.2, pcb_mount_dist + wall + 1);
+}
+
+module mount() {
+    translate([0, -wall, 0])
+    difference() {
+        union() {
+            cube([pcb_width + pcb_wall_dist + 20, wall, pcb_height]);
+            
+            translate([pcb_width + pcb_wall_dist + 7.5, wall, 0])
+            cube([5, 1, pcb_height]);
+            
+            translate([0, wall, pcb_height])
+            rotate([-90, 0, 0])
+            holes(hole_support_dia, pcb_mount_dist);
+        }
+        
+        for (i = mounting_holes)
+        translate([pcb_width + pcb_wall_dist + 10, -1, i])
+        rotate([-90, 0, 0])
+        cylinder(d = mount_dia, h = wall + 3);
+        
+        translate([0, -1, pcb_height])
+        rotate([-90, 0, 0])
+        holes(pcb_dia, wall + pcb_mount_dist + 2);
+        
+        for (c = [0 : len(cutouts) - 1])
+        for (i = [0, 1, 2, 3])
+        translate([pcb_width / 2 + cutouts[c][2], 0, pcb_height / 2 + cutouts[c][3]])
+        rotate([0, 90 * i, 0])
+        translate([cutouts[c][0] * sqrt(2) / 2 + cutouts[c][1], -1, -cutouts[c][0] * sqrt(2) / 2])
+        rotate([45, 0, 90])
+        prism(wall + 2, cutouts[c][0], cutouts[c][0]);
+    }
+}
+
+module assembly() {
+    %translate([0, pcb_mount_dist, pcb_height])
+    rotate([-90, 0, 0])
+    pcb();
+    
+    mount();
+}
+
+//translate([0, 0, pcb_height])
+//rotate([0, 180, 0])
+
+rotate([90, 0, 0])
+
+assembly();

am8/switching_supply_mount.scad

@@ -0,0 +1,80 @@
+mosfet_width = 60 + 3;
+mosfet_height = 40 + 3;
+mosfet_depth = 2;
+
+mosfet_holes_x = 56;
+mosfet_holes_y = 36;
+mosfet_dia = 2.2;
+
+wall = 5.0;
+mosfet_wall_dist = 15.0;
+mosfet_mount_dist = 2.0;
+mount_dia = 4.2;
+
+cutout_len = 20;
+cutout_dist = 4;
+
+$fn = 42;
+
+module prism(l, w, h) {
+    polyhedron(
+        points = [[0,0,0], [l,0,0], [l,w,0], [0,w,0], [0,w,h], [l,w,h]],
+        faces = [[0,1,2,3],[5,4,3,2],[0,4,5,1],[0,3,4],[5,2,1]]
+    );
+}
+
+module mosfet() {
+    cube([mosfet_width, mosfet_height, mosfet_depth]);
+    
+    for (x = [-1, 1])
+    for (y = [-1, 1])
+    translate([mosfet_width / 2 + x * mosfet_holes_x / 2, mosfet_height / 2 + y * mosfet_holes_y / 2, -mosfet_mount_dist - wall - 1])
+    cylinder(d = mosfet_dia - 0.2, h = mosfet_mount_dist + wall + 1);
+}
+
+module mount() {
+    translate([0, -wall, 0])
+    difference() {
+        union() {
+            cube([mosfet_width + mosfet_wall_dist + 20, wall, mosfet_height]);
+            
+            translate([mosfet_width + mosfet_wall_dist + 7.5, wall, 0])
+            cube([5, 1, mosfet_height]);
+            
+            for (x = [-1, 1])
+            for (y = [-1, 1])
+            translate([mosfet_width / 2 + x * mosfet_holes_x / 2, wall, mosfet_height / 2 + y * mosfet_holes_y / 2])
+            rotate([-90, 0, 0])
+            cylinder(d = 7, h = mosfet_mount_dist);
+        }
+        
+        for (i = [-15, 15])
+        translate([mosfet_width + mosfet_wall_dist + 10, -1, mosfet_height / 2 + i])
+        rotate([-90, 0, 0])
+        cylinder(d = mount_dia, h = wall + 3);
+        
+        for (x = [-1, 1])
+        for (y = [-1, 1])
+        translate([mosfet_width / 2 + x * mosfet_holes_x / 2, -1, mosfet_height / 2 + y * mosfet_holes_y / 2])
+        rotate([-90, 0, 0])
+        cylinder(d = mosfet_dia, h = wall + mosfet_mount_dist + 2);
+        
+        for (i = [0, 1, 2, 3])
+        translate([mosfet_width / 2, 0, mosfet_height / 2])
+        rotate([0, 90 * i, 0])
+        translate([cutout_len * sqrt(2) / 2 + cutout_dist, -1, -cutout_len * sqrt(2) / 2])
+        rotate([45, 0, 90])
+        prism(wall + 2, cutout_len, cutout_len);
+    }
+}
+
+module assembly() {
+    %translate([0, mosfet_mount_dist, mosfet_height])
+    rotate([-90, 0, 0])
+    mosfet();
+    
+    mount();
+}
+
+rotate([90, 0, 0])
+assembly();

am8/top_corner_5mm.scad

@@ -0,0 +1,44 @@
+$fn = 42;
+
+module prism(l, w, h) {
+    polyhedron(
+        points = [[0,0,0], [l,0,0], [l,w,0], [0,w,0], [0,w,h], [l,w,h]],
+        faces = [[0,1,2,3],[5,4,3,2],[0,4,5,1],[0,3,4],[5,2,1]]
+    );
+}
+
+difference() {
+    union() {
+        color("green")
+        hull() {
+            cube([80, 40, 5]);
+            cube([40, 80, 5]);
+        }
+        
+        color("red")
+        for (i = [0, 20])
+        translate([45, 7.5 + i, 5])
+        cube([35, 5, 1]);
+        
+        color("red")
+        for (i = [0, 20])
+        translate([7.5 + i, 45, 5])
+        cube([5, 35, 1]);
+    }
+    
+    translate([40, 40 + 23, -1])
+    rotate([0, -90, 180])
+    prism(7, 23, 23);
+    
+    for (i = [30, 70])
+    translate([i, 10, -1])
+    cylinder(d = 5.2, h = 8);
+    
+    for (i = [10, 70])
+    translate([i, 30, -1])
+    cylinder(d = 5.2, h = 8);
+    
+    for (i = [10, 30])
+    translate([i, 70, -1])
+    cylinder(d = 5.2, h = 8);
+} 

am8/y_bearing_mount.scad

@@ -0,0 +1,102 @@
+bearing_dia = 15.0;
+bearing_len = 23.8;
+mount_hole = bearing_dia + 0.4;
+hole_dia = 4.2;
+hole_dist_x = 24.0;
+hole_dist_y = 18.0;
+screw_nut = 7.75;
+screw_nut_off = 2.5;
+base_side = 5.0;
+base_wall = 5.0;
+mount_bearing_dist = 13.0;
+shim_width = 16.0;
+cutout = 5.0;
+top_screw_dia = 3.2;
+top_screw_head = 6.0;
+top_screw_head_off = base_side;
+top_screw_nut = 6.2;
+top_screw_nut_off = 3.0;
+
+base_width = hole_dist_x + base_side * 2;
+base_length = hole_dist_y + base_side * 2;
+
+$fn = 42;
+
+module bearing() {
+    difference() {
+        cylinder(d = bearing_dia, h = bearing_len);
+        
+        translate([0, 0, -1])
+        cylinder(d = 8.0, h = bearing_len + 2);
+    }
+}
+
+module mount() {
+    %translate([0, (base_length - bearing_len) / 2, bearing_dia / 2 + mount_bearing_dist])
+    rotate([-90, 0, 0])
+    bearing();
+    
+    difference() {
+        union() {
+            // base
+            translate([-base_width / 2, 0, 0])
+            cube([base_width, base_length, base_wall]);
+            
+            hull() {
+                // bearing outer hull
+                translate([0, 0, bearing_dia / 2 + mount_bearing_dist])
+                rotate([-90, 0, 0])
+                cylinder(d = mount_hole + 2 * base_side, h = base_length);
+                
+                // top clamp for screw
+                translate([-cutout / 2 - base_side, 0, bearing_dia + mount_bearing_dist])
+                cube([cutout + 2 * base_side, base_length, base_wall + 1]);
+            }
+            
+            // shim
+            translate([-shim_width / 2, 0, base_wall])
+            cube([shim_width, base_length, mount_bearing_dist - base_wall]);
+        }
+        
+        // screw holes for mounting to carriage
+        for (x = [-hole_dist_x / 2, hole_dist_x / 2])
+        for (y = [-hole_dist_y / 2, hole_dist_y / 2])
+        translate([x, base_length / 2 + y, -1])
+        cylinder(d = hole_dia, h = base_wall + 2);
+        
+        // nut holes for mounting to carriage
+        for (x = [-hole_dist_x / 2, hole_dist_x / 2])
+        for (y = [-hole_dist_y / 2, hole_dist_y / 2])
+        translate([x, base_length / 2 + y, screw_nut_off])
+        rotate([0, 0, 90])
+        cylinder(d = screw_nut, h = base_wall - screw_nut_off + 1, $fn = 6);
+        
+        // bearing hole
+        translate([0, -1, bearing_dia / 2 + mount_bearing_dist])
+        rotate([-90, 0, 0])
+        cylinder(d = mount_hole, h = base_length + 2);
+        
+        // top cutout
+        translate([-cutout / 2, -1, bearing_dia + mount_bearing_dist - 1])
+        cube([cutout, base_length + 2, base_side + 5]);
+        
+        // top screw
+        translate([-base_width / 2, base_length / 2, mount_bearing_dist + bearing_dia + base_wall / 2])
+        rotate([0, 90, 0])
+        cylinder(d = top_screw_dia, h = base_width);
+        
+        // top screw head
+        translate([cutout / 2 + top_screw_head_off, base_length / 2, mount_bearing_dist + bearing_dia + base_wall / 2])
+        rotate([0, 90, 0])
+        cylinder(d = top_screw_head, h = base_width);
+        
+        // top screw nut
+        translate([-cutout / 2 - top_screw_nut_off - base_width, base_length / 2, mount_bearing_dist + bearing_dia + base_wall / 2])
+        rotate([0, 90, 0])
+        rotate([0, 0, 90])
+        cylinder(d = top_screw_nut, h = base_width, $fn = 6);
+    }
+}
+
+rotate([90, 0, 0])
+mount();