Added Raspberry PI accessories

dibond/bom/accessories/light_strip_assembly.txt

@@ -0,0 +1,11 @@
+light_strip_assembly:
+Vitamins:
+  2 M3 cap screw x 10mm
+  2 Nyloc nut M3
+  1 Sanken SPS125 light strip
+  2 Washer M3 x 7mm x 0.5mm
+
+Printed:
+  1 light_strip_bracket_left.stl
+  1 light_strip_bracket_right.stl
+

dibond/bom/accessories/raspberry_pi_assembly.txt

@@ -0,0 +1,10 @@
+raspberry_pi_assembly:
+Vitamins:
+  2 Nyloc nut M2.5
+  2 M2.5 pan screw x 12mm
+  1 Raspberry PI model B
+  2 Washer M2.5 x 5.9mm x 0.5mm
+
+Printed:
+  1 rpi_bracket.stl
+

dibond/bom/accessories/raspberry_pi_camera_assembly.txt

@@ -0,0 +1,19 @@
+raspberry_pi_camera_assembly:
+Vitamins:
+  2 M2 cap screw x 12mm
+  2 M3 cap screw x 10mm
+  7 M3 cap screw x 16mm
+  2 Nyloc nut M2
+  9 Nyloc nut M3
+  1 Raspberry PI camera
+  1 Sanken SPS125 light strip
+  2 Washer M2 x 5mm x 0.3mm
+  9 Washer M3 x 7mm x 0.5mm
+
+Printed:
+  1 rpi_camera_back.stl
+  1 rpi_camera_bar.stl
+  1 rpi_camera_focus_ring.stl
+  1 rpi_camera_front.stl
+  2 rpi_light_clamp.stl
+

mendel/bom/accessories/light_strip_assembly.txt

@@ -0,0 +1,11 @@
+light_strip_assembly:
+Vitamins:
+  2 M3 cap screw x 10mm
+  2 Nyloc nut M3
+  1 Sanken SPS125 light strip
+  2 Washer M3 x 7mm x 0.5mm
+
+Printed:
+  1 light_strip_bracket_left.stl
+  1 light_strip_bracket_right.stl
+

mendel/bom/accessories/raspberry_pi_assembly.txt

@@ -0,0 +1,10 @@
+raspberry_pi_assembly:
+Vitamins:
+  2 Nyloc nut M2.5
+  2 M2.5 pan screw x 12mm
+  1 Raspberry PI model B
+  2 Washer M2.5 x 5.9mm x 0.5mm
+
+Printed:
+  1 rpi_bracket.stl
+

mendel/bom/accessories/raspberry_pi_camera_assembly.txt

@@ -0,0 +1,19 @@
+raspberry_pi_camera_assembly:
+Vitamins:
+  2 M2 cap screw x 12mm
+  2 M3 cap screw x 10mm
+  7 M3 cap screw x 16mm
+  2 Nyloc nut M2
+  9 Nyloc nut M3
+  1 Raspberry PI camera
+  1 Sanken SPS125 light strip
+  2 Washer M2 x 5mm x 0.3mm
+  9 Washer M3 x 7mm x 0.5mm
+
+Printed:
+  1 rpi_camera_back.stl
+  1 rpi_camera_bar.stl
+  1 rpi_camera_focus_ring.stl
+  1 rpi_camera_front.stl
+  2 rpi_light_clamp.stl
+

scad/ATX_PSU_brackets.scad

@@ -158,6 +158,8 @@ sleeving = [
     [HSHRNK100, 1],         // 12 * 0V
 ];
 
