// ----------------------------------------------------------------
// A collection of a few parameterizable plates for Fischertechnik
//
// 1) A base plate with a grid of holes for the pins of the basic 
//    building blocks. See section "Options for the base plate"
//    for the parameters that can be changed.
//    This is a configurable version of Art.-No. 32985, 
//    the base plate 258x186 
//
// 2) A resizable bottom plate with flat grooves.
//    Length and width of the plate may be configured by changing 
//    the values in the section "Plate options"
//    This is a configurable version of Art.-No. 32859, 
//    the bottom plate 30x90
//    
// 3) A resizable plate with holes to be combined with structural 
//    design components like angele girders and struts.
//    This plate has the option of a thinner area in the center of
//    one side of the plate.
//    This is a configurable version of Art.-No. 35431
//    the plate 90x90
//
// 4) A configurable version of the mounting plates.
//    It is possible to configure the length and width of the plate,
//    the position of the pins and even 15x15 mm holes in the plate
//    by setting a matrix describing the layout.
//    Each element in the matrix describes a 15x15 plate which are
//    finally combined into one big plate.
//    
//----------------------- parameters ------------------------------
/* [Plate options] */
// Plate type
PlateType = 0; // [0 : no output, 1:Base plate with grid, 2:Bottom plate, 3:Plate with holes, 4:Plate with pins]
// Plate length
Length = 90; // [30,45,60,75,90,105,120,135,150,165,180]
// Plate width
Width = 30; // [30,45,60,75,90,105,120,135,150,165,180]

/* [Options for the base plate] */
// The number of pin hole rows 
Rows = 4; // [2,4,6,8,10,12]
// The number of pin hole columns 
Columns = 4; // [2,4,6,8,10,12]

/* [Options for the plate with holes] */
// Use half thickness for the center area?
Thin_Center = false; // [false:No, true:yes]

/* [Options for the plate with pins] */
// Layout of the larger plate grid combined of 15x15 plates: 
// Every vector in the matrix describes one column of 15x15 mounting plates.
// The following values are valid:
// 0           - no segment at this position
// 1           - segment with a pin 
// 2           - segment without pin 
// 3,4,5,6     - half circles
// 7,8,9,10    - triangle segments, diagonal half of normal segment
// 11,12,13,14 - circle segments
// 15,16,17,18 - inverted circle segments
// Plate Layout, must be configured in source, configurator doesn't support matrix values
Layout = 
[
[ 0, 4, 0, 0, 4, 0],
[ 9, 7, 0, 0, 10, 8],
[ 2, 0, 0, 0, 0, 2],
[ 1, 18, 0, 0, 15, 1],
[ 2, 2, 2, 2, 2, 2],
[14, 1, 1, 1, 1, 11]
];

/* [Hidden] */

// **********************
// ** Static Settings: **
// **********************
include<ft_util.scad> 

// ********************
// ** Plate Modules: **
// ********************

// --------------------------------------------------------------------
// A build plate with a grid of holes for fixing basic blocks like 
// the base plate 258x186 
// --------------------------------------------------------------------
module build_plate(rows = 4, columns = 4) {
    assert((rows%2) == 0, "Rows must be a multiple of two!"); //%
    // some often used values
    plate_thickness = 2.8; 
    outer_wall = 3.0; 
    inner_wall = 1.6;
    half_inner_wall = inner_wall / 2;
    outer_wall_offset = outer_wall - half_inner_wall;
    cell_size = 13.4;
    center_fill = 2.2;

    cylinder_outer_d = 8.4;
    cylinder_inner_d = PLATE_HOLE_DIAMETER;
    
    width = columns * cell_size + (columns - 1) * inner_wall + 2 * outer_wall;
    length = rows * cell_size + (rows - 1) * inner_wall + 2 * outer_wall + center_fill * 2;
    height = BASIC_BLOCK_HALF;
    
    // from here on no values like 1.1, just variables. That way we 
    // can customize even the values not provided by the customizer.

