catch_latch.scad

Go to the documentation of this file.

//! A catch latch generator.
/***************************************************************************//**
  \file
  \author Roy Allen Sutton
  \date   2025
 
  \copyright
 
    This file is part of [omdl] (https://github.com/royasutton/omdl),
    an OpenSCAD mechanical design library.
 
    The \em omdl is free software; you can redistribute it and/or modify
    it under the terms of the [GNU Lesser General Public License]
    (http://www.gnu.org/licenses/lgpl.html) as published by the Free
    Software Foundation; either version 2.1 of the License, or (at
    your option) any later version.
 
    The \em omdl is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Lesser General Public License for more details.
 
    You should have received a copy of the GNU Lesser General Public
    License along with the \em omdl; if not, write to the Free Software
    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
    02110-1301, USA; or see <http://www.gnu.org/licenses/>.
 
  \details
 
    \amu_define group_name  (Catch latch)
    \amu_define group_brief (Catch latch generator.)
 
  \amu_include (include/amu/pgid_path_pstem_pg.amu)
*******************************************************************************/
 
//----------------------------------------------------------------------------//
// group and macros.
//----------------------------------------------------------------------------//
 
/***************************************************************************//**
  \amu_include (include/amu/group_in_parent_start.amu)
  \amu_define includes_required_add
  (
    models/3d/fastener/screws.scad
  )
  \amu_include (include/amu/includes_required.amu)
*******************************************************************************/
 
//----------------------------------------------------------------------------//
 
//! A catch latch generator with configurable profile.
/***************************************************************************//**
  \param  size    <decimal-list-6 | decimal> latch size;
                  a list [px, py, pz, bx, by, bz], the latch profile
                  and base-mount dimensions, or a single decimal px and
                  the remainder using predefined scaling of px.
 
  \param  screw   <decimal-list-5 | decimal> mount screw hole
                  specifications; a list [d, t, h, r, b], the
                  hole-diameter, tolerance, head-diameter,
                  recess-height, bevel-height, or a single decimal for
                  the hole diameter.
 
  \param  latch   <integer-list-1 | integer> latch; the latch type;
                  {1=no mount, 2=vertical mount, 3=horizontal mount}.
 
  \param  catch   <integer, decimal, decimal> | integer> catch; a list
                  [t, h, g], the catch type, thickness, and gap, or a
                  single decimal t for the catch type; {1=no mount,
                  2=vertical mount, 3=horizontal mount}.
 
  \param  profile <datastruct> latch profile (see below).
 
  \param  align   <integer-list-3> object alignment; a list [x, y, z],
                  the latch or catch alignment. Available alignment
                  options depends on the object and its mount-type.
 
  \param  verb    <integer> console output verbosity {0=quiet, 1=info}.
 
  \details
 
    Construct a catch and/or latch. Both can be produced with or
    without a mount, that can be oriented horizontally or vertically to
    match the application. Constructs without mounts are useful for
    direct incorporation with other design parts. The bore for the
    mount is specified by the parameter \p screw and generated by
    screw_bore().
 
    ## Multi-value and structured parameters
 
    ### profile
 
    #### Data structure fields: profile
 
      e | data type         | default value     | parameter description
    ---:|:-----------------:|:-----------------:|:------------------------------------
      0 | <decimal-list-3>  | [0, 0, 0]         | \p bevel; [f, v, h]
      1 | <decimal-list-3>  | [60, 100, 10]     | \p width; [t, c, h]
      2 | <decimal-list-3>  | [20, 40, 60]      | \p length; [t, s, e]
 
      \p bevel: a list [f, v, h], the flat-height, bevel-height,
      bevel-width, specified as a percentage of the latch height.
 
      \p width: a list [t, c, h], the width of the throat, catch, head,
      specified as a percentage of the latch width.
 
      \p length: a list [t, s, e], the length of the throat-end,
      catch-start, catch-end, specified as a percentage of the latch
      length.
 
    \amu_define scope_id      (example)
    \amu_define title         (Catch latch example)
    \amu_define image_views   (top bottom diag)
    \amu_define image_size    (sxga)
 
    \amu_include (include/amu/scope_diagrams_3d.amu)
*******************************************************************************/
 