+function sleeve_pos(i) = i > 0 ? sleeve_pos(i - 1) + tubing_od(sleeving[i][0]) /2 + 1 + tubing_od(sleeving[i - 1][0]) / 2 : 0;
+
 module atx_bracket_assembly(show_psu = false) {
     rotate([0, 0, 180]) {
         translate([0, psu_width(psu) / 2, 0]) {
@@ -183,7 +185,8 @@ module atx_bracket_assembly(show_psu = false) {
 
     for(j = [0 : len(sleeving) - 1])
         for(i = [0 : sleeving[j][1] - 1])
-            translate([psu_length(psu) / 2 + 8,  - 10 * j, psu_height(psu) / 2 + 10 * i])
+            assign(od = tubing_od(sleeving[j][0]))
+            translate([psu_length(psu) / 2 + 8,  psu_width(psu) / 2 - 15 - sleeve_pos(j), 12 + i * (od + 1) + od / 2])
                 rotate([0, 90, 0])
                     tubing(sleeving[j][0]);
 

scad/conf/config.scad

@@ -7,6 +7,9 @@
 //
 // Configuration file
 //
+
+function sqr(x) = x * x;            // shortcut
+
 bom = $bom == undef ? 0: $bom;                 // 0 no bom, 1 assemblies and stls, 2 vitamins as well
 exploded = $exploded == undef ? 0 : $exploded; // 1 for exploded view
 
@@ -35,6 +38,10 @@ No2_clearance_radius = 2.5 / 2;
 No4_clearance_radius = 3.5 / 2;
 No6_clearance_radius = 4.0 / 2;
 
+M2_tap_radius = 1.6 / 2;
+M2_clearance_radius = 2.4 / 2;
+M2_nut_trap_depth = 2.5;
+
 M2p5_tap_radius = 2.05 / 2;
 M2p5_clearance_radius= 2.8 / 2;   // M2.5
 M2p5_nut_trap_depth = 2.5;
@@ -100,7 +107,11 @@ base_nuts = false;                  // Need something under the base if using nu
 pulley_type = T5x8_plastic_pulley;
 clip_handles = true;
 include_fan = false;
+squeeze = false;                    // Bodge to make Huxley as small as possible without affecting dibond kits
 part_fan = fan60x15;
+raspberry_pi = false;               // Raspberry pi mounted on PSU
+raspberry_pi_camera = false;        // RPI camera on bar across the back
+light_strip = false;
 include <machine.scad>              // this file is generated from the command line parameter to include one of the machine configs
 
 screw_clearance_radius = screw_clearance_radius(cap_screw);

scad/conf/dibond_config.scad

@@ -49,6 +49,9 @@ single_piece_frame = true;
 stays_from_window = false;
 cnc_sheets = true;                 // If sheets are cut by CNC we can use slots, etc instead of just round holes
 pulley_type = T2p5x16_metal_pulley;
+//raspberry_pi = true;
+//raspberry_pi_camera = true;
+//light_strip = SPS125;
 
 Y_carriage = DiBond;
 

scad/conf/utils.scad

@@ -22,14 +22,14 @@ module slot(h, r, l, center = true)
                 circle(r = r, center = true);
         }
 
-module hole_support(r, h, max_r = 999) {
+module hole_support(r, h, max_r = 999, closed = false) {
     n = sides(r);
     cr = corrected_radius(r, n);
     ir = min(cr, max_r - 2.25 * filament_width);
     or = ir + 2 * filament_width;
     difference() {
         cylinder(r = or, h = h, $fn = n);
-        translate([0, 0, -1])
+        translate([0, 0, closed ? layer_height : -1])
             cylinder(r = ir, h = h + 2, $fn = n);
     }
 }
@@ -46,6 +46,9 @@ module nut_trap_support(h, r, r2 = 0) {
     }
 }
 
+function nut_trap_radius(nut) = nut_radius(nut) + layer_height / 4;
+function nut_trap_flat_radius(nut) = nut_trap_radius(nut) * cos(30);
+
 module nut_trap(screw_r, nut_r, depth, horizontal = false, supported = false) {
     render(convexity = 5) union() {
         if(horizontal) {
@@ -153,11 +156,11 @@ module tube(or, ir, h, center = true) {
 //
 module explode(v, offset = [0,0,0]) {
     if(exploded) {
-        translate(v)
+        translate(v * exploded)
             child();
         render() hull() {
             sphere(0.2);
-            translate(v + offset)
+            translate(v * exploded + offset)
                 sphere(0.2);
         }
     }

scad/conf/vitamins.scad

@@ -32,6 +32,7 @@ include <../vitamins/components.scad>
 include <../vitamins/hot_ends.scad>
 include <../vitamins/bars.scad>
 include <../vitamins/pullies.scad>
+include <../vitamins/light_strips.scad>
 
 module rod(d , l) {
     vitamin(str("RD", d, round(l), ": Smooth rod ", d, "mm x ", round(l), "mm"));

scad/frame_edge_clamp.scad

@@ -0,0 +1,125 @@
+//
+// Mendel90
+//
+// GNU GPL v2
+// nop.head@gmail.com
+// hydraraptor.blogspot.com
+//
+// A clamp for gripping the frame edge
+//
+include <conf/config.scad>
+
+wall = 2;
+width  = 8;
+hinge = 5;
+rim = 1.2;
+function frame_edge_clamp_pitch(length) = length - 2 * nut_flat_radius(M3_nut) - 2 * wall;
+
+clamp_back_thickness = 2;
+clamp_thickness = 2 + M3_nut_trap_depth;
+clearance = 0.2;
+
+screw_d = 3;
+
+total_width = width + screw_d / 2 + corrected_radius(screw_d / 2) + hinge;
+function pivot_l(length) = length - 2 * (min_wall + clearance);
+pivot_w = hinge - 2 * (min_wall + clearance);
+pivot_h = 1.2;
+
+function frame_edge_clamp_width() = total_width;
+function frame_edge_clamp_thickness() = clamp_thickness;
+
+
+module frame_edge_clamp_front_stl(length = 20) {
+
+    w = total_width;
+
+    union() {
+        difference() {
+            translate([0, 0, clamp_thickness / 2])
+                cube([length, w, clamp_thickness], center = true);
+
+            for(side = [-1, 1])
+                translate([side * frame_edge_clamp_pitch(length) / 2, w / 2 - width - screw_d / 2, clamp_thickness])
+                    rotate([0, 0, 90])
+                        nut_trap(M3_clearance_radius, nut_radius(M3_nut), M3_nut_trap_depth);
+
+            translate([0, - w / 2 + hinge / 2, 0])
+                cube([pivot_l(length) + 2 * clearance, pivot_w + 2 * clearance, pivot_h * 2], center = true);
+        }
+        if($children)
+            child();
+    }
+}
+
+module frame_edge_clamp_back_stl(length = 20, gap = sheet_thickness(frame)) {
+    l = length;
+    w = total_width;
+
+    union() {
+        difference() {
+            translate([-l / 2, -w / 2, 0])
+                cube([l, w, clamp_back_thickness + gap - layer_height]);
+
+            translate([-l / 2 + wall, -w / 2 + hinge, clamp_back_thickness])
+                cube([l - 2 * wall, w, clamp_back_thickness + gap - layer_height]);
+
+            translate([-l, w / 2 - width, clamp_back_thickness])
+                cube([2 * l, w, clamp_back_thickness + gap - layer_height]);
+
+            for(side = [-1, 1])
+                translate([side * frame_edge_clamp_pitch(l) / 2, w / 2 - width - screw_d / 2, clamp_thickness])
+                    rotate([0, 0, 90])
+                        poly_cylinder(M3_clearance_radius, h = 100, center = true);
+        }
+
+        translate([0, - w / 2 + hinge / 2, clamp_back_thickness + gap])
+            cube([pivot_l(l), pivot_w, pivot_h * 2], center = true);
+    }
+}
+
+
+module frame_edge_clamp_assembly(length = 20, gap = sheet_thickness(frame), left = true) {
+    kids = $children;
+
+    screw_length = screw_longer_than(washer_thickness(M3_washer)
+                                   + clamp_back_thickness
+                                   + gap
+                                   + clamp_thickness
+                                   - M3_nut_trap_depth
+                                   + nut_thickness(M3_nut, true));
+
+    color(left ? "lime" : "red") render() {
+        frame_edge_clamp_front_stl(length = length)
+            if(kids)
+                child();
+    }
+
+    translate([0, 0, -gap - clamp_back_thickness])
+        color(left ? "red" : "lime") render() frame_edge_clamp_back_stl(length, gap);
+
+    for(side = [-1, 1])
+        translate([side * frame_edge_clamp_pitch(length) / 2, total_width / 2 - width - screw_d / 2, -gap - clamp_back_thickness])
+            rotate([0, 0, 90]) {
+                rotate([180, 0, 0])
+                    screw_and_washer(M3_cap_screw, max(screw_length, 16));
+
+                translate([0, 0, clamp_thickness + gap + clamp_back_thickness - M3_nut_trap_depth])
+                    nut(M3_nut, true);
+            }
+
+
+}
+
+module frame_edge_clamp_stl() {
+    frame_edge_clamp_front_stl();
+
+    translate([0, total_width + 2, 0])
+        frame_edge_clamp_back_stl();
+
+}
+
+if(1)
+    frame_edge_clamp_assembly();
+else
+    frame_edge_clamp_stl();

scad/light_strip.scad

@@ -0,0 +1,152 @@
+//
+// Mendel90
+//
+// GNU GPL v2
+// nop.head@gmail.com
+// hydraraptor.blogspot.com
+//
+// Bracket to mount RPI
+//
+include <conf/config.scad>
+use <spool_holder.scad>
+use <fixing-block.scad>
+include <positions.scad>
+
+light = light_strip ? light_strip : SPS125;
+
+x = (left_stay_x + right_stay_x) / 2;
+y = gantry_Y + sheet_thickness(frame) + spool_holder_gap();
+z = height - gantry_thickness + light_strip_set_back(light);
+
+angle = atan2(Y0 - y, z - bed_height);
+
+clearance = 0.5;
+boss_r = nut_radius(M3_nut) + 2;
+nut_trap_meat = 2;
+
+bracket_thickness = 3;
+bracket_width = spool_holder_gap() - clearance;
+bracket_length = (right_stay_x - left_stay_x - sheet_thickness(frame) - light_strip_hole_pitch(light)) / 2 + boss_r;
+bracket_height = height - z - light_strip_thickness(light);
+bracket_stem = bracket_width - fixing_block_height();
+
+stem_thickness = 3;
+
+hook = 8;
+hook_overlap = 3;
+hook_r = 3;
+
+wire_hole_r = 3.5 / 2;
+
+module light_strip_bracket() {
+    hook_w = stem_thickness + sheet_thickness(frame) + hook;
+    hook_h = hook + hook_overlap;
+    slot = sheet_thickness(frame) + 0.2;
+
+    difference() {
+        union() {
+            multmatrix([[1,0,0,0],
+                        [0,1,-tan(angle),0],
+                        [0,0,1,0],
+                        [0,0,0,1]])
+               union() {
+                    cube([bracket_length, bracket_thickness, bracket_width]);
+
+                    translate([0, bracket_thickness, bracket_stem])
+                        rotate([90, 0, 90])
+                            right_triangle(width = bracket_width, height = bracket_width - bracket_stem, h = stem_thickness, center = false);
+               }
+
+            cube([stem_thickness, bracket_height, bracket_stem]);
+
+            translate([stem_thickness, bracket_thickness, 0])
+                right_triangle(width = bracket_length - bracket_thickness, height = bracket_width, h = bracket_thickness, center = false);
+
+            translate([-sheet_thickness(frame) - hook + hook_w / 2, bracket_height - hook_overlap + hook_h / 2, 0])
+                rounded_rectangle([hook_w, hook_h, bracket_stem], center = false, r = hook_r);
+
+            hull() {
+                rotate([angle, 0, 0])
+                    translate([bracket_length - boss_r, 0, light_strip_width(light) / 2])
+                        rotate([-90, 0, 0])
+                            cylinder(r = boss_r - eta, h = nut_trap_meat + nut_thickness(M3_nut, true));
+                    translate([bracket_length - 2 * boss_r, bracket_thickness, 0])
+                        cube([2 * (boss_r - eta), nut_trap_meat + nut_thickness(M3_nut, true) - bracket_thickness, 1]);
+            }
+        }
+        translate([-slot, bracket_height - bracket_thickness - hook_overlap, -1])
+            cube([slot, bracket_thickness + hook_overlap, bracket_stem + 2]);
+
+        rotate([angle, 0, 0]) {
+            translate([0, -5, 0])
+                cube([100, 10, 100], center = true);
+
+            translate([bracket_length - boss_r, nut_trap_meat + M3_nut_trap_depth, light_strip_width(light) / 2])
+                rotate([90, 0, 0])
+                    nut_trap(M3_clearance_radius, M3_nut_radius, M3_nut_trap_depth, horizontal = true);
+
+            translate([stem_thickness + wire_hole_r + layer_height, nut_trap_meat + M3_nut_trap_depth, light_strip_width(light) / 2])
+                rotate([90, 0, 0])
+                    teardrop_plus(r = wire_hole_r, h = 100);
+        }
+    }
+}
+
+module light_strip_bracket_left_stl() {
+    stl("light_strip_bracket_left");
+    light_strip_bracket();
+}
+
+module light_strip_bracket_right_stl() {
+    stl("light_strip_bracket_right");
+    mirror([1,0,0]) light_strip_bracket();
+}
+
+module light_strip_brackets_stl() {
+    light_strip_bracket_left_stl();
+    translate([-2 - 2 * (hook + sheet_thickness(frame)), 0, 0])
+        light_strip_bracket_right_stl();
+}
+
+module light_strip_assembly() {
+    assembly("light_strip_assembly");
+    translate([x, y, z + light_strip_thickness(light)])
+        rotate([angle, 0, 0])
+            translate([0, -light_strip_width(light) / 2, - light_strip_thickness(light)])
+                light_strip(light);
+
+    translate([left_stay_x + sheet_thickness(frame) / 2, y, z + light_strip_thickness(light)])
+        rotate([90, 0, 0])
+            color("lime") render() light_strip_bracket_left_stl();
+
+    translate([right_stay_x - sheet_thickness(frame) / 2, y, z + light_strip_thickness(light)])
+        rotate([90, 0, 0])
+            color("red") render() light_strip_bracket_right_stl();
+
+    for(side = [-1,1])
+        translate([x + side * light_strip_hole_pitch(light) / 2, y, z + light_strip_thickness(light)])
+            rotate([angle - 180, 0, 0])
+                translate([0,  light_strip_width(light) / 2, light_strip_thickness(light)]) {
+                    screw_and_washer(M3_cap_screw, 10);
+                    translate([0, 0, -nut_trap_meat - light_strip_thickness(light)])
+                        rotate([180, 0, 0])
+                            nut(M3_nut, true);
+                }
+
+    *hull() {                           // light ray, should point at center of Y axis.
+        translate([x, y -light_strip_width(light) / 2, z])
+            sphere();
+        translate([x, Y0, bed_height])
+            sphere();
+    }
+    end("light_strip_assembly");
+}
+
+
+if(1)
+    light_strip_assembly();
+else
+    if(1)
+        light_strip_bracket();
+    else
+        light_strip_brackets_stl();

scad/main.scad

@@ -26,8 +26,12 @@ use <ATX_PSU_brackets.scad>
 use <spool_holder.scad>
 use <tube_cap.scad>
 use <d-motor_bracket.scad>
+use <raspberry_pi.scad>
+use <raspberry_pi_camera.scad>
+use <light_strip.scad>
 include <positions.scad>
 
+
 X = 0 * X_travel / 2; // - limit_switch_offset;
 Y = 0 * Y_travel / 2; // - limit_switch_offset;
 Z = 0.5 * Z_travel;
@@ -363,14 +367,6 @@ module print_bed_assembly(show_bed = true, show_heatshield = true) {
     //
     translate([X_origin, Y + Y0, 0]) {
 
-        translate([0, 0, Y_carriage_height + sheet_thickness(Y_carriage) / 2]) {
-            if(show_bed) {
-                bed_assembly(Y);
-                if(show_heatshield)
-                    translate([0, 0, sheet_thickness(Cardboard) / 2])
-                        y_heatshield();
-            }
-        }
 
         translate([0, -(Y + Y0) + ribbon_clamp_y + ribbon_clamp_width(base_screw) / 2, ribbon_clamp_slot_depth() - cable_strip_thickness])
             rotate([90, 0, 90])
@@ -383,6 +379,14 @@ module print_bed_assembly(show_bed = true, show_heatshield = true) {
 
         y_carriage_assembly(show_bed);
 
+        translate([0, 0, Y_carriage_height + sheet_thickness(Y_carriage) / 2]) {
+            if(show_bed) {
+                if(show_heatshield)
+                    translate([0, 0, sheet_thickness(Cardboard) / 2])
+                        y_heatshield();
+                bed_assembly(Y);
+            }
+        }
     }
     end("print_bed_assembly");
 }
@@ -787,9 +791,9 @@ module electronics_assembly() {
     translate([right_stay_x + sheet_thickness(frame) / 2, controller_y, controller_z])
         rotate([90, 0, 90]) {
             controller_screw_positions(controller)
-                pcb_spacer_assembly();
+                pcb_spacer_assembly(raspberry_pi ? 2 : 1, raspberry_pi ? $i >= 2 : true);
 
-            translate([0, 0, pcb_spacer_height()])
+            translate([0, 0, pcb_spacer_height() * (raspberry_pi ? 2 : 1)])
                 controller(controller);
         }
 
@@ -804,7 +808,7 @@ module psu_assembly() {
 
     assembly("psu_assembly");
 
-    translate([right_stay_x + sheet_thickness(frame) / 2, psu_y, psu_z])
+    translate([psu_x, psu_y, psu_z])
         rotate([0, 90, 0]) {
             psu_screw_positions(psu) group() {
                 if(psu_screw_from_back(psu))
@@ -882,8 +886,17 @@ module machine_assembly(show_bed = true, show_heatshield = true, show_spool = tr
         electronics_assembly();
         psu_assembly();
 
-        if(show_spool)
+        if(raspberry_pi)
+            raspberry_pi_assembly();
+
+        if(raspberry_pi_camera)
+            raspberry_pi_camera_assembly(light_strip);
+
+        if(show_spool) {
             spool_assembly(left_stay_x, right_stay_x);
+            if(light_strip && !raspberry_pi_camera)
+                light_strip_assembly();
+        }
 
         translate([0, Y0, 0]) {
             x_axis_assembly(true);

scad/pcb_spacer.scad

@@ -11,22 +11,28 @@ function pcb_spacer_height() = part_base_thickness - pcb_thickness;
 
 pcb_screw_length = frame_screw_length;
 
-
 module pcb_spacer_stl(screw = M3_cap_screw, h = pcb_spacer_height()) {
     stl("pcb_spacer");
 
     r = screw_clearance_radius(screw);
 
     difference() {
-        cylinder(r = corrected_diameter(r * 2) / 2 + 2, h = h,  center = false);
+        cylinder(r = corrected_radius(r) + 2, h = h,  center = false);
         translate([0, 0, -0.5])
             poly_cylinder(r = r, h = h + 1, center = false);
     }
 }
 
-module pcb_spacer_assembly() {
+module pcb_spacer_assembly(spacers, spacer) {
+    if(spacers && spacer)
         color(pcb_spacer_color) render() pcb_spacer_stl();
-    translate([0,0, pcb_spacer_height() + pcb_thickness])
+
+    if(spacers > 1  && spacer)
+        color("red")
+            translate([0, 0, pcb_spacer_height()])
+                render() pcb_spacer_stl();
+
+    translate([0, 0, spacers * pcb_spacer_height() + pcb_thickness])
         screw_and_washer(M3_cap_screw, pcb_screw_length, !frame_nuts);
 
     if(frame_nuts)

scad/positions.scad

@@ -14,7 +14,7 @@ use <fixing-block.scad>
 use <mains_inlet.scad>
 use <ribbon_clamp.scad>
 
-base_depth = Y_travel + limit_switch_offset + Y_carriage_depth + 2 * base_clearance;
+base_depth = ceil(Y_travel + limit_switch_offset + Y_carriage_depth + 2 * base_clearance);
 AL_tube_inset = 9.5;
 
 Y0 = limit_switch_offset / 2;
@@ -25,7 +25,7 @@ bed_height =  Y_carriage_height + sheet_thickness(Y_carriage) / 2 + pillar_heigh
 
 Z0 = floor(bed_height + nozzle_length - x_carriage_offset());
 
-height = Z0 + Z_travel + limit_switch_offset + x_end_height() + bar_clamp_depth + axis_end_clearance + base_clearance;
+height = ceil(Z0 + Z_travel + limit_switch_offset + x_end_height() + bar_clamp_depth + axis_end_clearance + base_clearance);
 
 gantry_thickness = height - max(bed_height + Z_travel + Z_clearance, Y_carriage_depth + 1);
 
@@ -77,6 +77,7 @@ fan_z = Y_carriage_height + fan_width(case_fan) / 2;
 atx_bracket_width = (frame_nuts && cnc_sheets) ? 2 * (nut_radius(frame_nut) + 3 * filament_width)
                                                : washer_diameter(frame_washer) + 1;
 
+psu_x = right_stay_x + sheet_thickness(frame) / 2;
 psu_z = fixing_block_height() + psu_length(psu) / 2;
 psu_y = base_depth / 2 - base_clearance - psu_width(psu) / 2 - (atx_psu(psu) ? atx_bracket_width : mains_inlet_inset());
 

scad/raspberry_pi.scad

@@ -0,0 +1,145 @@
+//
+// Mendel90
+//
+// GNU GPL v2
+// nop.head@gmail.com
+// hydraraptor.blogspot.com
+//
+// Bracket to mount RPI
+//
+include <conf/config.scad>
+use <pcb_spacer.scad>
+include <positions.scad>
+
+pi_width = 56;
+pi_length = 85;
+pi_clearance = 0.25;
+pi_thickness = 1.6;
+
+overlap = 1.5;
+
+pi_base_width  = pi_width + 2 * pi_clearance + 2 * min_wall;
+pi_base_length = pi_length+ 2 * pi_clearance + 2 * min_wall;
+rim_width = overlap + pi_clearance + min_wall;
+
+module pi_holes()
+    for(hole = [[25.5, 18], [pi_length-5, pi_width-12.5]])
+        translate([pi_width / 2 - hole[1], hole[0] - pi_length / 2, 0])
+            child();
+
+
+pi_lift = 10;      // space underneath for 12mm screw
+
+standoffs = 4;
+pi_base = 2;
+nut_depth = nut_thickness(M2p5_nut, true) + 0.5;
+rim_height = pi_lift + pi_thickness;
+margin = 2;
+x_offset = psu_height(psu) - raspberry_pi_width() / 2 - margin;
+
+function raspberry_pi_width() = pi_width;
+
+back_height = controller_z - (psu_z + psu_length(psu) / 2);
+screw_z = back_height + controller_hole_inset(controller);
+screw_pitch = controller_width(controller) - 2 * controller_hole_inset(controller);
+slot_length = 2;
+
+wall = 2.5;
+
+card_width = 30.3;
+card_thickness = 4;
+card_offset = 11.5;
+
+back_width = screw_pitch + 2 * (M3_clearance_radius + wall);
+
+module raspberry_pi() {
+    vitamin("RASPBERY: Raspberry PI model B");
+    color("green")
+        rotate([0, 0, 90])
+            translate([-pi_length / 2, - pi_width / 2, 0])
+                import("../imported_stls/R-Pi.stl");
+}
+
+module rpi_bracket_stl() {
+    stl("rpi_bracket");
+
+    difference() {
+        union() {
+            difference() {
+                hull() {
+                    translate([0, 0, rim_height / 2])
+                        rounded_rectangle([pi_base_width, pi_base_length, rim_height], center = true, r = 2);
+
+                    translate([0, 0, pi_lift + pi_thickness / 2])
+                        cube([pi_base_width, pi_base_length, pi_thickness], center = true);
+                }
+
+                translate([0, 0, rim_height / 2 + pi_base])
+                    cube([pi_base_width - 2 * rim_width, pi_base_length - 2 * rim_width, rim_height], center = true);
+
+                translate([0, 0, rim_height])
+                    cube([pi_width + 2 * pi_clearance, pi_length + 2 * pi_clearance, pi_thickness * 2], center = true);
+
+                translate([-pi_width / 2 + card_offset + card_width / 2, -pi_length / 2, pi_lift])
+                    cube([card_width + 2, rim_width * 2 + 1, card_thickness * 2], center = true);
+            }
+
+            translate([-x_offset, controller_y - psu_y + controller_width(controller) / 2 - back_width / 2, 0]) {
+                cube([x_offset - pi_width / 2 + eta, back_width, 4]);
+                cube([pcb_spacer_height(), back_width, back_height]);
+
+                for(side = [-1, 1])
+                    translate([0, side * screw_pitch / 2 + back_width / 2, screw_z + slot_length / 2])
+                        hull() {
+                            rotate([0, 90, 0])
+                                cylinder(r = M3_clearance_radius + wall, h = 2 * pcb_spacer_height());
+
+                            translate([0, -(M3_clearance_radius + wall), -screw_z])
+                                cube([2 * pcb_spacer_height(), 2 * (M3_clearance_radius + wall), 1]);
+                        }
+            }
+
+            pi_holes() union() {
+                cylinder(r = corrected_radius(M2p5_clearance_radius) + 2, h = pi_lift);
+                cylinder(r = nut_radius(M2p5_nut) + 2, h = nut_depth + layer_height);
+            }
+        }
+        pi_holes()
+            nut_trap(M2p5_clearance_radius, nut_radius(M2p5_nut), nut_depth, supported = true);
+
+        for(side = [-1, 1])
+            translate([-x_offset, controller_y - psu_y + controller_width(controller) / 2 + side * screw_pitch / 2, screw_z])
+                rotate([90, 0, 90])
+                    vertical_tearslot(h = 4 * pcb_spacer_height() + 1, r = M3_clearance_radius, l = slot_length);
+
+    }
+}
+
+module raspberry_pi_assembly() {
+    assembly("raspberry_pi_assembly");
+
+    translate([psu_x + x_offset, psu_y, psu_z + psu_length(psu) /2]) {
+        color("lime") render() rpi_bracket_stl();
+
+        explode([80, 0, 0])
+            translate([0, 0, pi_lift])
+                raspberry_pi();
+
+        pi_holes()
+            explode([0, 0, -20])
+                translate([0, 0, nut_depth])
+                    rotate([180, 0, 0])
+                        nut(M2p5_nut, true);
+        pi_holes()
+            explode([0, 0, 30])
+                translate([0, 0, pi_lift + pi_thickness])
+                    screw_and_washer(M2p5_pan_screw, 12);
+    }
+
+    end("raspberry_pi_assembly");
+}
+
+if(1)
+    raspberry_pi_assembly();
+else
+    rpi_bracket_stl();

scad/raspberry_pi_camera.scad

@@ -0,0 +1,509 @@
+//
+// Mendel90
+//
+// GNU GPL v2
+// nop.head@gmail.com
+// hydraraptor.blogspot.com
+//
+// Bracket to mount RPI camera
+//
+include <conf/config.scad>
+include <positions.scad>
+use <frame_edge_clamp.scad>
+
+light = light_strip ? light_strip : SPS125;
+
+show_rays = false;
+
+wall = 2;
+clearance = 0.2;
+
+pi_cam_width = 24;
+pi_cam_length = 25;
+pi_cam_thickness = 1;
+pi_cam_hole_pitch = pi_cam_length - 4;
+
+pi_cam_hole_r = 2.1 / 2;
+pi_cam_turret = 8;
+pi_cam_connector_length = 23;
+pi_cam_connector_depth = 6;
+pi_cam_connector_height = 2.65;
+
+pi_cam_led_pos = [pi_cam_length / 2 - 4.5, pi_cam_width / 2 - 5, pi_cam_thickness];
+pi_cam_led_clearance = [3, 2, 0.8 * 2];
+
+pi_cam_res_pos = [pi_cam_length / 2 - 5.5, pi_cam_width / 2 - 3, pi_cam_thickness];
+pi_cam_res_clearance = [3.5, 2, 0.8 * 2];
+
+pi_cam_back_clearance = 1.6;
+pi_cam_back_overlap = 1;
+
+pi_cam_back_wall = min_wall;
+pi_cam_back_depth = max(pi_cam_connector_height + wall, pi_cam_back_clearance + wall + M2_nut_trap_depth);
+pi_cam_back_length = pi_cam_hole_pitch + 2 * (nut_flat_radius(M2_nut) + min_wall);
+pi_cam_back_width = pi_cam_width + (pi_cam_back_length - pi_cam_length) / 2;
+pi_cam_centreline = -pi_cam_width / 2 + 9.5;
+
+function round_to_layer(z) = ceil(z / layer_height) * layer_height;
+
+pi_cam_front_clearance = 1.6;
+pi_cam_front_wall = 2;
+pi_cam_front_depth = pi_cam_back_depth + pi_cam_thickness + pi_cam_front_clearance + wall;
+pi_cam_front_length = pi_cam_back_length + 2 * (pi_cam_front_wall + clearance);
+pi_cam_front_width = pi_cam_back_width + 2 * (pi_cam_front_wall + clearance);
+
+bar_dia = 12;
+bar_gap = 2;
+bar_wall = 3;
+
+X_build = min(X_travel, bed_holes[0] - screw_head_radius(M3_cap_screw) * 2); // sturdy travel exceeds the bed so max object is smaller
+Y_build = min(Y_travel, bed_holes[1] - screw_head_radius(M3_cap_screw) * 2);
+
+y_limit = Y0 + (Y_travel + Y_build) / 2 + 1;
+bar_z = 240;
+bar_y = y_limit + bar_dia / 2 + wall + 2;
+
+cam_offset = pi_cam_front_width / 2 - pi_cam_width / 2 + pi_cam_back_width / 2 - pi_cam_centreline + bar_dia / 2;
+cam_x = X_origin;
+cam_y = bar_y - bar_dia / 2 - pi_cam_front_wall;
+cam_z = bar_z - cam_offset;
+
+hypot = sqrt(sqr(bar_z - bed_height) + sqr(bar_y - Y0));
+angle = atan2(bar_z - bed_height, bar_y - Y0) - asin(cam_offset / hypot);
+
+left = left_stay_x + sheet_thickness(frame) / 2;
+right = right_stay_x - sheet_thickness(frame) / 2;
+
+bar_length = right - left - 2;
+bar_overlap = 2 * (cam_x -(right + left) / 2);
+clamp_length = bar_dia - frame_edge_clamp_pitch(0) + 2 * nut_flat_radius(M3_nut) + clearance * 2;
+
+band_width = 2 * (nut_trap_radius(M3_nut) + wall);
+band_tab_h = 2 * (nut_trap_flat_radius(M3_nut) + wall);
+band_ir = bar_dia / 2;
+band_or = band_ir + pi_cam_front_wall;
+band_y = pi_cam_front_width / 2 - pi_cam_width / 2 + pi_cam_back_width / 2 - pi_cam_front_wall + band_or + eta;
+
+band_tab_t = M3_nut_trap_depth + wall;
+band_slit = 1;
+band_tab_d = max(2 * band_tab_t + band_slit, 16 - washer_thickness(M3_washer) - nut_thickness(M3_nut, true) + M3_nut_trap_depth - 0.5);
+band_tab_height = band_tab_h + sqrt(sqr(band_or) - sqr(band_tab_d / 2));
+
+light_x = (left + right) / 2;
+light_z = bar_z + bar_dia / 2 + light_strip_width(light) / 2 + pi_cam_front_wall + clearance;
+bar_z_offset = light_z - bar_z;
+
+light_angle = atan2(bar_z - bed_height, bar_y - Y0) + asin(bar_z_offset / hypot);
+
+light_incursion = max(0, y_limit + sin(light_angle) * (bar_z_offset + light_strip_width(light) / 2) - bar_y);
+
+bar_y_offset = (light_strip_thickness(light) + light_incursion) / cos(light_angle);
+light_y = bar_y + bar_y_offset;
+
+light_band_tab_h = 2 * (nut_trap_radius(M3_nut) + wall);
+light_band_tab_height = light_band_tab_h + sqrt(sqr(band_or) - sqr(band_tab_d / 2));
+
+module pi_cam_holes(mid_only = false) {
+    ypos = [pi_cam_centreline, pi_cam_width / 2 - 2];
+    for(y = mid_only ? [ ypos[0] ] : ypos)
+        for(x = [-pi_cam_length / 2 + 2, pi_cam_length / 2 - 2])
+            translate([x, y, 0])
+                 child();
+}
+
+module raspberry_pi_camera() {
+    vitamin("RPICAM: Raspberry PI camera");
+    color("green") render() difference() {
+        translate([0, 0, pi_cam_thickness / 2])
+            cube([pi_cam_length, pi_cam_width, pi_cam_thickness], center = true);
+
+        pi_cam_holes()
+            cylinder(r = pi_cam_hole_r, h = 100);
+    }
+
+    color("DarkSlateGray") render() union() {
+        translate([0, -pi_cam_width / 2 + 9.5, 1.5 + pi_cam_thickness ])
+            cube([pi_cam_turret, pi_cam_turret, 3], center = true);
+
+        translate([0, pi_cam_centreline, pi_cam_thickness])
+            cylinder(r = 7.5 / 2, h = 4);
+
+        translate([0, pi_cam_centreline, pi_cam_thickness])
+            cylinder(r = 5.5 / 2, h = 5);
+    }
+
+    color("Khaki")
+        render() translate([- pi_cam_connector_length / 2, -pi_cam_width / 2, - pi_cam_connector_height])
+            cube([pi_cam_connector_length, pi_cam_connector_depth, pi_cam_connector_height]);
+
+    color("red")
+        render() translate(pi_cam_led_pos) cube(center = true);
+}
+
+module rpi_camera_focus_ring_stl() {
+    rad = 15 / 2;
+    hole_r1 = 2.5 / 2;
+    hole_r2 = 5 / 2;
+    thickness = 3;
+    flutes = 8;
+    angle = 180 / flutes;
+    x = rad / (sin(angle / 2) + cos(angle / 2));
+    r = x * sin(angle / 2);
+
+    stl("rpi_camera_focus_ring");
+
+    difference() {
+        linear_extrude(height = thickness, convexity = 5)
+            difference() {
+                union() {
+                    circle(x);
+                    for(i = [0 : flutes - 1])
+                        rotate([0, 0, 2 * angle * i])
+                            translate([x, 0])
+                                circle(r);
+                }
+                for(i = [0 : flutes - 1])
+                    rotate([0, 0, 2 * angle * i + angle])
+                        translate([x, 0])
+                            circle(r);
+            }
+        hull() {
+            poly_cylinder(r = hole_r1, h = 0.1, center = true);
+
+            translate([0, 0, thickness])
+                poly_cylinder(r = hole_r2, h = 0.1, center = true);
+        }
+    }
+}
+
+module rpi_camera_back_stl() {
+    lug_width = 6.4;
+    lug_rad = 8;
+    lug_height = 20;
+    lug_hole_r = 6.4 / 2;
+
+    stl("rpi_camera_back");
+    translate([0, 0, pi_cam_back_depth]) rotate([0, 180, 0]) difference() {
+        union() {
+            translate([0, -pi_cam_width / 2 + pi_cam_back_width / 2, pi_cam_back_depth / 2])
+                cube([pi_cam_back_length, pi_cam_back_width, pi_cam_back_depth], center = true);
+
+            *translate([0, pi_cam_centreline, pi_cam_back_depth + lug_height - lug_rad])
+                rotate([0, 90, 90])
+                    cylinder(r = lug_rad, h = lug_width, center = true);
+
+            *translate([ - lug_rad, pi_cam_centreline - lug_width / 2, 0])
+                cube([lug_rad * 2, lug_width, lug_height - lug_rad + pi_cam_back_depth]);
+        }
+
+        translate([0, -pi_cam_back_overlap, 0])
+            cube([pi_cam_length - 2 * pi_cam_back_overlap, pi_cam_width, 2 * pi_cam_back_clearance], center = true);
+
+        translate([0, -pi_cam_width / 2, 0])
+            cube([pi_cam_connector_length + 2 * clearance, 2 * pi_cam_connector_depth + 1, 2 * round_to_layer(pi_cam_connector_height + clearance)], center = true);
+
+        pi_cam_holes(mid_only = true) group() {
+            translate([0, 0, pi_cam_back_depth])
+                rotate([180, 0, 90])
+                    nut_trap(M2_clearance_radius, nut_radius(M2_nut), M2_nut_trap_depth, supported = true);
+
+            *translate([0, 0, pi_cam_back_clearance + layer_height])
+                rotate([0, 0, 90])
+                    poly_cylinder(r = M2_clearance_radius, h = 100);
+        }
+
+        *translate([0, pi_cam_centreline, pi_cam_back_depth + lug_height - lug_rad])
+            rotate([90, 0, 0])
+                teardrop_plus(r = lug_hole_r, h = lug_width + 1, center = true);
+    }
+}
+
+module rpi_camera_front_stl() {
+    stl("rpi_camera_front");
+
+    shelf = pi_cam_front_depth - pi_cam_back_depth;
+    connector_slot = pi_cam_connector_height + 2 * layer_height;
+    rad = pi_cam_front_wall;
+    led_hole_r = 1.25;
+
+
+    sensor_length = pi_cam_width / 2 - pi_cam_back_overlap - pi_cam_centreline;
+
+    difference() {
+        union() {
+            hull()
+                for(x = [-1, 1], y = [-1, 1])
+                    translate([x * (pi_cam_front_length / 2 - rad), y * (pi_cam_front_width / 2 - rad) - pi_cam_width / 2 + pi_cam_back_width / 2, 0])
+                        hull() {    // 3D truncated teardrop gives radiused edges without exceeding 45 degree overhang
+                            translate([0, 0, pi_cam_front_depth - 1])
+                                cylinder(r = rad, h = 1 + 2 * layer_height);
+
+                            translate([0, 0, rad])
+                                sphere(rad);
+
+                            cylinder(r = rad * (sqrt(2) - 1), h = eta);
+                        }
+            //
+            // bar clamp
+            //
+            translate([0, band_y, band_or])
+                rotate([-90, 0, 90])
+                    teardrop(r = band_or, h = band_width, center = true);                           // clamp band to go round bar
+
+            translate([0, band_y, band_or + band_tab_height / 2])
+                cube([band_width, band_tab_d, band_tab_height], center = true);                     // tab for screw
+        }
+        translate([0, band_y, band_or])
+            rotate([90, 0, 90])
+                teardrop(r = band_ir, h = band_width + 1, center = true);
+
+        translate([0, -pi_cam_width / 2 + pi_cam_back_width / 2, pi_cam_front_depth / 2 + shelf - layer_height])   // recess for the back
+            cube([pi_cam_back_length + 2 * clearance, pi_cam_back_width + 2 * clearance, pi_cam_front_depth], center = true);
+
+        translate([0, 0, pi_cam_front_depth / 2 + shelf - pi_cam_thickness])                        // recess for PCB
+            cube([pi_cam_length + 2 * clearance, pi_cam_width + 2 * clearance, pi_cam_front_depth], center = true);
+
+        rotate([0, 180, 0]) translate(pi_cam_led_pos - [0, 0, shelf])                               // clearance for LED
+            cube(pi_cam_led_clearance, center = true);
+
+        rotate([0, 180, 0]) translate(pi_cam_res_pos - [0, 0, shelf])                               // clearance for resistor
+            cube(pi_cam_res_clearance, center = true);
+
+        translate([0, pi_cam_centreline + sensor_length / 2, shelf - pi_cam_thickness])             // clearance for sensor connector
+            cube([pi_cam_turret + 2 * clearance, sensor_length, 2 * pi_cam_front_clearance], center = true);
+
+        translate([0, -pi_cam_width / 2, shelf + connector_slot / 2 - layer_height])                // slot for connector
+            cube([pi_cam_connector_length + 2 * clearance, pi_cam_connector_depth * 2, connector_slot], center = true);
+
+        pi_cam_holes(mid_only = true)                                                               // screw holes
+            translate([0, 0, pi_cam_back_clearance + layer_height])
+                rotate([0, 0, 90])
+                    poly_cylinder(r = M2_clearance_radius, h = 100, center = true);
+
+        translate([0, pi_cam_centreline, 0])
+            cube(pi_cam_turret + 2 * clearance, center = true);                                     // hole for lens
+
+        rotate([0, 180, 0]) translate(pi_cam_led_pos) cylinder(r = led_hole_r, h = 100, center = true);   // hole for led
+        //
+        // bar clamp
+        //
+        translate([-50, band_y - band_slit / 2, band_or + band_ir + 5 * layer_height / 4])
+            cube([100, band_slit, 100]);
+
+        translate([0, band_y + band_tab_d / 2, band_or + band_tab_height - band_tab_h / 2])
+            rotate([90, 0, 0])
+                nut_trap(M3_clearance_radius, nut_radius(M3_nut), M3_nut_trap_depth, horizontal = true);
+
+    }
+
+}
+
+module camera_bar(male = false) {
+    length = bar_length / 2 + (male ? -bar_overlap / 2 : bar_overlap / 2);
+
+    translate([0, base_depth / 2 - bar_y, 0])
+        difference() {
+            union() {
+                tube(or = bar_dia / 2, ir = bar_dia / 2 - bar_wall, h = length, center = false);
+                if(male)
+                    translate([0, 0, length - 6 * layer_height])
+                        cylinder(r = bar_dia / 2 - wall - 0.1, h = bar_overlap + 6 * layer_height);
+            }
+            if(!male)
+                translate([0, 0, length])
+                    cylinder(r = bar_dia / 2 - wall, h = 2 * bar_overlap + 2, center = true);
+
+            *translate([-100, 0, 0])
+                cube([200, 200, 200]);
+    }
+}
+
+module rpi_light_clamp_stl() {
+
+    thickness = 3;
+    overlap = 1;
+    length = light_strip_width(light) + 2 * wall;
+    gap = light_strip_width(light) + clearance;
+
+    stl("rpi_light_clamp");
+
+    difference() {
+        union() {
+            translate([-length / 2, - bar_y_offset, 0])
+                cube([length, thickness + bar_y_offset, band_width]);
+
+            translate([0, 0, band_width / 2 + eta])
+                rotate([-90, 0, 0])
+                    teardrop(r = nut_trap_radius(M3_nut) + wall, h = wall + M3_nut_trap_depth);
+
+
+            translate([bar_z_offset, -bar_y_offset, 0]) {
+                cylinder(r = band_or, h = band_width);
+
+                translate([light_band_tab_height / 2, 0, band_width / 2])
+                    cube([light_band_tab_height, band_tab_d, band_width], center = true);                     // tab for screw
+            }
+        }
+        translate([-gap / 2, - bar_y_offset * 2, -1])
+            cube([gap, bar_y_offset * 2, band_width + 2]);
+
+        translate([-gap / 2 - wall - 1, -bar_y_offset -overlap, -1])
+            cube([wall + 2, bar_y_offset, band_width + 2]);
+
+        translate([bar_z_offset, -bar_y_offset, 0])
+            cylinder(r = band_ir, h = 100, center = true);
+
+
+        translate([0, wall + M3_nut_trap_depth, band_width / 2])
+            rotate([90, 0, 0])
+                nut_trap(M3_clearance_radius, nut_radius(M3_nut), M3_nut_trap_depth, horizontal = true);
+        //
+        // bar clamp
+        //
+        translate([bar_z_offset, -bar_y_offset, 0]) {
+            translate([0, -band_slit / 2, -1])
+                cube([100, band_slit, band_width + 2]);
+
+            translate([light_band_tab_height - light_band_tab_h / 2, -band_tab_d / 2, band_width / 2])
+                rotate([90, 0, 0])
+                    nut_trap(M3_clearance_radius, nut_radius(M3_nut), M3_nut_trap_depth, horizontal = true);
+        }
+   }
+}
+
+
+module raspberry_pi_camera_assembly(light_strip = true) {
+    assembly("raspberry_pi_camera_assembly");
+
+    translate([0, bar_y, bar_z]) {
+        rotate([angle, 0, 0])
+            translate([cam_x, cam_y - bar_y, cam_z - bar_z]) rotate([90, 0, 0]) translate([0, -pi_cam_centreline, 0]) {
+                color("lime") render()
+                    translate([0, 0, - pi_cam_front_depth - 40 * exploded])
+                        rpi_camera_back_stl();
+
+                color("blue") render()
+                    rotate([0, 180, 0])
+                        rpi_camera_front_stl();
+
+                translate([0, 0, pi_cam_back_depth - pi_cam_front_depth - 23 * exploded])
+                    raspberry_pi_camera();
+
+                pi_cam_holes(mid_only = true) group() {
+                    screw_and_washer(M2_cap_screw, 12);
+
+                    translate([0, 0, -pi_cam_front_depth + M2_nut_trap_depth - 40 * exploded])
+                        rotate([0, 180, 90])
+                            nut(M2_nut, true);
+                }
+
+                translate([0, (band_y - band_tab_d / 2), -(band_or + band_tab_height - band_tab_h / 2)]) {
+                    rotate([90, 0, 0])
+                        screw_and_washer(M3_cap_screw, 16);
+
+                    translate([0, band_tab_d - M3_nut_trap_depth, 0])
+                        rotate([-90, 0, 0])
+                            nut(M3_nut, true);
+                }
+
+                translate([0, pi_cam_centreline, 1.5 + 10 * exploded]) color("lime") render() rpi_camera_focus_ring_stl();
+            }
+
+        if(light_strip)
+            rotate([light_angle, 0, 0])
+                translate([light_x, bar_y_offset, bar_z_offset]) {
+                    rotate([90, 0, 0])
+                        light_strip(light);
+
+                    for(side = [-1, 1])
+                        translate([side * light_strip_hole_pitch(light) / 2, 0, 0]) {
+                            translate([-band_width / 2, 0, 0])
+                                rotate([0, 90, 0])
+                                    color("blue") render() rpi_light_clamp_stl();
+
+                            translate([0, -light_strip_thickness(light), 0])
+                                rotate([90, 0, 0])
+                                    screw_and_washer(M3_cap_screw, 10);
+
+                            translate([0, wall, 0])
+                                rotate([-90, 90, 0])
+                                    nut(M3_nut, true);
+
+                            translate([0, -bar_y_offset, -bar_z_offset]) {
+                                translate([0, band_tab_d / 2, -light_band_tab_height + light_band_tab_h / 2])
+                                    rotate([-90, 0, 0])
+                                        screw_and_washer(M3_cap_screw, 16);
+
+                                translate([0, -band_tab_d / 2 + M3_nut_trap_depth,
+                                              -light_band_tab_height + light_band_tab_h / 2])
+                                    rotate([90, 90, 0])
+                                        nut(M3_nut, true);
+                            }
+                        }
+                }
+
+    }
+
+    stl("rpi_camera_bar");
+
+    for(side = [-1, 1])
+        translate([side < 0 ? left : right, base_depth / 2, bar_z])
+            explode([20 * side, 0, 0])
+                rotate([0, side * 90, 180])
+                    frame_edge_clamp_assembly(length = clamp_length, left = side < 0)
+                        camera_bar(side > 0);
+
+    if(show_rays) {
+        %hull() {                           // light ray, should point at centre of Y axis.
+            translate([0, bar_y, bar_z])
+                rotate([angle, 0, 0])
+                    translate([cam_x, cam_y - bar_y, cam_z - bar_z])
+                        sphere();
+
+            translate([X_origin, Y0, bed_height])
+                sphere();
+        }
+
+        %hull() {                           // light ray, should point at centre of Y axis.
+            translate([0, bar_y, bar_z])
+                rotate([light_angle, 0, 0])
+                    translate([X_origin, bar_y_offset - light_strip_thickness(light), bar_z_offset])
+                        sphere();
+
+            translate([X_origin, Y0, bed_height])
+                sphere();
+        }
+
+        translate([X_origin, Y0 + Y_travel / 2, bed_height + Z_travel / 2])
+            %cube([X_build, Y_build, Z_travel], center = true);               // work volume at max Y travel
+    }
+
+    end("raspberry_pi_camera_assembly");
+}
+
+module rpi_camera_bar_stl() {
+
+    for(side = [-1, 1])
+        translate([side * (clamp_length / 2 + 1), 0, 0]) {
+            frame_edge_clamp_front_stl(length = clamp_length)
+                camera_bar(side > 0);
+
+            translate([0, frame_edge_clamp_width() + 2, 0])
+                frame_edge_clamp_back_stl(length = clamp_length);
+        }
+}
+
+module rpi_camera_case_stl() {
+    rpi_camera_front_stl();
+
+    translate([pi_cam_front_length, 0, 0])
+        rpi_camera_back_stl();
+}
+
+if(1)
+    raspberry_pi_camera_assembly();
+else
+    if(1)
+        rpi_camera_case_stl();
+    else
+        rpi_camera_bar_stl();

scad/spool_holder.scad

@@ -48,6 +48,8 @@ tube_spacing = sqrt(dx * dx + dy * dy);
 
 width = spool_width(spool) - 2 * (thickness + washer_thickness(M8_washer) + washer_thickness(M8_penny_washer));
 
+function spool_holder_gap() = spool_y - width / 2 - thickness - (gantry_Y + sheet_thickness(frame));
+
 sponge_length = 15;
 sponge_depth  = 15;
 sponge_height = 15;
@@ -175,15 +177,15 @@ module tube(height) {
 //
 // The outline of the bracket, triangle with rounded corners
 //
-module shape(width, height) {
+module shape(width, height, offset = 0) {
     hull() {
-        circle(washer_diameter(M8_washer) / 2 + 1);
+        circle(washer_diameter(M8_washer) / 2 + 1 + offset);
 
         translate([width - tube_r, height + hook - tube_r])
-            circle(tube_r);
+            circle(tube_r + offset);
 
         translate([width - tube_r, -height + tube_r])
-            circle(tube_r);
+            circle(tube_r + offset);
     }
 }
 //
@@ -196,15 +198,12 @@ module inner_shape(width, height) {
     inset = frame_bar_width + rad;
 
     minkowski() {
-        render() difference() {
+        difference() {
             shape(width, height);
             union() {
                 minkowski() {
                     difference() {
-                        minkowski() {
-                            shape(width, height);
-                            circle(r = 1, center = true);
-                        }
+                        shape(width, height, 1);
                         shape(width, height);
                         translate([width -1, -inset])
                             square([3, 2 * inset + 1]);

scad/vitamins/ball-bearings.scad

@@ -23,7 +23,7 @@ module ball_bearing(type) {
         for(z = [-type[2] / 2, type[2] / 2])
             translate([0,0,z]) difference() {
                 cylinder(r = (type[1] - rim) / 2, h = 2, center = true);
-                cylinder(r = (type[0] + rim) / 2, 2, center = true);
+                cylinder(r = (type[0] + rim) / 2, h = 3, center = true);
             }
     }
 }

scad/vitamins/electronics.scad

@@ -27,8 +27,9 @@ function controller_accessories(type) = type[4];
 module controller_screw_positions(type) {
     inset = controller_hole_inset(type);
 
-    for(x = [inset, controller_width(type) - inset])
-        for(y = [inset, controller_length(type) - inset])
+    for($i = [0:3])
+        assign(x = [inset, controller_width(type) - inset][$i % 2])
+        assign(y = [inset, controller_length(type) - inset][$i / 2])
             translate([x, y, 0])
                 child();
 }

scad/vitamins/fans.scad

@@ -61,7 +61,7 @@ module fan(type) {
     //Seven Blades
     linear_extrude(height = depth - 1, center = true, convexity = 4, twist = -30, slices = depth / 2)
         for(i= [0 : 6])
-            rotate((360 * i) / 7)
+            rotate([0, 0, (360 * i) / 7])
                 translate([0, -1.5 / 2])
                     square([fan_bore(type) / 2 - 0.75, 1.5]);
 }

scad/vitamins/light_strips.scad

@@ -0,0 +1,29 @@
+//
+// Mendel90
+//
+// GNU GPL v2
+// nop.head@gmail.com
+// hydraraptor.blogspot.com
+//
+// LED light strips
+//
+SPS125 = ["SPS125: Sanken SPS125 light strip", 300, 20, 0, 1.6, 260, 3.5];
+
+function light_strip_length(type)     = type[1];
+function light_strip_width(type)      = type[2];
+function light_strip_set_back(type)   = type[3];
+function light_strip_thickness(type)  = type[4];
+function light_strip_hole_pitch(type) = type[5];
+function light_strip_hole_dia(type)   = type[6];
+
+module light_strip(type) {
+    vitamin(type[0]);
+    color("white") render() difference() {
+        translate([0, 0, light_strip_thickness(type) / 2])
+            cube([light_strip_length(type), light_strip_width(type), light_strip_thickness(type)], center = true);
+
+        for(side = [-1, 1])
+            translate([side * light_strip_hole_pitch(type) / 2, 0, 0])
+                cylinder(r = light_strip_hole_dia(type) / 2, h = 100, center = true);
+    }
+}

scad/vitamins/linear-bearings.scad

@@ -12,7 +12,9 @@ LM8UU  = [24, 15,  8];
 LM6UU  = [19, 12,  6];
 LM4UU  = [12,  8,  4];
 
+function bearing_length(type)  = type[0];
 function bearing_radius(type)  = type[1] / 2;
+function bearing_rod_dia(type) = type[2];
 
 module linear_bearing(type) {
     vitamin(str("LM",type[2],"UU: ","LM",type[2],"UU linear bearing"));

scad/vitamins/nuts.scad

@@ -7,6 +7,7 @@
 //
 // Washers
 //
+M2_nut    =   [2, 4.9, 1.6, 2.4,  M2_washer,     M2_nut_trap_depth];
 M2p5_nut  = [2.5, 5.8, 2.2, 3.8,  M2p5_washer, M2p5_nut_trap_depth];
 M3_nut      = [3, 6.4, 2.4, 4,    M3_washer,     M3_nut_trap_depth];
 M4_nut      = [4, 8.1, 3.2, 5,    M4_washer,     M4_nut_trap_depth];

scad/vitamins/screws.scad

@@ -13,8 +13,9 @@ hs_cs  = 2;     // counter sunk
 hs_hex = 3;
 hs_grub= 4;     // pulley set screw
 
-M2p5_pan_screw = ["PS025", "M2.5 pan screw",     hs_pan, 2.5, 4.7, 1.7, M2p5_washer, false,  M2p5_tap_radius,  M2p5_clearance_radius];
+M2_cap_screw   = ["CS020", "M2 cap screw",       hs_cap,   2, 3.8, 1.5,   M2_washer, false,  M2_tap_radius,    M2_clearance_radius];
 
+M2p5_pan_screw = ["PS025", "M2.5 pan screw",     hs_pan, 2.5, 4.7, 1.7, M2p5_washer, false,  M2p5_tap_radius,  M2p5_clearance_radius];
 M2p5_cap_screw = ["CS025", "M2.5 cap screw",     hs_cap, 2.5, 4.7, 2.0, M2p5_washer, false,  M2p5_tap_radius,  M2p5_clearance_radius];
 
 M3_cap_screw   = ["CS030", "M3 cap screw",       hs_cap,   3, 5.5, 2.5,   M3_washer, M3_nut, M3_tap_radius,    M3_clearance_radius];
@@ -69,8 +70,8 @@ module screw(type, length, hob_point = 0) {
     rad = screw_radius(type) - eta;
     head_rad = screw_head_radius(type);
     if(exploded)
-        cylinder(r = 0.2, h = 16);
-    translate([0, 0, exploded ? length + 10 : 0]) {
+        cylinder(r = 0.2, h = 10 * exploded);
+    translate([0, 0, exploded ? (length + 10) * exploded : 0]) {
         if(head_type == hs_cap) {
             assign(head_height = rad * 2,
                    socket_rad = type[5] / cos(30) / 2,

scad/vitamins/sheet.scad

@@ -28,6 +28,7 @@ PMMA8    = [ "AC", "Acrylic sheet",        8, [1,   1,   1,   0.5  ], false];
 PMMA10   = [ "AC", "Acrylic sheet",       10, [1,   1,   1,   0.5  ], false];   // ~3/8"
 glass2   = [ "GL", "Glass sheet",          2, [1,   1,   1,   0.25 ], false];
 DiBond   = [ "DB", "Dibond sheet",         3, "RoyalBlue",            false];
+DiBond6  = [ "DB", "Dibond sheet",         6, "RoyalBlue",            false];
 Cardboard= [ "CB", "Corrugated cardboard", 5, [0.8, 0.6, 0.3, 1    ], false];
 FoilTape = [ "AF", "Aluminium foil tape",0.05,[0.9, 0.9, 0.9, 1    ], false];
 Foam20   = [ "FM", "Foam sponge",          20,[0.3, 0.3, 0.3, 1    ], true];

scad/vitamins/stepper-motors.scad

@@ -17,11 +17,12 @@ NEMA14  = [35.2, 36,     46.4/2, 21,     11,     2,     5,     21,     26 ];
 function NEMA_width(motor)    =    motor[0];
 function NEMA_length(motor)      = motor[1];
 function NEMA_radius(motor)      = motor[2];
-function NEMA_holes(motor)    = [-motor[8]/2, motor[8]/2];
 function NEMA_big_hole(motor)    = motor[4] + 0.2;
+function NEMA_boss_height(motor) = motor[5];
 function NEMA_shaft_dia(motor)   = motor[6];
-function NEMA_shaft_length(motor) = motor[7];
+function NEMA_shaft_length(motor)= motor[7];
 function NEMA_hole_pitch(motor)  = motor[8];
+function NEMA_holes(motor)       = [-motor[8]/2, motor[8]/2];
 
 module NEMA(motor) {
     side = NEMA_width(motor);

scad/vitamins/washers.scad

@@ -7,7 +7,8 @@
 //
 // Washers
 //
-M2p5_washer=      [2.5, 5.9, 0.5, false,  5.4];
+M2_washer =       [2,   5, 0.3, false,  4.5];
+M2p5_washer=      [2.5,5.9,0.5, false,  5.4];
 M3_washer  =      [3,   7, 0.5, false,  5.8];
 M3_penny_washer  =[3,  12, 0.8, false,  5.8];
 M3p5_washer  =    [3.5, 8, 0.5, false,  6.9];

sturdy/bom/accessories/light_strip_assembly.txt

@@ -0,0 +1,11 @@
+light_strip_assembly:
+Vitamins:
+  2 M3 cap screw x 10mm
+  2 Nyloc nut M3
+  1 Sanken SPS125 light strip
+  2 Washer M3 x 7mm x 0.5mm
+
+Printed:
+  1 light_strip_bracket_left.stl
+  1 light_strip_bracket_right.stl
+

sturdy/bom/accessories/raspberry_pi_assembly.txt

@@ -0,0 +1,10 @@
+raspberry_pi_assembly:
+Vitamins:
+  2 Nyloc nut M2.5
+  2 M2.5 pan screw x 12mm
+  1 Raspberry PI model B
+  2 Washer M2.5 x 5.9mm x 0.5mm
+
+Printed:
+  1 rpi_bracket.stl
+

sturdy/bom/accessories/raspberry_pi_camera_assembly.txt

@@ -0,0 +1,20 @@
+raspberry_pi_camera_assembly:
+Vitamins:
+  2 M2 cap screw x 12mm
+  2 M3 cap screw x 10mm
+  3 M3 cap screw x 16mm
+  4 M3 cap screw x 25mm
+  2 Nyloc nut M2
+  9 Nyloc nut M3
+  1 Raspberry PI camera
+  1 Sanken SPS125 light strip
+  2 Washer M2 x 5mm x 0.3mm
+  9 Washer M3 x 7mm x 0.5mm
+
+Printed:
+  1 rpi_camera_back.stl
+  1 rpi_camera_bar.stl
+  1 rpi_camera_focus_ring.stl
+  1 rpi_camera_front.stl
+  2 rpi_light_clamp.stl
+