epaper_door_case/GDEY0583T81.scad

// GDEY0583T81 mockup
//
// FPC dimensions from GDEY0583T81 mechanical drawing:
//   right edge:   55.47 mm from display right  →  69.93 mm from display left
//   stiffened section (at glass edge): 14.50 mm wide, 6.00 mm deep
//   cable section (remainder):         12.50 mm wide, 18.00 mm long
//   total extension: 24.00 mm from display Y+ face; thickness 0.30 mm
//   contact zone at tip: 11.50 mm wide × 2.50 mm deep (24 pins, 0.5 mm pitch)
//
// Optional bend parameters (all default to flat/no-bend):
//   fpc_bend_start  — mm from display Y+ face where bend begins (undef = flat)
//   fpc_bend_r      — bend radius mm (default 4.0)
//   fpc_bend_angle  — bend angle degrees (default 90; arc clip assumes ≤ 90°)
//   fpc_post_clip   — truncate post-bend segment to this length in mm (undef = full)

module GDEY0583T81(fpc_bend_start=undef, fpc_bend_r=4.0, fpc_bend_angle=90, fpc_post_clip=undef) {
    dw = 125.4;   dd = 99.5;    dt = 1.2;    // overall body
    aw = 118.78;  ad = 88.22;                 // active area
    ax = (dw - aw) / 2;                       // active area X offset (symmetric)
    ay = 3.30;                                // active area Y offset from Y- edge (per drawing)

    fpc_right   = dw - 55.47;  // FPC right edge X (= 69.93 mm from display left)
    fpc_w_wide  = 14.50;
    fpc_w_cable = 12.50;
    fpc_stiff   = 6.00;
    fpc_len     = 24.00;
    fpc_t       = 0.30;
    contact_w   = 11.50;
    contact_d   = 2.50;
    fpc_xl      = fpc_right - fpc_w_cable;   // cable left edge X

    color([0.32, 0.32, 0.32])
        cube([dw, dd, dt]);

    color([0.82, 0.82, 0.82])
        translate([ax, ay, dt - 0.01])
            cube([aw, ad, 0.1]);

    color([0.65, 0.65, 0.65]) {
        if (is_undef(fpc_bend_start)) {
            // Flat cable (no bend)
            translate([fpc_right - fpc_w_wide, dd, 0])
                cube([fpc_w_wide, fpc_stiff, fpc_t]);
            translate([fpc_xl, dd + fpc_stiff, 0])
                cube([fpc_w_cable, fpc_len - fpc_stiff, fpc_t]);
        } else {
            _bs = fpc_bend_start;

            // Pre-bend straight sections
            if (_bs > 0)
                translate([fpc_right - fpc_w_wide, dd, 0])
                    cube([fpc_w_wide, min(fpc_stiff, _bs), fpc_t]);
            if (_bs > fpc_stiff)
                translate([fpc_xl, dd + fpc_stiff, 0])
                    cube([fpc_w_cable, _bs - fpc_stiff, fpc_t]);

            // Bend arc: quarter-annular tube sweeping in YZ plane, axis along X.
            // rotate([0,90,0]) cylinder → axis X, cross-section circle in YZ at origin.
            // Clip cube (Y≥0, Z≥0) selects the quadrant from (Y=0,Z=r) to (Y=r,Z=0),
            // which is cable-entry (flat, at Z=0) to cable-exit (going -Z).
            // Arc center placed at world (fpc_xl, dd+_bs, -fpc_bend_r).
            translate([fpc_xl, dd + _bs, -fpc_bend_r])
                intersection() {
                    difference() {
                        rotate([0, 90, 0])
                            cylinder(r=fpc_bend_r + fpc_t, h=fpc_w_cable, $fn=32);
                        rotate([0, 90, 0])
                            cylinder(r=fpc_bend_r, h=fpc_w_cable, $fn=32);
                    }
                    cube([fpc_w_cable, fpc_bend_r + fpc_t + 1, fpc_bend_r + fpc_t + 1]);
                }

            // Post-bend straight segment: exits arc at (Y=dd+_bs+r, Z=-r), going -Z
            _arc_len   = fpc_bend_r * fpc_bend_angle * PI / 180;
            _post_len  = fpc_len - _bs - _arc_len;
            _post_show = is_undef(fpc_post_clip) ? _post_len : min(fpc_post_clip, _post_len);
            if (_post_show > 0)
                translate([fpc_xl, dd + _bs + fpc_bend_r, -fpc_bend_r - _post_show])
                    cube([fpc_w_cable, fpc_t, _post_show]);
        }
    }

    // Contact pads shown only for flat cable (position undefined after bend)
    if (is_undef(fpc_bend_start))
        color([0.80, 0.70, 0.25])
            translate([fpc_right - fpc_w_cable + (fpc_w_cable - contact_w) / 2,
                       dd + fpc_len - contact_d,
                       -0.01])
                cube([contact_w, contact_d, fpc_t + 0.02]);
}

// Standalone render — runs only when this file is opened directly, not when use<>'d
GDEY0583T81();