bb815bcd2f
Change CutoutMargin from a diameter to a radius/single edge (cut it in half) Change OuterMargin to a more generic part margin for mating parts Derive PanelGap from CutoutMargin and OuterMargin
796 lines
22 KiB
OpenSCAD
796 lines
22 KiB
OpenSCAD
/*//////////////////////////////////////////////////////////////////
|
|
- FB Aka Heartman/Hearty 2016 -
|
|
- http://heartygfx.blogspot.com -
|
|
- OpenScad Parametric Box -
|
|
- CC BY-NC 3.0 License -
|
|
////////////////////////////////////////////////////////////////////
|
|
12/02/2016 - Fixed minor bug
|
|
28/02/2016 - Added holes ventilation option
|
|
09/03/2016 - Added PCB feet support, fixed the shell artefact on export mode.
|
|
|
|
*/////////////////////////// - Info - //////////////////////////////
|
|
|
|
// All coordinates are starting as integrated circuit pins.
|
|
// From the top view :
|
|
|
|
// CoordD <--- CoordC
|
|
// ^
|
|
// ^
|
|
// ^
|
|
// CoordA ---> CoordB
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
////////// - Paramètres de la boite - Box parameters - /////////////
|
|
|
|
/* [Box options] */
|
|
// - Epaisseur - Wall thickness
|
|
Thick = 2; //[2:5]
|
|
// - Panel thickness
|
|
PanelThick = 2;
|
|
// - Font Thickness
|
|
FontThick = 0.5;
|
|
// - Filet Radius
|
|
Filet = 2; //[0.1:12]
|
|
// - 0 for beveled, 1 for rounded
|
|
Round = 1; // [0:No, 1:Yes]
|
|
// - Printer margin around interior cutouts
|
|
CutoutMargin = 0.3;
|
|
// - Margin between mating parts
|
|
PartMargin = 0.1;
|
|
// Pieds PCB - PCB feet (x4)
|
|
PCBFeet = 1; // [0:No, 1:Yes]
|
|
// - Decorations?
|
|
Decorations = 1; // [0:No, 1:Yes]
|
|
// - Decorations to ventilation holes
|
|
Vent = 1; // [0:No, 1:Yes]
|
|
// - Decoration-Holes width (in mm)
|
|
Vent_width = 1.5;
|
|
// - Tolérance - Tolerance (Panel/rails gap)
|
|
PanelGap = CutoutMargin*2 + PartMargin*2;
|
|
|
|
|
|
/* [Box Fixation Tabs] */
|
|
// - Side screw hole (or snap) diameter
|
|
ScrewHole = 2.2606;
|
|
// Thickness of fixation tabs
|
|
TabThick = 2;
|
|
// Back left tab
|
|
BLTab = 1; // [0:Bottom, 1:Top]
|
|
// Back right tab
|
|
BRTab = 1; // [0:Bottom, 1:Top]
|
|
// Front left tab
|
|
FLTab = 1; // [0:Bottom, 1:Top]
|
|
// Front right tab
|
|
FRTab = 1; // [0:Bottom, 1:Top]
|
|
// EXPERIMENTAL: Snap tabs
|
|
SnapTabs = 0; // [0:Screws, 1:Snaps]
|
|
|
|
|
|
/* [PCB options] */
|
|
// - Longueur PCB - PCB Length
|
|
PCBLength = 80;
|
|
// - Largeur PCB - PCB Width
|
|
PCBWidth = 144;
|
|
// - Epaisseur PCB Thickness
|
|
PCBThick = 1.6;
|
|
// You likely need to maintain |Thick| margin on the left and right for tabs
|
|
// and whatnot.
|
|
// - Margin between front panel and PCB
|
|
FrontEdgeMargin = 70;
|
|
// - Margin between back panel and PCB
|
|
BackEdgeMargin = 0;
|
|
// - Margin between left wall and PCB
|
|
LeftEdgeMargin = 11;
|
|
// - Margin between right wall and PCB
|
|
RightEdgeMargin = 11;
|
|
// - Margin between top of PCB and box top.
|
|
TopPCBMargin = 84;
|
|
|
|
|
|
/* [PCB_Feet] */
|
|
// - Heuteur pied - Feet height above box interior
|
|
FootHeight = 8;
|
|
// - Diamètre pied - Foot diameter
|
|
FootDia = 8;
|
|
// - Diamètre trou - Hole diameter
|
|
FootHole = 2.2606; // tap size for #4 coarse-thread
|
|
FootFilet = FootHeight/4;
|
|
|
|
// Foot centers are specified as distance from PCB top-left corner.
|
|
// X is along the "length" axis, and Y is along the "width" axis.
|
|
// - Foot 1 distance from top PCB edge
|
|
Foot1X = 5;
|
|
// - Foot 1 distance from left edge
|
|
Foot1Y = 5;
|
|
// - Foot 2 distance from top PCB edge
|
|
Foot2X = 5;
|
|
// - Foot 2 distance from left edge
|
|
Foot2YFromEdge = 5;
|
|
Foot2Y = PCBWidth - Foot2YFromEdge;
|
|
// - Foot 3 distance from top PCB edge
|
|
Foot3XFromEdge = 5;
|
|
Foot3X = PCBLength - Foot3XFromEdge;
|
|
// - Foot 3 distance from left edge
|
|
Foot3Y = 5;
|
|
// - Foot 4 distance from top PCB edge
|
|
Foot4XFromEdge = 5;
|
|
Foot4X = PCBLength - Foot4XFromEdge;
|
|
// - Foot 4 distance from left edge
|
|
Foot4YFromEdge = 5;
|
|
Foot4Y = PCBWidth - Foot4YFromEdge;
|
|
|
|
|
|
/* [STL element to export] */
|
|
//Coque haut - Top shell
|
|
TShell = 0; // [0:No, 1:Yes]
|
|
//Coque bas- Bottom shell
|
|
BShell = 1; // [0:No, 1:Yes]
|
|
//Panneau avant - Front panel
|
|
FPanL = 1; // [0:No, 1:Yes]
|
|
//Panneau arrière - Back panel
|
|
BPanL = 1; // [0:No, 1:Yes]
|
|
|
|
|
|
/* [Hidden] */
|
|
// - Couleur coque - Shell color
|
|
Couleur1 = "Orange";
|
|
// - Couleur panneaux - Panels color
|
|
Couleur2 = "OrangeRed";
|
|
// - Text colors
|
|
TextColor = "White";
|
|
// - making decorations thicker if it is a vent to make sure they go through shell
|
|
// Add a small number to Thick in case Filet is 0.
|
|
Dec_Thick = Vent ? Thick*1.001 + Filet : Thick/2;
|
|
// Separate vents with a square pillar by default.
|
|
Dec_Spacing = Thick + Vent_width;
|
|
// X offset to center of first vent
|
|
Dec_Offset = Thick*2 + PanelThick + PanelGap + Dec_Spacing - Vent_width/2;
|
|
|
|
// Resolution based on Round parameter
|
|
Resolution = Round ? 100: 4;
|
|
|
|
// Calculate box dimensions from PCB.
|
|
TopMargin = PCBThick + TopPCBMargin;
|
|
Length = PCBLength + FrontEdgeMargin + BackEdgeMargin + ((Thick + PanelThick + PanelGap)*2);
|
|
Width = PCBWidth + LeftEdgeMargin + RightEdgeMargin + Thick*2;
|
|
Height = FootHeight + TopMargin + Thick*2;
|
|
echo("Box: ", Length=Length, Width=Width, Height=Height);
|
|
// X position inset of mounting holes and tabs
|
|
MountInset = Thick*3 + PanelThick + PanelGap + ScrewHole*4;
|
|
|
|
// Calculate panel dimensions from box dimensions.
|
|
PanelWidth = Width - Thick*2 - PanelGap;
|
|
PanelHeight = Height - Thick*2 - PanelGap;
|
|
|
|
|
|
/* Panel Manager
|
|
|
|
Use the below 4 modules to produce holes and text on the front and back panels.
|
|
The holes modules should contain instances of SquareHole or CylinderHole
|
|
defined later in this file. The text modules should contain instances of
|
|
LText or CText defined later in this file. It is recommended to use variables
|
|
that you define for your needs to create the size and positions of these
|
|
objects.
|
|
*/
|
|
|
|
// Calculate board-relative positions with respect to the panel, for
|
|
// convenience in placing panel elements.
|
|
TopOfBoardWRTPanel = FootHeight + PCBThick - (PanelGap/2);
|
|
LeftEdgeOfBoardWRTFPanel = LeftEdgeMargin - (PanelGap/2);
|
|
LeftEdgeOfBoardWRTBPanel = RightEdgeMargin - (PanelGap/2);
|
|
|
|
|
|
// Holes for front panel
|
|
module FPanelHoles() {
|
|
// SquareHole(On/Off, Xpos,Ypos,Length,Width,Filet)
|
|
SquareHole(1, 20, 20, 15, 10, 1);
|
|
SquareHole(1, 40, 20, 15, 10, 1);
|
|
SquareHole(1, 60, 20, 15, 10, 1);
|
|
// CylinderHole(On/Off, Xpos, Ypos, Diameter)
|
|
CylinderHole(1, 27, 40, 8);
|
|
CylinderHole(1, 47, 40, 8);
|
|
CylinderHole(1, 67, 40, 8);
|
|
SquareHole(1, 20, 50, 80, 30, 3);
|
|
CylinderHole(1, 93, 30, 10);
|
|
SquareHole(1, 120, 20, 30, 60, 3);
|
|
}
|
|
|
|
|
|
// Text for front panel
|
|
module FPanelText() {
|
|
// LText(On/Off, Xpos, Ypos, "Font", Size, "Text", "HAlign", "VAlign")
|
|
LText(1, 20, 83, "Arial Black", 4, "Digital Screen", HAlign="left");
|
|
LText(1, 120, 83, "Arial Black", 4, "Level", HAlign="left");
|
|
LText(1, 20, 11, "Arial Black", 6, " 1 2 3", HAlign="left");
|
|
// CText(On/Off, Xpos, Ypos, "Font", Size, Diameter, Arc(Deg), Starting Angle(Deg),"Text")
|
|
CText(1, 93, 29, "Arial Black", 4, 10, 180, 0,
|
|
["1", "." , "3", "." , "5", "." , "7", "." , "9", "." , "11"]);
|
|
}
|
|
|
|
|
|
// Holes for back panel
|
|
module BPanelHoles() {
|
|
CylinderHole(1,
|
|
LeftEdgeOfBoardWRTBPanel + 16.4,
|
|
TopOfBoardWRTPanel + 7,
|
|
5 + PartMargin*2);
|
|
SquareHole(1,
|
|
LeftEdgeOfBoardWRTBPanel + 37.3,
|
|
TopOfBoardWRTPanel,
|
|
39.2,
|
|
12.55,
|
|
1);
|
|
}
|
|
|
|
|
|
// Text for back panel
|
|
module BPanelText() {
|
|
LText(1,
|
|
LeftEdgeOfBoardWRTBPanel + 16.4,
|
|
TopOfBoardWRTPanel + 7 + 5,
|
|
"Arial Black",
|
|
4, "PWR"
|
|
);
|
|
LText(1,
|
|
LeftEdgeOfBoardWRTBPanel + 37.3 + 39.2/2,
|
|
TopOfBoardWRTPanel + 12.55 + 2,
|
|
"Arial Black",
|
|
4,
|
|
"DATA"
|
|
);
|
|
}
|
|
|
|
|
|
/* Generic rounded box
|
|
|
|
Produces a box of the specified dimensions. Corners are rounded according to
|
|
Filet and Resolution parameters.
|
|
|
|
Arguments:
|
|
xshrink: the amount to reduce the length on one end compared to the full length
|
|
yzshrink: the amount to reduce the width or height on one edge compared to the full box
|
|
*/
|
|
module RoundBox(xshrink=0, yzshrink=0) {
|
|
Filet = (Filet > Thick*2) ? Filet - yzshrink : Filet;
|
|
translate([xshrink, yzshrink, yzshrink]) {
|
|
rotate([90, 0, 90]) {
|
|
linear_extrude(height=Length - xshrink*2) {
|
|
translate([Filet, Filet, 0]) {
|
|
offset(r=Filet, $fn=Resolution) {
|
|
square([Width - 2*yzshrink - 2*Filet, Height - 2*yzshrink - 2*Filet]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/* MainBox: Main box module
|
|
|
|
This module produces the simple main box half. No feet, tabs, vents or fixation
|
|
is applied here.
|
|
*/
|
|
module MainBox() {
|
|
difference() {
|
|
union() {
|
|
// Makes a hollow box with walls of Thick thickness.
|
|
difference() {
|
|
RoundBox();
|
|
RoundBox(xshrink=Thick, yzshrink=Thick);
|
|
}
|
|
// Makes interior backing for panel as a wall
|
|
difference() {
|
|
RoundBox(xshrink=(Thick + PanelThick + PanelGap), yzshrink=Thick/2);
|
|
RoundBox(xshrink=(Thick*2 + PanelThick + PanelGap));
|
|
}
|
|
}
|
|
// Remove the top half
|
|
translate([-Thick, -Thick, Height/2]) {
|
|
cube([Length + Thick*2, Width + Thick*2, Height]);
|
|
}
|
|
// Remove the center for panel visibility.
|
|
RoundBox(xshrink=-Thick, yzshrink=Thick*2);
|
|
}
|
|
}
|
|
|
|
|
|
/* decoration: a single box decoration
|
|
*/
|
|
module decoration() {
|
|
translate([-Vent_width/2, -Thick, -Thick]) {
|
|
cube([Vent_width, Dec_Thick + Thick, Height/4 + Thick]);
|
|
}
|
|
}
|
|
|
|
|
|
/* LeftDecorations: left decorations module
|
|
|
|
Produces the decorations/vents for just the left side of the box.
|
|
These can be rotated and translated for the right side.
|
|
*/
|
|
module LeftDecorations() {
|
|
for (i=[0 : Dec_Spacing : Length/4]) {
|
|
translate([Dec_Offset + i, 0, 0]) {
|
|
decoration();
|
|
}
|
|
translate([Length - Dec_Offset - i, 0, 0]) {
|
|
decoration();
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/* Decorations: decorations module
|
|
|
|
This module produces the box vents or decorations.
|
|
*/
|
|
module Decorations() {
|
|
LeftDecorations();
|
|
// Mirror for the right side decorations
|
|
translate([0, Width, 0]) {
|
|
mirror([0, 1, 0]) {
|
|
LeftDecorations();
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/* Coque: Shell module
|
|
|
|
This module takes no arguments, but produces a box shell. This is half the box,
|
|
including slots for end panels, rounded corners according to Filet and Resolution,
|
|
and vents/decorations according to parameters.
|
|
*/
|
|
module Coque() { //Coque - Shell
|
|
color(Couleur1) {
|
|
difference() {
|
|
MainBox();
|
|
if (Decorations == 1) {
|
|
Decorations();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/* tab: tab module
|
|
|
|
Produces a single box fixation tab with screw hole or snap button
|
|
*/
|
|
module tab() {
|
|
translate([0, Thick, Height/2]) {
|
|
rotate([90, 0, 180]) {
|
|
difference() {
|
|
linear_extrude(TabThick) {
|
|
difference() {
|
|
circle(r=4*ScrewHole, $fn=6);
|
|
if (!SnapTabs) {
|
|
translate([0, ScrewHole*2, 0]) {
|
|
circle(d=ScrewHole, $fn=100);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
translate([-4*ScrewHole, -ScrewHole, TabThick]) {
|
|
rotate([90+45, 0, 0]) {
|
|
cube([8*ScrewHole, 3*ScrewHole, 5*ScrewHole]);
|
|
}
|
|
}
|
|
translate([-4*ScrewHole, 0, -PartMargin]) {
|
|
cube([8*ScrewHole,4*ScrewHole,PartMargin*2]);
|
|
}
|
|
}
|
|
if (SnapTabs) {
|
|
translate([0, ScrewHole*2, PartMargin]) {
|
|
difference() {
|
|
sphere(d=ScrewHole, $fn=100);
|
|
translate([0, 0, ScrewHole*.75]) {
|
|
cube(ScrewHole, center=true);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/* Tabs: tabs module
|
|
|
|
This module produces the wall fixation box tabs.
|
|
Tabs are produced according to the parameters for XXTab indicating top or bottom.
|
|
|
|
Arguments:
|
|
top: 0 for bottom shell tabs. 1 for top shell tabs. defaults to bottom.
|
|
*/
|
|
module Tabs(top=0) {
|
|
color(Couleur1) {
|
|
if (BLTab == top) {
|
|
translate([MountInset, 0, 0]) {
|
|
tab();
|
|
}
|
|
}
|
|
if (FLTab == top) {
|
|
translate([Length - MountInset, 0, 0]) {
|
|
tab();
|
|
}
|
|
}
|
|
if (BRTab == top) {
|
|
translate([MountInset, Width, 0]) {
|
|
rotate([0, 0, 180]) {
|
|
tab();
|
|
}
|
|
}
|
|
}
|
|
if (FRTab == top) {
|
|
translate([Length - MountInset, Width, 0]) {
|
|
rotate([0, 0, 180]) {
|
|
tab();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/* hole: hole module
|
|
|
|
Produces a box hole for fixation. This is either a cylinder for a screw
|
|
or a semispherical indention for snap tabs.
|
|
*/
|
|
module hole() {
|
|
if (SnapTabs) {
|
|
translate([0, -Thick, Height/2 - 2*ScrewHole]) {
|
|
sphere(d=ScrewHole, $fn=100);
|
|
}
|
|
}
|
|
else {
|
|
translate([0, Thick, Height/2 - 2*ScrewHole]) {
|
|
rotate([90, 0, 0]) {
|
|
cylinder(Thick*3, d=ScrewHole, $fn=100);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/* Holes: holes module
|
|
|
|
This module produces the holes necessary in the box fixation tabs and in the wall
|
|
of the box for the corresponding tabs to affix to.
|
|
Holes are produced according to the parameters for XXTab indicating top or bottom.
|
|
|
|
Arguments:
|
|
top: 0 for bottom shell holes. 1 for top shell holes. defaults to bottom.
|
|
*/
|
|
module Holes(top=0) {
|
|
color(Couleur1) {
|
|
if (BRTab != top) {
|
|
translate([MountInset, Width, 0]) {
|
|
hole();
|
|
}
|
|
}
|
|
if (FRTab != top) {
|
|
translate([Length - MountInset, Width, 0]) {
|
|
hole();
|
|
}
|
|
}
|
|
if (BLTab != top) {
|
|
translate([MountInset, 0, 0]) {
|
|
rotate([0, 0, 180]) {
|
|
hole();
|
|
}
|
|
}
|
|
}
|
|
if (FLTab != top) {
|
|
translate([Length - MountInset, 0, 0]) {
|
|
rotate([0, 0, 180]) {
|
|
hole();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/* foot module
|
|
|
|
Produces a single foot for PCB mounting.
|
|
*/
|
|
module foot() {
|
|
color(Couleur1) {
|
|
rotate_extrude($fn=100) {
|
|
difference() {
|
|
translate([FootHole/2, 0, 0]) {
|
|
square([(FootDia - FootHole)/2 + FootFilet, FootHeight]);
|
|
}
|
|
translate([FootDia/2 + FootFilet, FootFilet, 0]) {
|
|
offset(r=FootFilet, $fn=Resolution) {
|
|
square(FootHeight);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/* Feet module
|
|
|
|
Combines four feet to form mounting platform for PCB.
|
|
A model of the PCB is included with the background modifier. It is translucent
|
|
but visible in the preview, but not in the final render.
|
|
|
|
No arguments are used, but parameters provide the PCB and foot dimensions.
|
|
*/
|
|
module Feet() {
|
|
translate([BackEdgeMargin + Thick + PanelThick + PanelGap, LeftEdgeMargin + Thick, Thick]) {
|
|
/////////////// - PCB only visible in the preview mode - ///////////////
|
|
%translate([0, 0, FootHeight]) {
|
|
cube([PCBLength, PCBWidth, PCBThick]);
|
|
translate([PCBLength/2, PCBWidth/2, PCBThick]) {
|
|
color("Olive") {
|
|
linear_extrude(height=FontThick) {
|
|
text("PCB", font="Arial black", halign="center", valign="center");
|
|
}
|
|
}
|
|
}
|
|
} // Fin PCB
|
|
|
|
////////////////////////////// - 4 Feet - //////////////////////////////
|
|
translate([Foot1X, Foot1Y]) {
|
|
foot();
|
|
}
|
|
translate([Foot2X, Foot2Y]) {
|
|
foot();
|
|
}
|
|
translate([Foot3X, Foot3Y]) {
|
|
foot();
|
|
}
|
|
translate([Foot4X, Foot4Y]) {
|
|
foot();
|
|
}
|
|
} // End main translate
|
|
} // Fin du module Feet
|
|
|
|
|
|
/* TopShell: top shell module
|
|
|
|
Produces the top shell, including requested fixation tabs and holes
|
|
Model is rotated and translated to the appropriate position.
|
|
*/
|
|
module TopShell() {
|
|
translate([0, 0, Height + 0.2]) {
|
|
mirror([0, 0, 1]) {
|
|
difference() {
|
|
union() {
|
|
Coque();
|
|
Tabs(top=1);
|
|
}
|
|
Holes(top=1);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/* BottomShell: bottom shell module
|
|
|
|
Produces the bottom shell, including requested fixation tabs, holes,
|
|
and PCB feet.
|
|
*/
|
|
module BottomShell() {
|
|
difference() {
|
|
union() {
|
|
Coque();
|
|
Tabs();
|
|
if (PCBFeet == 1) {
|
|
Feet();
|
|
}
|
|
}
|
|
Holes();
|
|
}
|
|
}
|
|
|
|
|
|
/* Panel module
|
|
|
|
Produces a single panel with potentially rounded corners. Takes no arguments
|
|
but uses the global parameters.
|
|
*/
|
|
module Panel() {
|
|
Filet = (Filet > Thick*2) ? Filet - Thick - PanelGap/2 : Filet - PanelGap/2;
|
|
echo("Panel:", Thick=PanelThick, PanelWidth=PanelWidth, PanelHeight=PanelHeight, Filet=Filet);
|
|
translate([Filet, Filet, 0]) {
|
|
offset(r=Filet, $fn=Resolution) {
|
|
square([PanelWidth - Filet*2, PanelHeight - Filet*2]);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/* Cylinder Hole module
|
|
|
|
Produces a cylinder for use as a holein a panel
|
|
|
|
Arguments:
|
|
OnOff: Rendered only if 1
|
|
Cx: X position of hole center
|
|
Cy: Y position of hole center
|
|
Cdia: diameter of hole
|
|
*/
|
|
module CylinderHole(OnOff, Cx, Cy, Cdia) {
|
|
if (OnOff == 1) {
|
|
echo("CylinderHole:", Cx=Cx, Cy=Cy, Cdia=Cdia + CutoutMargin*2);
|
|
translate([Cx, Cy, 0]) {
|
|
circle(d=Cdia + CutoutMargin*2, $fn=100);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/* Square Hole module
|
|
|
|
Produces a rectangular prism with potentially rounded corner for use as a hole in a panel
|
|
|
|
Arguments:
|
|
OnOff: Rendered only if 1
|
|
Sx: X position of bottom left corner
|
|
Sy: Y position of bottom left corner
|
|
Sl: width of rectangle
|
|
Sw: height of rectangle
|
|
Filet: radius of rounded corner
|
|
*/
|
|
module SquareHole(OnOff, Sx, Sy, Sl, Sw, Filet) {
|
|
if (OnOff == 1) {
|
|
echo("SquareHole:", Sx=Sx - CutoutMargin, Sy=Sy - CutoutMargin,
|
|
Sl=Sl + CutoutMargin*2, Sw=Sw + CutoutMargin*2, Filet=Filet);
|
|
translate([Sx + Filet - CutoutMargin, Sy + Filet - CutoutMargin, 0]) {
|
|
offset(r=Filet, $fn=Resolution) {
|
|
square([Sl + CutoutMargin*2 - Filet*2, Sw + CutoutMargin*2 - Filet*2]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/* LText module
|
|
|
|
Produces linear text for use on a panel
|
|
|
|
Arguments:
|
|
OnOff: Rendered only if 1
|
|
Tx: X position of bottom left corner of text
|
|
Ty: Y position of bottom left corner of text
|
|
Font: Font to use for text
|
|
Size: Approximate Height of text in mm.
|
|
Content: The text
|
|
HAlign: Text horizontal alignment. Defaults to "center". "left" and "right" available.
|
|
VAlign: Text vertical alignment. Defaults to "baseline". "top", "center", and "bottom" available.
|
|
*/
|
|
module LText(OnOff,Tx,Ty,Font,Size,Content, HAlign="center", VAlign="baseline") {
|
|
if (OnOff == 1) {
|
|
echo("LText:", Tx=Tx, Ty=Ty, Font=Font, Size=Size, Content=Content, HAlign=HAlign, VAlign=VAlign);
|
|
translate([Tx, Ty, PanelThick]) {
|
|
linear_extrude(height=FontThick) {
|
|
text(Content, size=Size, font=Font, halign=HAlign, valign=VAlign);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/* CText module
|
|
|
|
Produces circular text for a panel
|
|
|
|
OnOff:Rendered only if 1
|
|
Tx: X position of text
|
|
Ty: Y position of text
|
|
Font: Font to use for text
|
|
Size: Approximate height of text in mm
|
|
TxtRadius: Radius of text
|
|
Angl: Arc angle
|
|
Turn: Starting angle
|
|
Content: The text
|
|
*/
|
|
module CText(OnOff, Tx, Ty, Font, Size, TxtRadius, Angl, Turn, Content) {
|
|
if (OnOff == 1) {
|
|
echo("CText:", Tx=Tx, Ty=Ty, Font=Font, Size=Size,
|
|
TxtRadius=TxtRadius, Turn=Turn, Content=Content);
|
|
Angle = -Angl / (len(Content) - 1);
|
|
translate([Tx, Ty, PanelThick]) {
|
|
for (i= [0 : len(Content) - 1] ) {
|
|
rotate([0, 0, i*Angle + 90 + Turn]) {
|
|
translate([0, TxtRadius, 0]) {
|
|
linear_extrude(height=FontThick) {
|
|
text(Content[i], size=Size, font=Font, halign="center");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
////////////////////// <- New module Panel -> //////////////////////
|
|
/* FPanL module
|
|
|
|
Produces the front panel. No arguments are used, but this module must be
|
|
edited to produce holes and text for your box.
|
|
*/
|
|
module FPanL() {
|
|
translate([Length - (Thick + PanelGap/2 + PanelThick),
|
|
Thick + PanelGap/2,
|
|
Thick + PanelGap/2]) {
|
|
rotate([90, 0, 90]) {
|
|
color(Couleur2) {
|
|
linear_extrude(height=PanelThick) {
|
|
difference() {
|
|
Panel();
|
|
FPanelHoles();
|
|
}
|
|
}
|
|
}
|
|
color(TextColor) {
|
|
FPanelText();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
////////////////////// <- New module Panel -> //////////////////////
|
|
/* BPanL module
|
|
|
|
Produces the back panel. No arguments are used, but this module must be
|
|
edited to produce holes and text for your box.
|
|
*/
|
|
module BPanL() {
|
|
translate([Thick + PanelGap/2 + PanelThick,
|
|
Thick + PanelGap/2 + PanelWidth,
|
|
Thick + PanelGap/2]) {
|
|
rotate([90, 0, 270]) {
|
|
color(Couleur2) {
|
|
linear_extrude(height=PanelThick) {
|
|
difference() {
|
|
Panel();
|
|
BPanelHoles();
|
|
}
|
|
}
|
|
}
|
|
color(TextColor) {
|
|
BPanelText();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/////////////////////////// <- Main part -> /////////////////////////
|
|
|
|
if (TShell == 1) {
|
|
// Coque haut - Top Shell
|
|
TopShell();
|
|
}
|
|
|
|
if (BShell == 1) {
|
|
// Coque bas - Bottom shell
|
|
BottomShell();
|
|
}
|
|
|
|
// Panneau avant - Front panel
|
|
if (FPanL == 1) {
|
|
FPanL();
|
|
}
|
|
|
|
//Panneau arrière - Back panel
|
|
if (BPanL == 1) {
|
|
BPanL();
|
|
}
|