    difference() {
        union() {
            // plate with outer walls
            difference () {
                cube([width, length, height]);
                // substract the inner area
                translate ([outer_wall, outer_wall, plate_thickness])
                    cube([width - outer_wall * 2, length - outer_wall * 2, height]);
            }

            // inner walls
            // wall at the vertical center 
            translate([0, length / 2 - half_inner_wall, 0])
                cube([width, inner_wall, height]);

            // the horizontal inner walls, 
            // first half from the bottom to the middle
            // for(i = [FT_GRID_SIZE : FT_GRID_SIZE : ((rows / 2) - 1) * FT_GRID_SIZE])
            //     translate([0, outer_wall_offset + i - half_inner_wall, 0])
            //         cube([width, inner_wall, height]);      
            // // the second half from the top to the middle
            // for(i = [FT_GRID_SIZE : FT_GRID_SIZE : ((rows / 2) - 1) * FT_GRID_SIZE])
            //     translate([0,length - (outer_wall_offset + i - half_inner_wall) , 0])
            //         cube([width, inner_wall, height]);  

            // the horizontal inner walls, 
            for(i = [FT_GRID_SIZE : FT_GRID_SIZE : ((rows / 2) - 1) * FT_GRID_SIZE]) {
                // first half from the bottom to the middle
                translate([0, outer_wall_offset + i - half_inner_wall, 0])
                    cube([width, inner_wall, height]);      
                // the second half from the top to the middle
                translate([0,length - (outer_wall_offset + i - half_inner_wall) , 0])
                    cube([width, inner_wall, height]);  
            }
            // for(i = [FT_GRID_SIZE : FT_GRID_SIZE : (columns - 1) * FT_GRID_SIZE]) 
            //     // vertical inner walls
            //     translate([outer_wall_offset + i - half_inner_wall, 0, 0])
            //         cube([inner_wall, length, height]);

            // // add cylinders, hole is done later !
            // for(i = [FT_GRID_SIZE : FT_GRID_SIZE : (columns - 1) * FT_GRID_SIZE])
            //     translate([outer_wall_offset + i, length / 2,0])
            //         cylinder(height, d = cylinder_outer_d);

            for(i = [FT_GRID_SIZE : FT_GRID_SIZE : (columns - 1) * FT_GRID_SIZE]) {
                // vertical inner walls
                translate([outer_wall_offset + i - half_inner_wall, 0, 0])
                    cube([inner_wall, length, height]);
                // add cylinders, hole is done later !
                translate([outer_wall_offset + i, length / 2,0])
                    cylinder(height, d = cylinder_outer_d);
            }

        }
        // drill the holes through the cylinders 
        for(i = [FT_GRID_SIZE : FT_GRID_SIZE : (columns - 1) * FT_GRID_SIZE])
            translate([outer_wall_offset + i, length / 2, -MANIFOLD_CORRECTION / 2])
                cylinder(height + MANIFOLD_CORRECTION, d = PLATE_HOLE_DIAMETER);
        
        // finally cut out the hole for the pins
        for(i = [FT_GRID_SIZE / 2 : FT_GRID_SIZE : columns * FT_GRID_SIZE])
                for(j = [FT_GRID_SIZE / 2 + outer_wall_offset : FT_GRID_SIZE :  ((rows / 2)) * FT_GRID_SIZE]) {
                    translate([outer_wall_offset + i, j, 0])
                        cube_with_cylinder(l1 = 5, dir = "up");
                    translate([outer_wall_offset + i, length - j, 0])
                        cube_with_cylinder(l1=5, dir = "down");
                }

    }
}

// --------------------------------------------------------------------
// A configurable bottom plate with a lot of flat grooves
// --------------------------------------------------------------------
module bottom_plate(length = 90, width = 30, height=BASIC_BLOCK_HALF) {
    groove_distance = BASIC_BLOCK_HALF;
    thin_wall = 1.4; // 1.5
    cubic_groove_width = 2.1; // 1.9
    cubic_groove_height = 2.85;
    bottom_bridge_width = 6.92;
    half_man_cor = MANIFOLD_CORRECTION / 2;
    