module catch_latch
(
  size = 5,
 
  screw,
 
  latch,
  catch,
 
  profile,
 
  align,
  verb = 0
)
{
  // construct latch
  module construct_latch()
  {
    extrude_linear_mss( h=bevel_mss_h )
    polygon(latch_p);
  }
 
  // construct catch
  module construct_catch()
  {
    extrude_linear_mss( h=bevel_mss_h )
    difference()
    {
      offset(r=catch_g+catch_h) polygon(latch_p);
      offset(r=catch_g) polygon(catch_p);
 
      // open mouth
      throat_w = hprofile_p[1].x*2;
 
      translate([0, -catch_h/2])
      square([ throat_w + catch_g*2 + catch_h*2, catch_h + catch_g*2], center = true);
    }
  }
 
  // construct mount
  module construct_mount(n, t)
  {
    difference()
    {
      union()
      {
        // mount
        rotate([0, 90, 0])
        extrude_linear_mss( h=mnt_dx, center=true )
        pg_rectangle(size=[size_my, size_mz], vr=pad_vr, center=true);
 
         // pad
        for( p=[-1, 1] )
        translate([p*mnt_dx/2, pad_dy/2 - size_mz/2, 0])
        extrude_linear_mss( h=size_my, center=true )
        pg_rectangle(size=[pad_dx, pad_dy], vr=mnt_vr, center=true);
      }
 
      // screw holes on both sizes of mount
      for( s=[-1, 1] )
      translate([s*mnt_dx/2, pad_dy/2 - size_mz/2, 0])
      screw_bore(d=screw_d, l=size_my+eps*8, h=[screw_h, screw_r, screw_b], t=[screw_t]);
    }
 
    if (verb > 0)
    {
      echo(strl
      ([ n, " mount, type ", t, ": screw hole diameter = ",
         screw_d, ", offset = ", mnt_dx
      ]));
    }
  }
 
  // assemble
  module assemble()
  {
    //
    // latch
    //
 
    if ( is_defined( latch ) )
    {
      if ( latch_t == 1 )
      {
        construct_latch();
      }
 
      if ( latch_t == 2 )
      {
        construct_latch();
 
        translate([0, -size_my/2, size_mz/2])
        mirror([0, 1, 0])
        rotate([90, 0, 0])
        construct_mount("latch", latch_t);
 
        // connect latch to mount
        translate([0, -size_my/4+eps*2, size_mz/2])
        extrude_linear_mss( h=size_mz, center=true )
        pg_rectangle(size=[width_t*2, size_my/2], vr=2, vrm=[0, 0, 4, 3], center=true);
      }
 
      if ( latch_t == 3 )
      {
        construct_latch();
 
        translate([0, -size_mz/2, size_my/2])
        mirror([0, 0, 1])
        rotate([180, 0, 0])
        construct_mount("latch", latch_t);
 
        // connect latch to mount
        rotate([270, 270, 270])
        extrude_rotate_tr(r=grid_coarse, ra=90)
        rotate([0, 0, 90])
        projection(cut=true)
        rotate([90, 0, 0])
        construct_latch();
      }
    }
 
    //
    // catch
    //
 
    if ( is_defined( catch ) )
    {
      if ( catch_t == 1 )
      {
        construct_catch();
      }
 
      if ( catch_t == 2 )
      {
        construct_catch();
 
        translate([0, size_my/2 + size_py + catch_g + catch_h*0, size_mz/2])
        rotate([90, 0, 0])
        construct_mount("catch", catch_t);
      }
 
      if ( catch_t == 3 )
      {
        construct_catch();
 
        difference()
        {
          translate([0, -size_mz/8 + size_py + catch_g + catch_h, size_my/2])
          construct_mount("catch", catch_t);
 
          resize([size_px+catch_g*4, size_py+catch_g*4, size_pz])
          construct_latch();
        }
      }
    }
  }
 
  //
  // global parameters
  //
 
  // latch/catch profile size: x, y, z
  size_px = defined_e_or(size, 0, size);
  size_py = defined_e_or(size, 1, size_px*5/2);
  size_pz = defined_e_or(size, 2, size_px*5/4);
 
  // latch/catch mount size: x, y, z
  size_mx = defined_e_or(size, 3, size_py*5/3);
  size_my = defined_e_or(size, 4, size_px/2);
  size_mz = defined_e_or(size, 5, size_pz);
 
  // mount screw: hole-diameter, tolerance, head-diameter, recess-height, bevel-height
  screw_d = defined_e_or(screw, 0, defined_or(screw, size_mz/3));
  screw_t = defined_e_or(screw, 1, 0);
  screw_h = defined_e_or(screw, 2, 0);
  screw_r = defined_e_or(screw, 3, 0);
  screw_b = defined_e_or(screw, 4, 0);
 
  // latch: mount-type
  latch_t = defined_e_or(latch, 0, latch);
 
  // catch: mount-type, thickness, gap
  catch_t = defined_e_or(catch, 0, catch);
  catch_h = defined_e_or(catch, 1, size_px/5);
  catch_g = defined_e_or(catch, 2, size_px/20);
 
  // latch profile
  prof_b  = defined_e_or(profile, 0, undef);
  prof_w  = defined_e_or(profile, 1, undef);
  prof_l  = defined_e_or(profile, 2, undef);
 
  // latch/catch edge bevel (percentages): v-flat, v-bevel, h-bevel
  bevel_f = defined_e_or(prof_b, 0, 0) / 100 * size_pz;
  bevel_v = defined_e_or(prof_b, 1, 0) / 100 * size_pz;
  bevel_h = defined_e_or(prof_b, 2, 0) / 100;
 
  // latch/catch profile width percentages): throat, catch, head
  width_t = defined_e_or(prof_w, 0,  60) / 100 * size_px/2;
  width_c = defined_e_or(prof_w, 1, 100) / 100 * size_px/2;
  width_h = defined_e_or(prof_w, 2,  10) / 100 * size_px/2;
 
  // latch/catch profile length (percentages): throat-end, catch-start, catch-end
  length_t = defined_e_or(prof_l, 0, 20) / 100 * size_py;
  length_s = defined_e_or(prof_l, 1, 40) / 100 * size_py;
  length_e = defined_e_or(prof_l, 2, 60) / 100 * size_py;
 
  //
  // global variables
  //
 
  // mount pad: separation, size-y, size-x, rounding(s)
  mnt_dx = size_mx - size_mz;
 
  pad_dy = max(screw_d*3, size_mz);
  pad_dx = pad_dy + screw_t;
 
  mnt_vr = pad_dy*2/5;
  pad_vr = size_my/2;
 
  // half-profile polygon points, rounding, and rounding-mode
  hprofile_p =
  [
    origin2d,                                 // base
    [width_t, 0], [width_t, length_t],        // throat; start, end
    [width_c, length_s], [width_c, length_e], // catch; start, end
    [width_h, size_py]                        // head
  ];
 
  hprofile_vr = [1/3, 1/2, 1, 1, 1/10] * size_px/2;
  hprofile_vrm = [0, 1, 1, 1, 1];
 
  // assemble full profile polygon points, rounding, and rounding-modes
  profile_p = concat( [for (i=hprofile_p) i], [for (i=reverse(hprofile_p)) [-i.x, i.y]] );
  profile_vr = concat( [for (i=hprofile_vr) i], [for (i=reverse(hprofile_vr)) i] );
  latch_vrm = concat( [for (i=hprofile_vrm) i], [for (i=reverse(hprofile_vrm)) i] );
 
  // flare-out catch mouth; replace first and last rounding elements of latch
  catch_vrm = concat( headn(concat( [3], tailn(latch_vrm))), [4] );
 
  // rounded polygon points for latch and catch
  latch_p = polygon_round_eve_all_p(c=profile_p, vr=profile_vr, vrm=latch_vrm);
  catch_p = polygon_round_eve_all_p(c=profile_p, vr=profile_vr, vrm=catch_vrm);
 
  // mss extrusion for bevels
  bevel_mss_h =
    let( h1 = bevel_f, h2 = bevel_v, s  = 1 - bevel_h )
    [ [h1, [s, s]], [h2, [s, 1]], size_pz - (h1 + h2)*2, [h2, [1, s]], [h1, [s, s]] ];
 
  //
  // orientation and alignment configuration
  //
  oaa = let
        (
          idl = is_defined(latch), idc = is_defined(catch),
           tl = latch_t, tc = catch_t,
 
          // repeating values and configurations
          v01 = catch_g+catch_h,
          v02 = +size_mz/8-size_py-v01,
 
          c01 = [ [0,0,0], [0,0,0], [ [0],[0],[0] ] ],
          c02 = [0, +mnt_dx/2+pad_dx/2, +mnt_dx/2, -mnt_dx/2, -mnt_dx/2-pad_dx/2],
          c03 = [0, -size_pz/2, -size_pz, -pad_dy/2, -pad_dy],
          c04 = [0, -size_my/2, -size_my, -size_pz/2, -size_pz]
        )
        !idc && idl ? // latch only
        (
            (tl == 1) ? [ [0, 0, 0], [0, 0, 0],
                          [ [0, -width_t, +width_t],
                            [0, -size_py/2, -size_py],
                            [0, -size_pz/2, -size_pz] ] ]
          : (tl == 2) ? [ [0, 0, 0], [0, +size_my, 0],
                          [ c02,
                            [0, -size_my, -size_py/2-size_my, -size_py-size_my],
                            c03 ] ]
          : (tl == 3) ? [ [0, 0, 0], [0, +pad_dy, 0],
                          [ c02,
                            [0, -pad_dy/2, -pad_dy, -size_py/2-pad_dy, -size_py-pad_dy],
                            c04 ] ]
          : c01
        )
      : idc && !idl ? // catch only
        (
            (tc == 1) ? [ [0, 0, 180], [0, +size_py+v01, 0],
                          [ [0, +size_px/2+v01, -size_px/2-v01],
                            [0, -catch_h, -size_py/2-catch_h, -size_py-catch_h],
                            [0, -size_pz/2, -size_pz] ] ]
          : (tc == 2) ? [ [0, 0, 180], [0, +size_py+catch_g+size_my, 0],
                          [ c02,
                            [0, -size_my, -size_py/2-size_my-catch_g, -size_py-size_my],
                            c03 ] ]
          : (tc == 3) ? [ [0, 0, 180], [0, pad_dy/2-v02, 0],
                          [ c02,
                            [0, -pad_dy/2, -pad_dy, v02-pad_dy/2+size_py/2, v02-pad_dy/2],
                            c04 ] ]
          : c01
        )
      : idc && idl ?  // both latch and catch
        (
          [ [0, 0, 0], [0, 0, 0],
            [ c02,
              [ 0,
                -size_py/2, +v02/2+pad_dy/4,
                -size_py-catch_g, +size_my, -size_py-catch_g-size_my,
                +pad_dy, +pad_dy/2, +v02+pad_dy/2, +v02, +v02-pad_dy/2
              ],
              concat(c03, [-size_my]) ]
          ]
        )
      : c01; // neither
 
  align_x = select_ci ( third(oaa).x, defined_e_or(align, 0, 0), false );
  align_y = select_ci ( third(oaa).y, defined_e_or(align, 1, 0), false );
  align_z = select_ci ( third(oaa).z, defined_e_or(align, 2, 0), false );
 
  //
  // object assembly
  //
 
  translate(second(oaa) + [align_x, align_y, align_z])
  rotate(first(oaa))
  assemble();
}
 
