@tscircuit/footprinter 0.0.12 → 0.0.14

package/package.json

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

package/src/fn/quad.ts

@@ -0,0 +1,124 @@
+import type { AnySoupElement } from "@tscircuit/soup"
+import { z } from "zod"
+import { length } from "@tscircuit/soup"
+import type { NowDefined } from "../helpers/zod/now-defined"
+import { rectpad } from "../helpers/rectpad"
+import { pin_order_specifier } from "src/helpers/zod/pin-order-specifier"
+import { getQuadPinMap } from "src/helpers/get-quad-pin-map"
+
+const base_quad_def = z.object({
+  quad: z.literal(true),
+  cc: z.literal(true).optional(),
+  ccw: z.literal(true).optional(),
+  startingpin: z.array(pin_order_specifier).optional(),
+  num_pins: z.number(),
+  w: length.optional(),
+  h: length.optional(),
+  p: length.default(length.parse("0.5mm")),
+  pw: length.optional(),
+  pl: length.optional(),
+})
+
+const quad_def = base_quad_def.transform((v) => {
+  if (v.w && !v.h) {
+    v.h = v.w
+  } else if (!v.w && v.h) {
+    v.w = v.h
+  }
+
+  const side_pin_count = v.num_pins / 4
+
+  if (!v.p && !v.pw && !v.pl && v.w) {
+    // HACK: This is wayyy underspecified
+    const approx_pin_size_of_side = side_pin_count + 4
+    v.p = v.w / approx_pin_size_of_side
+  }
+
+  if (!v.p && v.w && v.h && v.pw && v.pl) {
+    // HACK: This is wayyy underspecified
+    v.p = (v.w - v.pl * 2) / (side_pin_count - 1)
+  }
+
+  if (v.p && !v.pw && !v.pl) {
+    v.pw = v.p / 2
+    v.pl = v.p / 2
+  } else if (!v.pw) {
+    v.pw = v.pl! * (0.6 / 1.0)
+  } else if (!v.pl) {
+    v.pl = v.pw! * (1.0 / 0.6)
+  }
+
+  return v as NowDefined<typeof v, "w" | "h" | "p" | "pw" | "pl">
+})
+
+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
+) => {
+  const sidePinCount = pinCount / 4
+  const side = SIDES_CCW[Math.floor((pn - 1) / sidePinCount)]
+  const pos = (pn - 1) % sidePinCount
+
+  const halfW = w / 2
+  const halfH = h / 2
+
+  /** inner box width */
+  const ibw = p * (sidePinCount - 1)
+  /** inner box height */
+  const ibh = p * (sidePinCount - 1)
+
+  switch (side) {
+    case "left":
+      return { x: -halfW / 2, y: ibh / 2 - pos * p, o: "vert" }
+    case "bottom":
+      return { x: -ibw / 2 + pos * p, y: -halfH / 2, o: "horz" }
+    case "right":
+      return { x: halfW / 2, y: -ibh / 2 + pos * p, o: "vert" }
+    case "top":
+      return { x: ibw / 2 - pos * p, y: halfH / 2, o: "horz" }
+    default:
+      throw new Error("Invalid pin number")
+  }
+}
+
+export const quad = (raw_params: {
+  quad: true
+  num_pins: number
+  w: number
+  l: number
+  p?: number
+  id?: string | number
+  od?: string | number
+}): AnySoupElement[] => {
+  const params = quad_def.parse(raw_params)
+  const pads: AnySoupElement[] = []
+  const pin_map = getQuadPinMap(params)
+  for (let i = 0; i < params.num_pins; i++) {
+    const {
+      x,
+      y,
+      o: orientation,
+    } = getQuadCoords(
+      params.num_pins,
+      i + 1,
+      params.w,
+      params.h,
+      params.p ?? 0.5
+    )
+
+    let pw = params.pw,
+      pl = params.pl
+    if (orientation === "vert") {
+      ;[pw, pl] = [pl, pw]
+    }
+
+    const pn = getQuadPinMap(params)[i + 1]
+    pads.push(rectpad(pn!, x, y, pw, pl))
+  }
+  return pads
+}

package/src/footprinter.ts

@@ -5,6 +5,7 @@ import { led } from "./fn/led"
 import { res } from "./fn/res"
 import { bga } from "./fn/bga"
 import { soic } from "./fn/soic"
+import { quad } from "./fn/quad"
 import type { AnySoupElement } from "@tscircuit/soup"
 import { isNotNull } from "./helpers/is-not-null"
 
