FootprintGenerator.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib widget\n",
    "import matplotlib.pyplot as plt\n",
    "import math\n",
    "import numpy as np\n",
    "\n",
    "N_FINGERS = 1\n",
    "PITCH = 2.25 # mm\n",
    "CLEARANCE = 0.11 # mm\n",
    "THETA = np.deg2rad(40) # Angle between edges"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "def make_edge_points(n_fingers, pad_pitch, clearance, theta):\n",
    "    margin = pad_pitch * 0.15\n",
    "    size = pad_pitch - clearance \n",
    "    \n",
    "    chord_pitch = (size - margin*2) / (n_fingers * 4.0)\n",
    "    \n",
    "    # Total displacement from center of the reference line\n",
    "    d0 = chord_pitch / 2 / math.tan(theta / 2)\n",
    "    # displacement offset for actual line to allow for clearance between neighboring electrodes\n",
    "    h = clearance / 2 / math.sin(theta/2)\n",
    "    c = clearance / 2\n",
    "    dm_inside = (h - c) / math.tan(math.pi/2 - theta/2)\n",
    "    dm_outside = (h - c) * math.tan(theta/2)\n",
    "    displacements = np.array([clearance/2] * 2 + [d0, d0, -d0 + h] * n_fingers + [clearance/2] * 2)\n",
    "    \n",
    "    chords = [clearance/2]\n",
    "    chords.append(clearance/2 + margin - dm_inside)\n",
    "    chord0 = clearance/2 + margin\n",
    "    for i in range(n_fingers):\n",
    "        center_offset = i*4*chord_pitch\n",
    "        chamfer_offset = h * math.tan(theta/2)\n",
    "        chords.append(chord0 + center_offset + chord_pitch- chamfer_offset)\n",
    "        chords.append(chord0 + center_offset + chord_pitch + chamfer_offset)\n",
    "        chords.append(chord0 + center_offset + chord_pitch * 3)\n",
    "        \n",
    "    chords.append(pad_pitch - clearance/2 - margin - dm_outside)\n",
    "    chords.append(pad_pitch - clearance/2)\n",
    "    chords = np.array(chords)\n",
    "    \n",
    "    return chords, displacements\n",
    "\n",
    "def make_pad(n_fingers, pad_pitch, clearance, theta, edges):\n",
    "    \"\"\"Make polygon for a pad\n",
    "    \n",
    "    edges is a list of 4 booleans corresponding to the four edges, top, right, bottom, left. If true, \n",
    "    the edge will be drawn with fingers, otherwise it will be flat. \n",
    "    \"\"\"\n",
    "   \n",
    "    chords, displacements = make_edge_points(n_fingers, pad_pitch, clearance, theta)\n",
    "    \n",
    "    def push_points(newp):\n",
    "        nonlocal points\n",
    "        points = np.vstack([points, newp])\n",
    "    # concatenate four edges\n",
    "    flat_displacements = np.ones_like(chords) * clearance/2\n",
    "    if edges[0]:\n",
    "        points = np.array([chords, displacements]).T\n",
    "    else:\n",
    "        points = np.array([chords, flat_displacements]).T\n",
    "    if edges[1]:\n",
    "        push_points(np.array([pad_pitch - displacements, chords]).T)\n",
    "    else: \n",
    "        push_points(np.array([pad_pitch - flat_displacements, chords]).T)\n",
    "    if edges[2]:\n",
    "        push_points(np.array([pad_pitch - chords, pad_pitch - displacements]).T)\n",
    "    else:\n",
    "        push_points(np.array([pad_pitch - chords, pad_pitch - flat_displacements]).T)\n",
    "    if edges[3]:\n",
    "        push_points(np.array([displacements, pad_pitch - chords]).T)\n",
    "    else:\n",
    "        push_points(np.array([flat_displacements, pad_pitch - chords]).T)\n",
    "    return points\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "b3a2b5b4a25e4543b1e9eeca518a1123",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "(5.0, -0.5)"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from matplotlib.patches import Polygon\n",
    "margin = 0.5\n",
    "\n",
    "ax = None\n",
    "fig = plt.figure()\n",
    "\n",
    "offsets = np.array([[0, 0], [0, PITCH], [PITCH, 0], [PITCH, PITCH]])\n",
    "p = make_pad(N_FINGERS, PITCH, CLEARANCE, THETA, [True, True, True, True])\n",
    "ax = fig.add_subplot(111, sharex=ax)\n",
    "\n",
    "for offset in offsets:\n",
    "    poly = Polygon(p + offset)\n",
    "    ax.add_patch(poly)\n",
    "ax.set_xlim([-margin, PITCH*2+margin])\n",
    "ax.set_ylim([PITCH*2+margin, -margin ])\n",
    "\n",
    "# for i, theta in enumerate([90, 75, 60, 45]):\n",
    "#     THETA = np.deg2rad(theta)\n",
    "#     offsets = np.array([[0, 0], [0, PITCH], [PITCH, 0], [PITCH, PITCH]])\n",
    "#     #offsets = [(0, 0)]\n",
    "#     p = normalized_points()\n",
    "#     #print(p)\n",
    "#     ax = fig.add_subplot(221 + i, sharex=ax)\n",
    "\n",
    "#     for offset in offsets:\n",
    "#         poly = Polygon(p + offset)\n",
    "#         ax.add_patch(poly)\n",
    "#     ax.set_title('THETA = %d deg' % theta)\n",
    "\n",
    "#     ax.set_xlim([-margin, PITCH*2+margin])\n",
    "#     ax.set_ylim([-margin, PITCH*2+margin])\n",
    "#     ax.axis('square')\n",
    "# plt.tight_layout()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "from KicadModTree import *\n",
    "\n",
    "edge_permutations = [\n",
    "    \"trbl\",\n",
    "    \"t\",\n",
    "    \"b\",\n",
    "    \"r\",\n",
    "    \"l\",\n",
    "    \"tr\",\n",
    "    \"tl\",\n",
    "    \"tb\",\n",
    "    \"rb\",\n",
    "    \"rl\",\n",
    "    \"bl\",\n",
    "    \"rbl\",\n",
    "    \"trb\",\n",
    "    \"trl\",\n",
    "    \"tbl\",\n",
    "]\n",
    "for variant in edge_permutations:\n",
    "    footprint_name = 'electrode_points_%d_%ddeg_%s' % (N_FINGERS, int(np.rad2deg(THETA)), variant)\n",
    "\n",
    "    kicad_mod = Footprint(footprint_name)\n",
    "    kicad_mod.setDescription(\"Pointy electrode with two 45degree fingers\")\n",
    "\n",
    "    kicad_mod.append(Text(type=\"reference\", text=\"REF**\", at=[0, -3], layer='F.SilkS', hide=True))\n",
    "    kicad_mod.append(Text(type=\"value\", text=\"DMFElectrode\", at=[1.5, 3], layer='F.Fab'))\n",
    "    \n",
    "    edges = [\"t\" in variant, \"r\" in variant, \"b\" in variant, \"l\" in variant]\n",
    "    polygon = Polygon(\n",
    "        nodes=(make_pad(N_FINGERS, PITCH, CLEARANCE, THETA, edges) - np.array([PITCH/2, PITCH/2])).tolist(), \n",
    "        layer='F.Cu',\n",
    "        width=0.0001)\n",
    "    pad = kicad_mod.append(Pad(\n",
    "        number=1,\n",
    "        type=Pad.TYPE_SMT,\n",
    "        shape=Pad.SHAPE_CUSTOM,\n",
    "        at=[0, 0],\n",
    "        size=[0.5, 0.5],\n",
    "        layers=Pad.LAYERS_SMT,\n",
    "        primitives=[polygon]))\n",
    "\n",
    "    # output kicad model\n",
    "    file_handler = KicadFileHandler(kicad_mod)\n",
    "    file_handler.writeFile(footprint_name + \".kicad_mod\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "35591b53998f4062a394b3280ad628f6",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Make reservoir shape A\n",
    "\n",
    "import KicadModTree as kmt\n",
    "import matplotlib.patches as patches\n",
    "\n",
    "\n",
    "L1 = 4.0\n",
    "L2 = 2.0\n",
    "L3 = 9.5\n",
    "L4 = PITCH * 1.5\n",
    "(chords, displacements) = make_edge_points(N_FINGERS, PITCH, CLEARANCE, THETA)\n",
    "\n",
    "c = CLEARANCE/2\n",
    "\n",
    "edges1 = [\n",
    "    [[c, L1 - c], [c, c],],\n",
    "    [L1 - displacements,  chords],\n",
    "    [[L1 - c, c], [PITCH-c, PITCH-c]],\n",
    "    [displacements, PITCH-chords]\n",
    "\n",
    "]\n",
    "edges1 = [np.array(e).T for e in edges1]\n",
    "poly1 = np.vstack(edges1)\n",
    "\n",
    "\n",
    "edges2 = [L1 + displacements, PITCH - chords]\n",
    "edges2 = [(x, y) for x, y in zip(edges2[0], edges2[1])]\n",
    "\n",
    "edges2 += [\n",
    "    (L1 + c, -c),\n",
    "    (L1 - L2, -c),\n",
    "    (L1 - L2, -L4 + c),\n",
    "    (L2 + L3, -L4 + c),\n",
    "    (L2 + L3, PITCH + L4 - c),\n",
    "    (L1 - L2, PITCH + L4 - c),\n",
    "    (L1 - L2, PITCH + c),\n",
    "    (L1 + c, PITCH + c)\n",
    "]\n",
    "\n",
    "#edges2 = [np.array(e).T for e in edges2]\n",
    "poly2 = np.array(edges2)\n",
    "\n",
    "ax = None\n",
    "fig = plt.figure()\n",
    "\n",
    "offsets = np.array([[0, 0], [0, PITCH], [PITCH, 0], [PITCH, PITCH]])\n",
    "#p = make_pad(N_FINGERS, PITCH, CLEARANCE, THETA, [True, True, True, True])\n",
    "ax = fig.add_subplot(111, sharex=ax)\n",
    "ax.add_patch(patches.Polygon(poly1))\n",
    "ax.add_patch(patches.Polygon(poly2,  color='red'))\n",
    "\n",
    "ax.set_xlim([-1, 12])\n",
    "ax.set_ylim([-4, 8])\n",
    "\n",
    "footprint_name = \"reservoir_A_%.2fmm\" % PITCH\n",
    "kicad_mod = kmt.Footprint(footprint_name)\n",
    "kicad_mod.setDescription(\"Reservoir A for %.2fmm pitch electrodes\" % PITCH)\n",
    "\n",
    "kicad_mod.append(kmt.Text(type=\"reference\", text=\"REF**\", at=[0, -3], layer='F.SilkS', hide=True))\n",
    "kicad_mod.append(kmt.Text(type=\"value\", text=\"DMFReservoir\", at=[1.5, 3], layer='F.Fab'))\n",
    "\n",
    "fp_poly1 = kmt.Polygon(\n",
    "    nodes=(poly1 - np.array([PITCH/2, PITCH/2])).tolist(), \n",
    "    layer='F.Cu',\n",
    "    width=0.0001)\n",
    "\n",
    "kicad_mod.append(kmt.Pad(\n",
    "    number=1,\n",
    "    type=kmt.Pad.TYPE_SMT,\n",
    "    shape=kmt.Pad.SHAPE_CUSTOM,\n",
    "    at=[0, 0],\n",
    "    size=[0.5, 0.5],\n",
    "    layers=kmt.Pad.LAYERS_SMT,\n",
    "    primitives=[fp_poly1]))\n",
    "\n",
    "pad2_origin = [L2 + L3/2, 0]\n",
    "fp_poly2 = kmt.Polygon(\n",
    "    nodes=(poly2 - np.array([PITCH/2, PITCH/2]) - np.array(pad2_origin)).tolist(), \n",
    "    layer='F.Cu',\n",
    "    width=0.0001)\n",
    "\n",
    "kicad_mod.append(kmt.Pad(\n",
    "    number=2,\n",
    "    type=kmt.Pad.TYPE_SMT,\n",
    "    shape=kmt.Pad.SHAPE_CUSTOM,\n",
    "    at=pad2_origin,\n",
    "    size=[0.5, 0.5],\n",
    "    layers=kmt.Pad.LAYERS_SMT,\n",
    "    primitives=[fp_poly2]))\n",
    "\n",
    "# output kicad model\n",
    "file_handler = kmt.KicadFileHandler(kicad_mod)\n",
    "file_handler.writeFile(footprint_name + \".kicad_mod\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "bc3fd4eed00841d3aaa4c3d0146b8025",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Make reservoir shape B\n",
    "\n",
    "import matplotlib.patches as patches\n",
    "\n",
    "(chords, displacements) = make_edge_points(N_FINGERS, PITCH, CLEARANCE, THETA)\n",
    "c = CLEARANCE/2\n",
    "# Length of long feeder electrode in units of PITCH \n",
    "L1 = 1.5\n",
    "\n",
    "def make_points_list(xp, yp):\n",
    "    return [(x, y) for x, y in zip(reversed(xp), reversed(yp))]\n",
    "\n",
    "jagged_edge = [(x, y) for x, y in zip(chords, displacements)]\n",
    "####\n",
    "# Make the output electrode\n",
    "####\n",
    "edges1 = make_points_list(displacements, PITCH - chords) + \\\n",
    "    [\n",
    "        (c, PITCH-c),\n",
    "        (PITCH-c, PITCH-c),\n",
    "    ] + \\\n",
    "    make_points_list(PITCH - displacements, chords) + \\\n",
    "    [\n",
    "        (PITCH - c, c),\n",
    "        (c, c)\n",
    "    ]\n",
    "poly1 = np.array(edges1)\n",
    "\n",
    "####\n",
    "# Make the long feeder electrode\n",
    "####\n",
    "edges2 = make_points_list(displacements + PITCH, PITCH - chords) + \\\n",
    "    [\n",
    "        (PITCH + c,  PITCH - c),\n",
    "    ] + \\\n",
    "    make_points_list((1+L1) * PITCH - displacements, chords) + \\\n",
    "    [\n",
    "        ((1 + L1) * PITCH - c, c),\n",
    "        (PITCH + c, c)\n",
    "    ]\n",
    "poly2 = np.array(edges2)\n",
    "\n",
    "####\n",
    "# Make the \"C\"\n",
    "####\n",
    "# Amount of C overlap with feeder electrode \n",
    "L2 = 1.0 * PITCH\n",
    "# Depth of reservoir\n",
    "L3 = 3.0 * PITCH\n",
    "# Thickness of reservoir arms\n",
    "L4 = 1.5 * PITCH\n",
    "# Define an origin at the top right corner of the feeder for simplification\n",
    "x0 = (1 + L1) * PITCH \n",
    "\n",
    "x1 = x0 - L2 + c\n",
    "x2 = x0 + L3 - c\n",
    "y1 = PITCH + c\n",
    "y2 = PITCH + L4 - c\n",
    "y3 = -(L4 - c)\n",
    "y4 = -c\n",
    "edges3 = make_points_list(x0 + displacements, PITCH - chords)\n",
    "edges3 += [\n",
    "    (x0 + c, y1),\n",
    "    (x1, y1),\n",
    "]\n",
    "edges3 += make_points_list(x1 -c + displacements, y1 - c + PITCH - chords)\n",
    "edges3 += [\n",
    "    (x1, y2),\n",
    "    (x2, y2),\n",
    "    (x2, y3),\n",
    "    (x1, y3),\n",
    "]\n",
    "edges3 += make_points_list(x1 - c + displacements, y3 - c + L4 - chords)\n",
    "edges3 += [\n",
    "    (x1, y4),\n",
    "    (x0 + c, y4),\n",
    "]\n",
    "poly3 = np.array(edges3)\n",
    "\n",
    "####\n",
    "# Make the side helper electrode\n",
    "####\n",
    "edges4 = [\n",
    "    (c, c),\n",
    "    (c, PITCH-c),\n",
    "    (PITCH-c, PITCH-c),\n",
    "] + \\\n",
    "make_points_list(PITCH - displacements, chords) + \\\n",
    "[\n",
    "    (PITCH - c, c),\n",
    "    (c, c)\n",
    "]\n",
    "poly4 = np.array(edges4) + [0.5*PITCH, PITCH]\n",
    "poly5 = np.array(edges4) + (0.5*PITCH, -PITCH)\n",
    "\n",
    "####\n",
    "# Plot it\n",
    "####\n",
    "ax = None\n",
    "fig = plt.figure()\n",
    "offsets = np.array([[0, 0], [0, PITCH], [PITCH, 0], [PITCH, PITCH]])\n",
    "ax = fig.add_subplot(111, sharex=ax)\n",
    "ax.add_patch(patches.Polygon(poly1))\n",
    "ax.add_patch(patches.Polygon(poly2,  color='red'))\n",
    "ax.add_patch(patches.Polygon(poly3,  color='green'))\n",
    "ax.add_patch(patches.Polygon(poly4,  color='orange'))\n",
    "ax.add_patch(patches.Polygon(poly5,  color='orange'))\n",
    "ax.set_xlim([-1, 12])\n",
    "ax.set_ylim([8, -4])\n",
    "\n",
    "####\n",
    "# Write it to kicad footprint file\n",
    "####\n",
    "import KicadModTree as kmt\n",
    "footprint_name = \"reservoir_B_%.2fmm\" % PITCH\n",
    "kicad_mod = kmt.Footprint(footprint_name)\n",
    "kicad_mod.setDescription(\"Reservoir B for %.2fmm pitch electrodes\" % PITCH)\n",
    "\n",
    "kicad_mod.append(kmt.Text(type=\"reference\", text=\"\", at=[0, -3], layer='F.SilkS'))\n",
    "kicad_mod.append(kmt.Text(type=\"value\", text=\"DMFReservoir\", at=[1.5, 3], layer='F.Fab'))\n",
    "\n",
    "def make_pad(number, poly, origin):\n",
    "    fp_poly = kmt.Polygon(\n",
    "        nodes=(poly - np.array([PITCH/2, PITCH/2]) - np.array(origin)).tolist(), \n",
    "        layer='F.Cu',\n",
    "        width=0.0001,\n",
    "    )\n",
    "    \n",
    "    kicad_mod.append(kmt.Pad(\n",
    "        number=number,\n",
    "        type=kmt.Pad.TYPE_SMT,\n",
    "        shape=kmt.Pad.SHAPE_CUSTOM,\n",
    "        at=origin,\n",
    "        size=[0.5, 0.5],\n",
    "        layers=kmt.Pad.LAYERS_SMT,\n",
    "        primitives=[fp_poly],\n",
    "    ))\n",
    "    \n",
    "make_pad(1, poly1, (0, 0))\n",
    "make_pad(2, poly2, (1.5*PITCH, 0))\n",
    "make_pad(3, poly3, (3.0*PITCH, 0))\n",
    "make_pad(4, poly4, (0.5*PITCH, PITCH))\n",
    "make_pad(5, poly5, (0.5*PITCH, -PITCH))\n",
    "\n",
    "\n",
    "# output kicad model\n",
    "file_handler = kmt.KicadFileHandler(kicad_mod)\n",
    "file_handler.writeFile(footprint_name + \".kicad_mod\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3, 5])"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.array([2, 4])\n",
    "a + [1, 1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}