    // Attention: the order of unions and differences is important to get the 
    // desired result.
    difference() {
        difference() {
            union() {
                difference() {
                    // the plate without any cutouts
                    cube([width, length, height]);
                    // two long cubic grooves at the bottom, each of them divided into two separate
                    // grooves by the bridge 
                    translate([thin_wall, -half_man_cor, -half_man_cor]) {
                        cube([cubic_groove_width, length + MANIFOLD_CORRECTION, cubic_groove_height + MANIFOLD_CORRECTION]);
                        
                        translate([width -  2 * thin_wall - cubic_groove_width, 0, -half_man_cor])
                            cube([cubic_groove_width, length + MANIFOLD_CORRECTION, cubic_groove_height + MANIFOLD_CORRECTION]);
                    }
                    // two long flat grooves at the bottom, each of them divided into two separate
                    // grooves by the bridge 
                    rotate([90,0,0]) {
                        translate([groove_distance, 0, -(length / 2)])
                            flat_groove(length);
                        translate([width - groove_distance, 0, -length / 2])
                            flat_groove(length);
                    }
                }
                // a bridge in the middle of length, used for the two short flat grooves and
                // dividing the long grooves into two grooves of equal length
                translate([0, length / 2 - bottom_bridge_width / 2,0])
                    cube([width, bottom_bridge_width, 4.6]);
            }
            // the long cutout at the bottom with dynamic width
            translate([width / 2 - (6.9 + width - 30) / 2, -half_man_cor, -half_man_cor])
                cube([6.9 + width - 30, length + MANIFOLD_CORRECTION, cubic_groove_height + MANIFOLD_CORRECTION]);
            // the thin cubic grooves on the front and rear of the top
            translate([ -half_man_cor, thin_wall, height - cubic_groove_height])
                cube([width + MANIFOLD_CORRECTION, cubic_groove_width, cubic_groove_height + MANIFOLD_CORRECTION]);
            translate([-half_man_cor, length - thin_wall - cubic_groove_width , height - cubic_groove_height])
                cube([width + MANIFOLD_CORRECTION, cubic_groove_width, cubic_groove_height + MANIFOLD_CORRECTION]);
        }
        // the horizontal flat grooves on the top of the plate
        for (i = [0 : groove_distance : (length / groove_distance - 2) * groove_distance]) {
            translate([width / 2, i + groove_distance, height])
                rotate([270,0,90])
                    flat_groove(width);
        }
        // the oval cutout through the plate
        translate([width / 2, 2.35 + 17.8, 0])
            hull() {
                cylinder(r=2.35, h=height + MANIFOLD_CORRECTION, center = false);
                translate([0,3.3,0])
                    cylinder(r=2.35, h=height + MANIFOLD_CORRECTION, center = false);
            }
        // a short flat groove in the center of both long sides of the bottom  
        translate([4.55, length / 2, 0])
            rotate([90,0,90])
                flat_groove(len = 9.10);
        translate([width - 4.55, length / 2, 0])
            rotate([90,0,90])
                flat_groove(len = 9.10);
    }
}

// --------------------------------------------------------------------
// A plate with holes to be combined with structural design components
// like angele girders and struts
// Attention: The thin paraameter makes sense only if the width is
//            greater than 30.
// --------------------------------------------------------------------
module plate_with_holes(length = 45, width = 90, height = WALL_THICKNESS, thin = false) {
    difference() {
        difference() {
            cube([width, length, height]);
            if (thin == true) {                
                translate([BASIC_BLOCK_SIZE, height, height / 2]) 
                    cube([width - (BASIC_BLOCK_SIZE * 2), length - (height * 2), (height / 2) + MANIFOLD_CORRECTION ]);
            }
        }
        eyelet_row(len = length, height = height * 2 + MANIFOLD_CORRECTION); 
        translate([width - BASIC_BLOCK_SIZE, 0, 0])
            eyelet_row(len = length, height = height * 2 + MANIFOLD_CORRECTION); 
    }
}

// --------------------------------------------------------------------
// A mounting plate like Art.No. 38246, optionally without pin 
// --------------------------------------------------------------------
module plate_with_optional_pin(width = BASIC_BLOCK_SIZE, length = BASIC_BLOCK_SIZE, height = 2, with_pin = true) {
    union() {
        cube([width, length, height], center = true);
        if (with_pin == true)
            translate([0, 0, height / 2 - 0.01])
                pin();
    }
}

// --------------------------------------------------------------------
// Variation of the mounting plate, triangle 
// --------------------------------------------------------------------
module plate_triangle(width = BASIC_BLOCK_SIZE, height = 2, orientation = 0) {
    half_width = width / 2;
    translate([0, 0, -height / 2])
        rotate([0, 0, orientation * 90])
            linear_extrude(height = height)
                polygon([[-half_width, -half_width], [half_width, -half_width], [-half_width, half_width]]);
}