//! @}
//! @}
 
 
//----------------------------------------------------------------------------//
// openscad-amu auxiliary scripts
//----------------------------------------------------------------------------//
 
/*
BEGIN_SCOPE example;
  BEGIN_OPENSCAD;
    include <omdl-base.scad>;
    include <models/3d/fastener/screws.scad>;
    include <parts/3d/fastener/catch_latch.scad>;
 
    s = 10;
    p = [10, 25, 10];
    c = [5, 4, 10, 2, 1] * s/10;
 
    catch_latch(latch=2, size=s, profile=[p], screw=c);
 
    translate([0, s*7, 0]) rotate([0, 0, 180])
    catch_latch(catch=3, size=s, profile=[p], screw=c);
 
    // end_include
  END_OPENSCAD;
 
  BEGIN_MFSCRIPT;
    include --path "${INCLUDE_PATH}" {var_init,var_gen_png2eps}.mfs;
    table_unset_all sizes;
 
    images    name "sizes" types "sxga";
    views     name "views" views "top bottom diag";
 
    variables set_opts_combine "sizes views";
    variables add_opts "--viewall --autocenter --view=axes";
 
    include --path "${INCLUDE_PATH}" scr_make_mf.mfs;
  END_MFSCRIPT;
END_SCOPE;
*/
 
//----------------------------------------------------------------------------//
// end of file
//----------------------------------------------------------------------------//