cx-module-wall/assets/cable_holder.scad

include <../config/cable_holder.scad>
include <../config/thread.scad>
include <../config/wall.scad>
include <thread.scad>

module cable_holder_object() {
    module single_cable_shape() {
        module base() {
            difference() {
                outside = cable_holder_thickness * 2 
                + cable_holder_cable_diameter
                - cable_holder_rounding * 2;

                inside = cable_holder_cable_diameter
                + cable_holder_rounding * 2;

                position = cable_holder_thickness
                + cable_holder_cable_diameter / 2
                - cable_holder_thickness / 2;

                circle(r = outside / 2);
                circle(r = inside / 2);

                translate([0, position]) {
                    square(cable_holder_hole, center = true);
                }
            }
        }

        minkowski() {
            base();
            circle(r = cable_holder_rounding);
        }
    }

    module single_cable_object() {
        height = cable_holder_base_thickness;

        module base() {
            linear_extrude(height = height, center = true) {
                single_cable_shape();
            }
        }
        
        module blocker() {
            radius = cable_holder_blocker_diameter / 2;
            
            height = cable_holder_cable_diameter 
            + cable_holder_thickness * 2;

            move = cable_holder_cable_diameter / 2
            + cable_holder_thickness
            - radius * 1.5;

            translate([0, move, 0]) {
                rotate([90, 0, 90]) {
                    cylinder(r = radius, h = height, center = true);

                    translate([radius, 0, 0]) {
                        rotate([0, 0, 45]) {
                            size = [
                                radius * 2, 
                                radius * 2, 
                                height
                            ];

                            cube(size, center = true);
                        }
                    }
                }
            }
        }
        
        render() {
            difference() {
                base();
                blocker();
            }
        }
    }

    module wall_mount_object() {
        module base_shape() {
            size = thread_height + cable_holder_thickness;
            move = cable_holder_width / 2 - size / 2;
     
            module close() {
                circle(r = size / 2);
                translate([0, -size / 4]) {
                    square([size, size / 2], center = true);
                }
            }   
            
            hull() {
                translate([-move, 0]) {
                    close();
                }

                translate([move, 0]) {
                    close();
                }
            }
        }

        module base_object() {
            height = cable_holder_base_thickness;

            linear_extrude(height = height, center = true) {
                base_shape();
            }
        }

        module thread(move_x) {
            move_y = thread_height / 2
            + cable_holder_thickness / 2
            - thread_height / 2;

            translate([move_x, -move_y, 0]) {
                rotate([270, 0, 0]) {
                    thread_object();
                }
            }
        }

        module threads() {
            base_width = cable_holder_width
            - thread_top_diameter;

            width = base_width
            - base_width % wall_holes_space;

            move_x = width / 2;

            for (count = [-move_x : wall_holes_space : move_x]) {
                thread(count);   
            }
        }

        render() {
            difference() {
                base_object();
                threads();
            }
        }
    }

    module final_object() {
        center_y = cable_holder_cable_diameter / 2
        + cable_holder_thickness
        + thread_height / 2
        + cable_holder_thickness / 2;

        module cable_object(move_x) {
            move_y = cable_holder_cable_diameter / 2
            + cable_holder_thickness / 2
            + thread_height
            + cable_holder_thickness 
            - center_y;

            translate([move_x, move_y, 0]) {
                single_cable_object();
            }
        }

        module cables_object() {
            base_size = cable_holder_thickness * 2
            + cable_holder_cable_diameter;

            size = base_size
            + cable_holder_thickness;

            base_width = cable_holder_width
            - thread_height / 2
            - cable_holder_thickness / 2
            - cable_holder_thickness;

            width = base_width 
            - base_width % size;

            move = width / 2;

            for (count = [-move : size : move]) {
                cable_object(count);
            }
        }

        move_wall_mount_y = thread_height / 2
        + cable_holder_thickness / 2
        - center_y;

        cables_object();
        
        translate([0, move_wall_mount_y, 0]) {
            wall_mount_object();
        }
    }

    color("#07F879") {
        render() {
            final_object();
        }
    }
}

module cable_holder_blocker_object() {
    module base_object() {
        radius = cable_holder_blocker_diameter / 2.1;
        
        height = cable_holder_cable_diameter 
        + cable_holder_thickness * 2;

        cylinder(r = radius, h = height, center = true);
    }

    module final_object() {
        rotate([0, 90, 0]) {
            base_object();
        }
    }

    color("#F80786") {
        render() {
            final_object();
        }
    }
}