@tscircuit/footprinter 0.0.20 → 0.0.22

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tscircuit/footprinter",
   "type": "module",
-  "version": "0.0.20",
+  "version": "0.0.22",
   "description": "",
   "main": "dist/index.cjs",
   "scripts": {

package/src/fn/qfn.ts

@@ -0,0 +1,10 @@
+import type { AnySoupElement } from "@tscircuit/soup"
+import { base_quad_def, quad, quad_def, quadTransform } from "./quad"
+import type { z } from "zod"
+
+export const qfn_def = base_quad_def.extend({}).transform(quadTransform)
+
+export const qfn = (params: z.input<typeof qfn_def>): AnySoupElement[] => {
+  params.legsoutside = false
+  return quad(params)
+}

package/src/fn/qfp.ts

@@ -0,0 +1,19 @@
+import type { AnySoupElement } from "@tscircuit/soup"
+import { quad, quad_def } from "./quad"
+import type { z } from "zod"
+
+export const qfp_def = quad_def
+
+export const qfp = (raw_params: z.input<typeof quad_def>): AnySoupElement[] => {
+  raw_params.legsoutside = true
+
+  const quad_defaults = quad_def.parse(raw_params)
+
+  if (!raw_params.pl) {
+    // SLOP - eyeballing typical pad width:pad length ratio
+    raw_params.pl = quad_defaults.pl * 4
+    raw_params.pw = quad_defaults.pw
+  }
+
+  return quad(raw_params)
+}

package/src/fn/quad.ts

@@ -7,8 +7,7 @@ import { pin_order_specifier } from "src/helpers/zod/pin-order-specifier"
 import { getQuadPinMap } from "src/helpers/get-quad-pin-map"
 import { dim2d } from "src/helpers/zod/dim-2d"
 
-const base_quad_def = z.object({
-  quad: z.literal(true),
+export const base_quad_def = z.object({
   cc: z.literal(true).optional(),
   ccw: z.literal(true).optional(),
   startingpin: z
@@ -24,9 +23,12 @@ const base_quad_def = z.object({
   pw: length.optional(),
   pl: length.optional(),
   thermalpad: z.union([z.literal(true), dim2d]).optional(),
+  legsoutside: z.boolean().optional(),
 })
 
-const quad_def = base_quad_def.transform((v) => {
+export const quadTransform = <T extends z.infer<typeof base_quad_def>>(
+  v: T
+) => {
   if (v.w && !v.h) {
     v.h = v.w
   } else if (!v.w && v.h) {
@@ -55,20 +57,24 @@ const quad_def = base_quad_def.transform((v) => {
     v.pl = v.pw! * (1.0 / 0.6)
   }
 
-  return v as NowDefined<typeof v, "w" | "h" | "p" | "pw" | "pl">
-})
+  return v as NowDefined<T, "w" | "h" | "p" | "pw" | "pl">
+}
+
+export const quad_def = base_quad_def.transform(quadTransform)
 
 const SIDES_CCW = ["left", "bottom", "right", "top"] as const
 
-export const getQuadCoords = (
-  pinCount: number,
-  pn: number, // pin number
-  w: number, // width of the package
-  h: number, // height (length) of the package
-  p: number, // pitch between pins
+export const getQuadCoords = (params: {
+  pin_count: number
+  pn: number // pin number
+  w: number // width of the package
+  h: number // height (length) of the package
+  p: number // pitch between pins
   pl: number // length of the pin
-) => {
-  const sidePinCount = pinCount / 4
+  legsoutside?: boolean
+}) => {
+  const { pin_count, pn, w, h, p, pl, legsoutside } = params
+  const sidePinCount = pin_count / 4
   const side = SIDES_CCW[Math.floor((pn - 1) / sidePinCount)]
   const pos = (pn - 1) % sidePinCount
 
@@ -77,15 +83,18 @@ export const getQuadCoords = (
   /** inner box height */
   const ibh = p * (sidePinCount - 1)
 
+  /** pad center distance from edge (negative is inside, positive is outside) */
+  const pcdfe = legsoutside ? pl / 2 : -pl / 2
+
   switch (side) {
     case "left":
-      return { x: -w / 2 + pl / 2, y: ibh / 2 - pos * p, o: "vert" }
+      return { x: -w / 2 - pcdfe, y: ibh / 2 - pos * p, o: "vert" }
     case "bottom":
-      return { x: -ibw / 2 + pos * p, y: -h / 2 + pl / 2, o: "horz" }
+      return { x: -ibw / 2 + pos * p, y: -h / 2 - pcdfe, o: "horz" }
     case "right":
-      return { x: w / 2 - pl / 2, y: -ibh / 2 + pos * p, o: "vert" }
+      return { x: w / 2 + pcdfe, y: -ibh / 2 + pos * p, o: "vert" }
     case "top":
-      return { x: ibw / 2 - pos * p, y: h / 2 - pl / 2, o: "horz" }
+      return { x: ibw / 2 - pos * p, y: h / 2 + pcdfe, o: "horz" }
     default:
       throw new Error("Invalid pin number")
   }
@@ -104,14 +113,15 @@ export const quad = (
       x,
       y,
       o: orientation,
-    } = getQuadCoords(
-      params.num_pins,
-      i + 1,
-      params.w,
-      params.h,
-      params.p ?? 0.5,
-      params.pl
-    )
+    } = getQuadCoords({
+      pin_count: params.num_pins,
+      pn: i + 1,
+      w: params.w,
+      h: params.h,
+      p: params.p ?? 0.5,
+      pl: params.pl,
+      legsoutside: params.legsoutside,
+    })
 
     let pw = params.pw
     let pl = params.pl
@@ -125,9 +135,8 @@ export const quad = (
 
   if (params.thermalpad) {
     if (typeof params.thermalpad === "boolean") {
-      const sidePinCount = params.num_pins / 4
-      const ibw = params.p * (sidePinCount - 1) + params.pw
-      const ibh = params.p * (sidePinCount - 1) + params.pw
+      const ibw = params.p * (spc - 1) + params.pw
+      const ibh = params.p * (spc - 1) + params.pw
       pads.push(rectpad(["thermalpad"], 0, 0, ibw, ibh))
     } else {
       pads.push(
@@ -146,9 +155,13 @@ export const quad = (
   ] as const) {
     // const dx = Math.floor(corner_index / 2) * 2 - 1
     // const dy = 1 - (corner_index % 2) * 2
-    const corner_x = (params.w / 2 - params.pl / 2) * dx
-    const corner_y = (params.h / 2 - params.pl / 2) * dy
+    const corner_x = (params.w / 2) * dx
+    const corner_y = (params.h / 2) * dy
     let arrow: "none" | "in1" | "in2" = "none"
+
+    let arrow_x = corner_x
+    let arrow_y = corner_y
+
     /** corner size */
     const csz = params.pw * 2
 
@@ -169,7 +182,17 @@ export const quad = (
     } else if (pin_map[spc * 2 + 1] === 1 && corner === "bottom-right") {
       arrow = "in2"
     }
-    if (arrow === "none") {
+
+    const rotate_arrow = arrow === "in1" ? 1 : -1
+    if (params.legsoutside) {
+      const arrow_dx = arrow === "in1" ? params.pl / 2 : params.pw / 2
+      const arrow_dy = arrow === "in1" ? params.pw / 2 : params.pl / 2
+      arrow_x += arrow_dx * dx * rotate_arrow
+      arrow_y -= arrow_dy * dy * rotate_arrow
+    }
+
+    // Normal Corner
+    if (arrow === "none" || params.legsoutside) {
       silkscreen_corners.push({
         layer: "top",
         pcb_component_id: "",
@@ -190,8 +213,11 @@ export const quad = (
         ],
         type: "pcb_silkscreen_path",
       })
-    } else {
-      const rotate_arrow = arrow === "in1" ? 1 : -1
+    }
+
+    // Two lines nearly forming a corner, used when the arrow needs to overlap
+    // the corne (QFN components where legs are inside)
+    if ((arrow === "in1" || arrow === "in2") && !params.legsoutside) {
       silkscreen_corners.push(
         {
           layer: "top",
@@ -224,33 +250,35 @@ export const quad = (
             },
           ],
           type: "pcb_silkscreen_path",
-        },
-        {
-          layer: "top",
-          pcb_component_id: "",
-          pcb_silkscreen_path_id: `pcb_silkscreen_path_${corner}_3`,
-          route: [
-            {
-              x: corner_x - 0.2 * -dx,
-              y: corner_y + 0.2 * rotate_arrow,
-            },
-            {
-              x: corner_x,
-              y: corner_y,
-            },
-            {
-              x: corner_x + 0.2 * rotate_arrow * -dx,
-              y: corner_y + 0.2,
-            },
-            {
-              x: corner_x - 0.2 * -dx,
-              y: corner_y + 0.2 * rotate_arrow,
-            },
-          ],
-          type: "pcb_silkscreen_path",
         }
       )
     }
+    if (arrow === "in1" || arrow === "in2") {
+      silkscreen_corners.push({
+        layer: "top",
+        pcb_component_id: "",
+        pcb_silkscreen_path_id: `pcb_silkscreen_path_${corner}_3`,
+        route: [
+          {
+            x: arrow_x - 0.2 * -dx,
+            y: arrow_y + 0.2 * rotate_arrow,
+          },
+          {
+            x: arrow_x,
+            y: arrow_y,
+          },
+          {
+            x: arrow_x + 0.2 * rotate_arrow * -dx,
+            y: arrow_y + 0.2,
+          },
+          {
+            x: arrow_x - 0.2 * -dx,
+            y: arrow_y + 0.2 * rotate_arrow,
+          },
+        ],
+        type: "pcb_silkscreen_path",
+      })
+    }
   }
 
   return [...pads, ...silkscreen_corners]

package/src/footprinter.ts

@@ -6,6 +6,8 @@ import { res } from "./fn/res"
 import { bga } from "./fn/bga"
 import { soic } from "./fn/soic"
 import { quad } from "./fn/quad"
+import { qfn } from "./fn/qfn"
+import { qfp } from "./fn/qfp"
 import type { AnySoupElement } from "@tscircuit/soup"
 import { isNotNull } from "./helpers/is-not-null"
 
@@ -34,6 +36,9 @@ export type Footprinter = {
   diode: () => FootprinterParamsBuilder<CommonPassiveOptionKey>
   led: () => FootprinterParamsBuilder<CommonPassiveOptionKey>
   lr: (num_pins: number) => FootprinterParamsBuilder<"w" | "l" | "pl" | "pr">
+  qfp: (
+    num_pins: number
+  ) => FootprinterParamsBuilder<"w" | "p" | "id" | "od" | "wide" | "narrow">
   quad: (
     num_pins: number
   ) => FootprinterParamsBuilder<
@@ -44,6 +49,7 @@ export type Footprinter = {
   ) => FootprinterParamsBuilder<
     "grid" | "p" | "w" | "h" | "ball" | "pad" | "missing"
   >
+  qfn: (num_pins: number) => FootprinterParamsBuilder<"w" | "h" | "p">
   soic: (num_pins: number) => FootprinterParamsBuilder<"w" | "p" | "id" | "od">
   params: () => any
   soup: () => AnySoupElement[]
@@ -83,6 +89,8 @@ export const footprinter = (): Footprinter & { string: typeof string } => {
           if ("bga" in target) return () => bga(target)
           if ("soic" in target) return () => soic(target)
           if ("quad" in target) return () => quad(target)
+          if ("qfn" in target) return () => qfn(target)
+          if ("qfp" in target) return () => qfp(target)
 
           return () => {
             // TODO improve error

package/tests/qfn.test.ts

@@ -0,0 +1,10 @@
+import test from "ava"
+import { getTestFixture, toPinPositionString } from "./fixtures"
+
+test("qfn16_w4_h4_p0.65mm", async (t) => {
+  const { fp, logSoup } = await getTestFixture(t)
+  const soup = fp.string("qfn16_w4_h4_p0.65mm").soup()
+
+  await logSoup(soup)
+  t.pass()
+})

package/tests/qfp.test.ts

@@ -0,0 +1,18 @@
+import test from "ava"
+import { getTestFixture, toPinPositionString } from "./fixtures"
+
+test("qfp48_w14_p1mm", async (t) => {
+  const { fp, logSoup } = await getTestFixture(t)
+  const soup = fp.string("qfp48_w14_p1mm").soup()
+
+  await logSoup(soup)
+  t.pass()
+})
+
+test("qfp48_w14_p1mm_startingpin(topside,leftpin)", async (t) => {
+  const { fp, logSoup } = await getTestFixture(t)
+  const soup = fp.string("qfp48_w14_p1mm_startingpin(topside,leftpin)").soup()
+
+  await logSoup(soup)
+  t.pass()
+})