388 lines
17 KiB
OpenSCAD
388 lines
17 KiB
OpenSCAD
// ----------------------------------------------------------------
|
|
// 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(); |