mirror of
https://github.com/nophead/Mendel90.git
synced 2025-01-16 20:38:15 +01:00
552 lines
21 KiB
OpenSCAD
552 lines
21 KiB
OpenSCAD
//
|
|
// Mendel90
|
|
//
|
|
// GNU GPL v2
|
|
// nop.head@gmail.com
|
|
// hydraraptor.blogspot.com
|
|
//
|
|
// Bracket to mount RPI camera
|
|
//
|
|
include <conf/config.scad>
|
|
include <positions.scad>
|
|
use <light_strip_clip.scad>
|
|
use <frame_edge_clamp.scad>
|
|
|
|
left = left_stay_x + sheet_thickness(frame) / 2;
|
|
right = right_stay_x - sheet_thickness(frame) / 2;
|
|
|
|
light = light_strip ? light_strip : (right - left) > 300 ? RIGID5050_290 : RIGID5050_208;
|
|
light2 = light == RIGID5050_290 ? RIGID5050_208 : 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;
|
|
|
|
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);
|
|
|
|
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;
|
|
|
|
pivot_screw_length = 16;
|
|
end_cap_nut_boss_r = nut_trap_radius(M3_nut, horizontal = false) + 3 * filament_width;
|
|
end_cap_nut_boss = pivot_screw_length - washer_thickness(M3_washer) - frame_edge_clamp_thickness() - 2;
|
|
|
|
pivot_offset = frame_edge_clamp_hinge() + washer_diameter(M3_washer) / 2;
|
|
pivot_y = base_depth / 2 + pivot_offset;
|
|
|
|
light2_z_top = light_strip_clip_length(light) / 2 + (light2 ? light_strip_clip_length(light2) - wall : 0);
|
|
light2_distance = sqrt(sqr(Z_travel) + sqr(y_limit - Y0));
|
|
max_light_angle = atan2(Z_travel, y_limit - Y0) - asin(light2_z_top / light2_distance);
|
|
max_pivot_z = bed_height + tan(max_light_angle) * (pivot_y - Y0);
|
|
pivot_z = 240;
|
|
|
|
pivot_light2_distance = sqrt(sqr(bed_height + Z_travel - max_pivot_z) + sqr(y_limit - pivot_y));
|
|
pivot_max_distance = sqrt(sqr(max_pivot_z - bed_height) + sqr(pivot_y - Y0));
|
|
|
|
light_x = (left + right) / 2;
|
|
light_y = pivot_y - end_cap_nut_boss_r;
|
|
light_angle = atan2(pivot_z - bed_height, pivot_y - Y0);
|
|
|
|
hinge_screw = M2_cap_screw;
|
|
hinge_nut = screw_nut(hinge_screw);
|
|
hinge_screw_length = 12;
|
|
|
|
hinge_r = nut_trap_radius(hinge_nut) + 3 * filament_width;
|
|
hinge_h = max(wall + nut_trap_depth(hinge_nut), light_strip_clip_depth(light) / 2);
|
|
cam_hinge_h = light_strip_clip_depth(light) - hinge_h;
|
|
|
|
light_hinge_offset = hinge_r + 0.5;
|
|
light_hinge_z_offset = light_strip_clip_length(light) / 2 + light_hinge_offset * cos(light_angle);
|
|
light_hinge_y_offset = light_strip_clip_width(light) + light_hinge_offset * sin(light_angle);
|
|
|
|
hinge_y = light_y + wall - light_hinge_y_offset;
|
|
hinge_z = pivot_z - light_hinge_z_offset;
|
|
|
|
cam_hinge_z_offset = pi_cam_front_width / 2 + hinge_r - pi_cam_width / 2 + pi_cam_back_width / 2 - pi_cam_centreline + 0.5;
|
|
cam_hinge_y_offset = hinge_r;
|
|
|
|
cam_x = X_origin;
|
|
cam_y = hinge_y - cam_hinge_y_offset;
|
|
cam_z = hinge_z - cam_hinge_z_offset;
|
|
|
|
light2_z_offset = light2_z_top - light_strip_clip_length(light2) / 2;
|
|
light2_x_offset = cam_x - light_x;
|
|
dy = sqrt(sqr(pivot_light2_distance) - sqr(light2_z_top));
|
|
light2_y_offset = -(pivot_y - light_y) + wall - light_strip_clip_width(light2) + (light2_distance < pivot_max_distance ? dy : -dy);
|
|
|
|
clamp_length = 20;
|
|
|
|
hypot = sqrt(sqr(pivot_z - bed_height) + sqr(pivot_y - Y0));
|
|
adj = hypot - (pivot_y - hinge_y);
|
|
alpha = atan2(light_hinge_z_offset, adj);
|
|
hypot2 = sqrt(sqr(adj) + sqr(light_hinge_z_offset));
|
|
beta = asin(cam_hinge_z_offset / hypot2);
|
|
cam_angle = light_angle - alpha - beta;
|
|
|
|
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])
|
|
children();
|
|
}
|
|
|
|
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);
|
|
|
|
if(show_rays)
|
|
translate([0, pi_cam_centreline, pi_cam_thickness])
|
|
%cylinder(r = 1, h = 100);
|
|
}
|
|
|
|
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);
|
|
|
|
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() {
|
|
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_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);
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
module rpi_camera_front_stl() {
|
|
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);
|
|
}
|
|
|
|
translate([-light_strip_clip_depth(light) / 2 + hinge_h, cam_hinge_z_offset + pi_cam_centreline, cam_hinge_y_offset])
|
|
hull() {
|
|
rotate([-90, 0, -90])
|
|
teardrop(r = hinge_r, h = cam_hinge_h);
|
|
|
|
translate([0, -hinge_r - 10, - hinge_r])
|
|
cube([cam_hinge_h, hinge_r + 10, 2 * hinge_r]);
|
|
}
|
|
}
|
|
translate([0, cam_hinge_z_offset + pi_cam_centreline, cam_hinge_y_offset])
|
|
rotate([90, 0, 90])
|
|
teardrop_plus(r = screw_clearance_radius(hinge_screw), h = 100, 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
|
|
}
|
|
}
|
|
|
|
module pivot_lug() {
|
|
linear_extrude(height = frame_edge_clamp_thickness(), convexity = 2)
|
|
difference() {
|
|
hull() {
|
|
translate([-clamp_length / 2, -frame_edge_clamp_hinge()])
|
|
square([clamp_length, eta]);
|
|
|
|
translate([0, -pivot_offset])
|
|
circle(washer_diameter(M3_washer)/ 2 + 1);
|
|
}
|
|
translate([0, -pivot_offset])
|
|
poly_circle(M3_clearance_radius);
|
|
}
|
|
}
|
|
|
|
module light_strip_end_cap_stl() {
|
|
base_thickness = (right - left - 2 * frame_edge_clamp_thickness() - 1 - light_strip_length(light)) / 2;
|
|
|
|
difference() {
|
|
union() {
|
|
linear_extrude(height = base_thickness, convexity = 2)
|
|
hull() {
|
|
translate([-light_strip_clip_length(light) / 2, end_cap_nut_boss_r - wall])
|
|
square([light_strip_clip_length(light), light_strip_clip_width(light)]);
|
|
|
|
circle(end_cap_nut_boss_r);
|
|
}
|
|
|
|
cylinder(r = end_cap_nut_boss_r, h = end_cap_nut_boss);
|
|
|
|
translate([0, end_cap_nut_boss_r - wall, base_thickness - eta])
|
|
light_strip_clip(light);
|
|
}
|
|
translate([0, 0, end_cap_nut_boss])
|
|
nut_trap(M3_clearance_radius, M3_nut_radius, M3_nut_trap_depth);
|
|
|
|
translate([-(light_strip_clip_gap(light) - eta) / 2, end_cap_nut_boss_r + eta, -1]) // extend the slot for wires
|
|
cube([light_strip_clip_gap(light) - 2 * eta, 100, 100]);
|
|
|
|
translate([50, end_cap_nut_boss_r - wall - eta, end_cap_nut_boss + eta]) // truncate back to level of screw boss when is short
|
|
rotate([0, 0, 180])
|
|
cube([100, 100, 100]);
|
|
}
|
|
}
|
|
|
|
module rpi_camera_bracket_stl(include_support = true) {
|
|
difference() {
|
|
union() {
|
|
light_strip_clip(light);
|
|
|
|
translate([light_hinge_z_offset, light_hinge_y_offset, 0]) union() {
|
|
cylinder(r = hinge_r, h = hinge_h);
|
|
|
|
rotate([0, 0, 180 + light_angle])
|
|
translate([0, - wall / 2, 0])
|
|
cube([light_hinge_offset + wall, wall, hinge_h]);
|
|
}
|
|
}
|
|
translate([light_hinge_z_offset, light_hinge_y_offset, 0])
|
|
nut_trap(screw_clearance_radius(hinge_screw), nut_radius(hinge_nut), nut_trap_depth(hinge_nut), supported = include_support);
|
|
}
|
|
}
|
|
|
|
module light_strip_piggy_back_clip() {
|
|
union() {
|
|
light_strip_clip(light);
|
|
|
|
translate([light2_z_offset, light2_y_offset, 0]) {
|
|
difference() {
|
|
translate([-light_strip_clip_length(light2) / 2, 0, 0])
|
|
cube([light_strip_clip_length(light2), light_strip_clip_width(light2), wall]);
|
|
|
|
translate([-(light_strip_clip_gap(light2) - eta) / 2, wall, -1]) // extend the slot for wires
|
|
cube([light_strip_clip_gap(light2) - 2 * eta, 100, 100]);
|
|
}
|
|
translate([0, 0, wall - eta])
|
|
light_strip_clip(light2);
|
|
}
|
|
|
|
translate([light_strip_clip_length(light) / 2, 0, 0])
|
|
rotate([0, 0, 180])
|
|
cube([wall, -light2_y_offset, light_strip_clip_depth(light2)]);
|
|
}
|
|
}
|
|
|
|
module light_strip_piggy_back_clips_stl() {
|
|
|
|
offset = -(light_strip_clip_length(light) / 2 + light_strip_clip_length(light2) - wall);
|
|
translate([offset, -light_strip_clip_width(light) - 1, 0])
|
|
light_strip_piggy_back_clip();
|
|
|
|
translate([offset, light_strip_clip_width(light) + 1, 0])
|
|
rotate([180, 0, 0])
|
|
mirror([0, 0, 1])
|
|
light_strip_piggy_back_clip();
|
|
}
|
|
|
|
module raspberry_pi_camera_assembly() {
|
|
assembly("raspberry_pi_camera_assembly");
|
|
|
|
stl("rpi_camera_case");
|
|
translate([0, pivot_y, pivot_z]) {
|
|
rotate([light_angle, 0, 0])
|
|
translate([0, hinge_y - pivot_y, hinge_z - pivot_z])
|
|
rotate([cam_angle - light_angle, 0, 0])
|
|
translate([cam_x, cam_y - hinge_y, cam_z - hinge_z - pi_cam_centreline]) rotate([90, 0, 0]) {
|
|
color("lime") render()
|
|
translate([0, 0, - pi_cam_front_depth - 40 * exploded])
|
|
rpi_camera_back_stl();
|
|
|
|
color("red") 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, pi_cam_centreline, 1.5 + 10 * exploded])
|
|
color("lime") render()
|
|
rpi_camera_focus_ring_stl();
|
|
}
|
|
}
|
|
|
|
stl("light_and_camera_brackets");
|
|
stl("rear_light_brackets");
|
|
|
|
translate([0, pivot_y, pivot_z])
|
|
rotate([light_angle, 0, 0]) {
|
|
translate([light_x, light_y - pivot_y, 0]) {
|
|
rotate([90, 0, 0]) {
|
|
light_strip(light);
|
|
|
|
if(light2) {
|
|
translate([light2_x_offset, light2_z_offset, light2_y_offset])
|
|
light_strip(light2);
|
|
|
|
for(side = [-1, 1])
|
|
translate([light2_x_offset + side * (light_strip_length(light2) / 2 + wall), 0, -wall])
|
|
rotate([90, 0, 90])
|
|
mirror([0, 0, side > 0 ? 1 : 0])
|
|
color("lime") render()
|
|
light_strip_piggy_back_clip();
|
|
}
|
|
}
|
|
|
|
translate([cam_x - light_x + light_strip_clip_depth(light) / 2, wall, 0])
|
|
rotate([180, 90, 0]) {
|
|
color("lime") render()
|
|
rpi_camera_bracket_stl(false);
|
|
|
|
translate([light_hinge_z_offset, light_hinge_y_offset, 0]) {
|
|
translate([0, 0, hinge_h + cam_hinge_h])
|
|
screw_and_washer(hinge_screw, hinge_screw_length);
|
|
|
|
translate([0, 0, nut_trap_depth(hinge_nut)])
|
|
rotate([180, 0, 0])
|
|
nut(hinge_nut, true);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
for(side = [-1, 1])
|
|
translate([side < 0 ? left : right, base_depth / 2, pivot_z])
|
|
explode([20 * side, 0, 0])
|
|
rotate([0, side * 90, 180]) {
|
|
frame_edge_clamp_assembly(length = clamp_length, kids = true)
|
|
pivot_lug();
|
|
|
|
translate([0, -pivot_offset, 0]) {
|
|
rotate([180, 0, 0])
|
|
screw_and_washer(M3_cap_screw, pivot_screw_length);
|
|
|
|
translate([0, 0, frame_edge_clamp_thickness() + end_cap_nut_boss - M3_nut_trap_depth])
|
|
rotate([0, 0, -side * light_angle])
|
|
nut(M3_nut, true);
|
|
}
|
|
|
|
translate([0, -pivot_offset, frame_edge_clamp_thickness()])
|
|
rotate([0, 0, -side * light_angle])
|
|
color("lime") render()
|
|
light_strip_end_cap_stl();
|
|
}
|
|
|
|
if(show_rays) {
|
|
%hull() { // light ray, should point at centre of Y axis.
|
|
translate([0, pivot_y, pivot_z])
|
|
rotate([light_angle, 0, 0])
|
|
translate([0, hinge_y - pivot_y, hinge_z - pivot_z])
|
|
rotate([cam_angle - light_angle, 0, 0])
|
|
translate([cam_x, cam_y - hinge_y, cam_z - hinge_z])
|
|
sphere();
|
|
|
|
translate([X_origin, Y0, bed_height])
|
|
sphere();
|
|
}
|
|
|
|
%hull() { // light ray, should point at centre of Y axis.
|
|
translate([0, pivot_y, pivot_z])
|
|
rotate([light_angle, 0, 0])
|
|
translate([X_origin, -(pivot_y - light_y) - light_strip_thickness(light), 0])
|
|
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 rear_light_brackets_stl() {
|
|
for(side = [-1, 1]) {
|
|
translate([side * (clamp_length / 2 + 1), 0, 0]) {
|
|
translate([0, -frame_edge_clamp_width() + frame_edge_clamp_hinge() - 2, 0])
|
|
frame_edge_clamp_front_stl(length = clamp_length)
|
|
pivot_lug();
|
|
|
|
translate([0, frame_edge_clamp_hinge(), 0])
|
|
frame_edge_clamp_back_stl(length = clamp_length);
|
|
}
|
|
}
|
|
}
|
|
|
|
module light_and_camera_brackets_stl() {
|
|
for(side = [-1, 1])
|
|
translate([side * (light_strip_clip_length(light) / 2 + 1), end_cap_nut_boss_r + 2, 0])
|
|
light_strip_end_cap_stl();
|
|
|
|
rotate([0, 0, 180])
|
|
rpi_camera_bracket_stl();
|
|
|
|
if(light2)
|
|
translate([0, light_strip_clip_width(light) + 2 * end_cap_nut_boss_r - wall + 4, 0])
|
|
rotate([0, 0, -90])
|
|
light_strip_piggy_back_clips_stl();
|
|
}
|
|
|
|
module rpi_camera_case_stl() {
|
|
rpi_camera_front_stl();
|
|
|
|
translate([pi_cam_front_length, 0, 0])
|
|
rpi_camera_back_stl();
|
|
|
|
translate([0, -pi_cam_front_width / 2 - 9, 0])
|
|
rpi_camera_focus_ring_stl();
|
|
}
|
|
|
|
if(1)
|
|
raspberry_pi_camera_assembly();
|
|
else if(1)
|
|
light_and_camera_brackets_stl();
|
|
else if(0)
|
|
rpi_camera_case_stl();
|
|
else
|
|
rear_light_brackets_stl();
|