ModularHotendMount/sensor_module_internal.scad at master · kll/ModularHotendMount · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
use <MCAD/polyholes.scad>
include <MCAD/nuts_and_bolts.scad>
include <config.scad>
use <nuttrap.scad>
use <fancy_cube.scad>

sensor_diameter = 18.75;
sensor_nut_height = 6.5;

main();

module main()
{
    difference()
    {
        ccube(module_body_size, body_chamfer, true);
        sensor_cutout();
        leveling_hardware_cutout();
        corner_cutout();
    }
}

module sensor_cutout()
{
    cut_size = module_body_size[2] + pf;
    translate([0, 0, -cut_size/2])
    {
        polyhole(cut_size, sensor_diameter);
    }

    nut_offset = module_body_size[2]/2 + sensor_nut_height/2 - sensor_nut_height + pf;
    translate([0, 0, nut_offset])
    {
        rotate([0, 0, 90])
        {
            cylinder(h=sensor_nut_height, d=METRIC_NUT_AC_WIDTHS[16]+tolerance, $fn=6, center=true);
        }
    }
}

module leveling_hardware_cutout()
{
    cut_length = module_body_size[2] + pf;
    cut_offset = module_body_size[1]/2 - module_mount_edge_offset;
    rotate([0, 0, 90])
    {
        for(y=[0:1])
        {
            rotate([0, 0, y*180])
            {
                translate([cut_offset, 0, 0])
                {
                    nutTrap(module_clamp_bolt_size, module_mount_edge_offset, tolerance);
                }

                translate([cut_offset, 0, -cut_length/2])
                {
                    polyhole(cut_length/2, module_clamp_bolt_size);
                }

                translate([cut_offset, 0, METRIC_NUT_THICKNESS[module_clamp_bolt_size]/2 + pf/2 + layer_height])
                {
                    polyhole(cut_length/2, module_clamp_bolt_size);
                }

                translate([cut_offset, 0, module_body_size[2]/4])
                {
                    polyhole(module_body_size[2]/4 + pf, module_level_spring_diameter);
                }
            }
        }
    }
}

module corner_cutout()
{
    for (x=[-1:2:1])
	{
		for (y=[-1:2:1])
		{
			x_offset = module_body_size[0]/2 * x;
			y_offset = module_body_size[1]/2 * y;
			translate([x_offset, y_offset, 0])
			{
				rotate([0, 0, 45])
				{
                    cube([module_body_size[0]/2.5 + pf, module_body_size[0]/2.5 + pf, module_body_size[2]+pf], true);
                }
			}
		}
	}
}