// --------------------------------------------------------------------
// Variation of the mounting plate, half circle 
// --------------------------------------------------------------------
module plate_half_circle(width = BASIC_BLOCK_SIZE, height = 2, orientation = 0) {
    rotate([0, 0, orientation * 90])
        union() {
            cylinder(d = width, h = height, center = true);
            translate([0, -width / 4, 0])
                cube([width, width / 2, height], center = true);
        }
}
// --------------------------------------------------------------------
// Variation of the mounting plate, quarter circle 
// --------------------------------------------------------------------
module plate_quarter_circle(width = BASIC_BLOCK_SIZE, height = 2, orientation = 0) {
    pos = (orientation == 1 ? [ width / 2, -width / 2, -height / 2] :
          (orientation == 2 ? [ width / 2,  width / 2, -height / 2] :
          (orientation == 3 ? [-width / 2,  width / 2, -height / 2] :
                              [-width / 2, -width / 2, -height / 2])));
    translate(pos) {
        intersection() {
            rotate([0, 0, orientation * 90])
                cube([width, width, height]);
            cylinder(r = width, h = height);
        }
    }
}
// --------------------------------------------------------------------
// Variation of the mounting plate, inverted quarter circle 
// --------------------------------------------------------------------
module plate_quarter_circle_inverted(width = BASIC_BLOCK_SIZE, height = 2, orientation = 0) {
    difference() {
        cube([width - 0.01, width - 0.01, height], center = true);
        translate([0,0, -0.1])
            plate_quarter_circle(width = width, height = height + 0.3, orientation = orientation);
    }
}

// -------------------------------------------------------------------------
// A complex mounting plate, configurable by a layout matrix.
// Every vector in the matrix describes one y-Column of 15x15 mounting
// plates. The following values are valid:
// 0           - no segment at this position
// 1           - segment with a pin 
// 2           - segment without pin 
// 3,4,5,6     - half circles
// 7,8,9,10    - triangle segments, diagonal half of normal segment
// 11,12,13,14 - circle segments
// 15,16,17,18 - inverted circle segments
// Play with the grid_layout to see what is possible.
// Attention: Only the 15 x 15 segment may have a pin, all others would
//            place a part of the pin in an empty area of the segment
// -------------------------------------------------------------------------
module mounting_plate(grid_layout = [[1,2,2,1],[2,2,2,2],[2,2,2,2],[1,2,2,1],], height = 2) {
    union() {
        for(i = [0 : len(grid_layout)-1]) {
            for(j = [0 : len(grid_layout[i])-1]) {
                translate([BASIC_BLOCK_SIZE*i, BASIC_BLOCK_SIZE*j, 0])
                    if (grid_layout[i][j] == 1)
                        plate_with_optional_pin(height = height);
                    else if (grid_layout[i][j] == 2)
                        plate_with_optional_pin(height = height, with_pin = false);
                    else if (grid_layout[i][j] >= 3 && grid_layout[i][j] <= 6)
                        plate_half_circle(height = height, orientation = grid_layout[i][j] - 3);
                    else if (grid_layout[i][j] >= 7 && grid_layout[i][j] <= 10)
                        plate_triangle(height = height, orientation = grid_layout[i][j] - 7);
                    else if (grid_layout[i][j] >= 11 && grid_layout[i][j] <= 14)
                        plate_quarter_circle(height = height, orientation = grid_layout[i][j] - 11);
                    else if (grid_layout[i][j] >= 15 && grid_layout[i][j] <= 18)
                        plate_quarter_circle_inverted(height = height, orientation = grid_layout[i][j] - 15);
            }
        }
    }
}

// ********************
// ** Build section: **
// ********************
module main() {
    if (PlateType == 1) {
        build_plate(Rows,Columns);
    }
    else if (PlateType == 2) {
        bottom_plate(length = Length, width = Width);
    }
    else if (PlateType == 3) {
        plate_with_holes(length = Length, width = Width, thin = Thin_Center);
    }
    else if (PlateType == 4) {
        mounting_plate(Layout);
    }
}

main();