@@ -81,6 +82,7 @@ export const footprinter = (): Footprinter & { string: typeof string } => {
           if ("res" in target) return () => res(target)
           if ("bga" in target) return () => bga(target)
           if ("soic" in target) return () => soic(target)
+          if ("quad" in target) return () => quad(target)
 
           return () => {
             // TODO improve error

package/src/helpers/get-quad-pin-map.ts

@@ -0,0 +1,105 @@
+import type { PinOrderSpecifier } from "./zod/pin-order-specifier"
+
+/**
+ * A counter-clockwise pin map is [1,2,3,4,5,6,7,8] for an 8-pin package
+ *
+ *     8 7
+ *   1     6
+ *   2     5
+ *     3 4
+ *
+ * Given some parameters, we're returning how to map the pins in a quad package
+ * with a different order. For example, if we pass in cw=true, we'll get the
+ * following mapping
+ *
+ * 1 -> 1
+ * 2 -> 8
+ * 3 -> 7
+ * 4 -> 6
+ * 5 -> 5
+ * 6 -> 4
+ * 7 -> 3
+ * 8 -> 2
+ *
+ * Which allows us to create the CW version of the package:
+ *
+ *    2 3
+ *  1     4
+ *  8     5
+ *    7 6
+ */
+export const getQuadPinMap = ({
+  num_pins,
+  cw,
+  ccw,
+  startingpin,
+}: {
+  num_pins: number
+  cw?: boolean
+  ccw?: boolean
+  startingpin?: PinOrderSpecifier[]
+}): number[] => {
+  const pin_map: number[] = []
+  const pins_per_side = num_pins / 4
+  let current_position_ccw_normal = 1
+
+  /** Starting Flag Pins */
+  const sfp: Record<PinOrderSpecifier, boolean> = {} as any
+  for (const specifier of startingpin ?? []) {
+    sfp[specifier] = true
+  }
+  if (!sfp.leftside && !sfp.topside && !sfp.rightside && !sfp.bottomside) {
+    sfp.leftside = true
+  }
+  if (!sfp.bottompin && !sfp.leftpin && !sfp.rightpin && !sfp.toppin) {
+    if (sfp.leftside) {
+      sfp.toppin = true
+    } else if (sfp.topside) {
+      sfp.rightpin = true
+    } else if (sfp.rightside) {
+      sfp.bottompin = true
+    } else if (sfp.bottomside) {
+      sfp.leftpin = true
+    }
+  }
+
+  if (sfp.leftside && sfp.toppin) {
+    current_position_ccw_normal = 1
+  } else if (sfp.leftside && sfp.bottompin) {
+    current_position_ccw_normal = pins_per_side
+  } else if (sfp.bottomside && sfp.leftpin) {
+    current_position_ccw_normal = pins_per_side + 1
+  } else if (sfp.bottomside && sfp.rightpin) {
+    current_position_ccw_normal = pins_per_side * 2
+  } else if (sfp.rightside && sfp.bottompin) {
+    current_position_ccw_normal = pins_per_side * 2 + 1
+  } else if (sfp.rightside && sfp.toppin) {
+    current_position_ccw_normal = pins_per_side * 3
+  } else if (sfp.topside && sfp.rightpin) {
+    current_position_ccw_normal = pins_per_side * 3 + 1
+  } else if (sfp.topside && sfp.leftpin) {
+    current_position_ccw_normal = pins_per_side * 4
+  }
+
+  pin_map.push(-1) // the first index is meaningless
+
+  // Each iteration we move the current position to the next pin, if we're
+  // going CCW this means incrementing, if we're going CW this means
+  // decrementing
+  for (let i = 0; i < num_pins; i++) {
+    pin_map.push(current_position_ccw_normal)
+    if (ccw) {
+      current_position_ccw_normal++
+      if (current_position_ccw_normal > num_pins) {
+        current_position_ccw_normal = 1
+      }
+    } else {
+      current_position_ccw_normal--
+      if (current_position_ccw_normal < 1) {
+        current_position_ccw_normal = num_pins
+      }
+    }
+  }
+
+  return pin_map
+}

package/src/helpers/zod/pin-order-specifier.ts

@@ -0,0 +1,13 @@
+import { z } from "zod"
+export const pin_order_specifier = z.enum([
+  "leftside",
+  "topside",
+  "rightside",
+  "bottomside",
+  "toppin",
+  "bottompin",
+  "leftpin",
+  "rightpin",
+])
+
+export type PinOrderSpecifier = z.infer<typeof pin_order_specifier>

package/tests/quad.test.ts

@@ -0,0 +1,37 @@
+import test from "ava"
+import { fp } from "../src/footprinter"
+import type { AnySoupElement } from "@tscircuit/soup"
+import { getTestFixture, toPinPositionString } from "./fixtures"
+
+test("quad16_w4_l4_p0.4_pw0.25_pl0.4", async (t) => {
+  const { fp, logSoup } = await getTestFixture(t)
+  const soup = fp.string("quad16_w4_l4_p0.4_pw0.25_pl0.4").soup()
+
+  await logSoup(soup)
+  t.pass()
+})
+
+//   const ps = toPinPositionString(soup)
+
+//   t.is(
+//     ps,
+//     `
+// 1 : -1.75 -2.00
+// 2 : -1.25 -2.00
+// 3 : -0.75 -2.00
+// 4 : -0.25 -2.00
+// 5 :  0.25 -2.00
+// 6 :  0.75 -2.00
+// 7 :  1.25 -2.00
+// 8 :  1.75 -2.00
+// 9 :  2.00 -1.75
+// 10:  2.00 -1.25
+// 11:  2.00 -0.75
+// 12:  2.00 -0.25
+// 13:  2.00  0.25
+// 14:  2.00  0.75
+// 15:  2.00  1.25
+// 16:  2.00  1.75
+//   `.trim()
+//   )
+// })