OpenSCAD/ft-parts
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Fill the repository

Browse Source
This commit is contained in:
ingo
2026-04-05 20:11:23 +02:00
parent 0fc2818264
commit 77e17a9915
32 changed files with 163433 additions and 2 deletions
Download Patch File Download Diff File Expand all files Collapse all files
plates.scad
+388
View File
@@ -0,0 +1,388 @@
// ----------------------------------------------------------------
// 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();