pads.js

// Author: @infused-kim
//
// Description:
// Let's you place solder pads on the PCB that can be used instead of
// connectors. Useful for batteries and other peripherals in case the end-user
// does not have the right cable connector.
//
// Fully reversible and pads are mirrored on the back side.

module.exports = {
    params: {
        designator: 'PAD',
        side: 'F',
        reverse: true,
        width: 1.25,
        height: 2.5,
        space: 2,
        mirror: true,
        pads: 2,
        net_1: {type: 'net', value: 'PAD_1'},
        net_2: {type: 'net', value: 'PAD_2'},
        net_3: {type: 'net', value: 'PAD_3'},
        net_4: {type: 'net', value: 'PAD_4'},
        net_5: {type: 'net', value: 'PAD_5'},
        net_6: {type: 'net', value: 'PAD_5'},
        label_1: '',
        label_2: '',
        label_3: '',
        label_4: '',
        label_5: '',
        label_6: '',
        label_at_bottom: false,
      },
    body: p => {

        const gen_nets = (p) => {
          const all_nets = [
            p.net_1.str, p.net_2.str, p.net_3.str,
            p.net_4.str, p.net_5.str, p.net_6.str,
          ];
          const all_labels = [
            p.label_1, p.label_2, p.label_3,
            p.label_4, p.label_5, p.label_6,
          ];

          pad_cnt = p.pads;
          if(pad_cnt > all_nets.length || pad_cnt > all_labels.length) {
            pad_cnt = Math.min(all_nets.length, all_labels.length);
          }

          let nets = [];
          for(let i = 0; i < pad_cnt; i++) {
            let net = [
              all_nets[i],
              all_labels[i],
            ];
            nets.push(net);
          }

          return nets;
        }

        const gen_pad = (pad_idx, pad_cnt, net_str, net_label, width, height, space, rot, layer, label_at_bottom) =>
        {
            // Calculate the pad position from center
            const pos_x_raw = (width + space) * pad_idx;

            // Adjust it so that the pads are centered in the middle
            const pos_x = (
              pos_x_raw - (width + space) * (pad_cnt - 1) / 2
            );

            let label_pos_y = -1 * (height / 2 + 0.2);
            let label_justify_direction = "left";
            if(label_at_bottom) {
              label_pos_y = label_pos_y * -1;
              label_justify_direction = "right";
            }

            if(label_at_bottom == false || layer == 'B') {
              if((rot > 0 && rot <= 180) || (rot <= -180)) {
                label_justify_direction = "right";
              } else {
                label_justify_direction = "left";
              }
            } else {
              if((rot > 0 && rot <= 180) || (rot <= -180)) {
                label_justify_direction = "left";
              } else {
                label_justify_direction = "right";
              }
            }

            let justify_mirror = '';
            if(layer == 'B') {
              justify_mirror = 'mirror'
            }

            let label_justify = '';
            if(justify_mirror != '' || label_justify_direction != '') {
              label_justify = `(justify ${label_justify_direction} ${justify_mirror})`;
            }

            let pad = `
                (pad ${pad_idx + 1} smd rect (at ${pos_x} 0 ${rot}) (size ${width} ${height}) (layers ${layer}.Cu ${layer}.Paste ${layer}.Mask) ${net_str})
            `

            if(net_label) {
              pad += `
                (fp_text user "${net_label}" (at ${pos_x} ${label_pos_y} ${90 + rot}) (layer ${layer}.SilkS)
                  (effects (font (size 1 1) (thickness 0.1)) ${label_justify})
                )
              `
            }

            return pad;
        }

        const gen_pads = (nets, width, height, space, rot, layer, label_at_bottom, mirror) => {

            if(mirror) {
                nets = nets.slice().reverse();
            }

            let pads = '';
            for (let [net_idx, net] of nets.entries()) {

                const net_str = net[0];
                const net_label = net[1];

                const pad = gen_pad(
                  net_idx,
                  nets.length,
                  net_str,
                  net_label,
                  width,
                  height,
                  space,
                  rot,
                  layer,
                  label_at_bottom,
                );

                pads += pad;
            }

            return pads;
        }

        const nets = gen_nets(p);

        let pads_front = '';
        if(p.side == 'F' || p.reverse) {
          pads_front = gen_pads(
            nets,
            p.width, p.height, p.space, p.rot, "F",
            p.label_at_bottom, false,
          );
        }

        let pads_back = '';
        if(p.side == 'B' || p.reverse) {
          pads_back = gen_pads(
            nets,
            p.width, p.height, p.space, p.rot, "B",
            p.label_at_bottom, p.mirror,
          );
        }
        const fp = `
          (module pads (layer F.Cu) (tedit 6446BF3D)
            ${p.at /* parametric position */}
            (attr smd)

            (fp_text reference "${p.ref}" (at 0 2.2) (layer F.SilkS) ${p.ref_hide}
              (effects (font (size 1 1) (thickness 0.15)))
            )
            ${pads_front}
            ${pads_back}
          )
        `

        return fp;
    }
}