greg/pcb-stator-coil-generator
1
0
Fork 0
mirror of https://github.com/atomic14/kicad-coil-plugins.git synced 2024-10-18 09:06:57 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

WIP board connector

Browse source
This commit is contained in:
Chris Greening 2022-10-12 10:33:06 +01:00
parent f11f403e9f
commit 02a304df72
6 changed files with 286 additions and 130 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

61
coil_generator-12.ipynb
View file

@ -20,15 +20,20 @@
" translate,\n", " translate,\n",
" flip_y,\n", " flip_y,\n",
" flip_x,\n", " flip_x,\n",
" create_via,\n",
" create_pad,\n",
" create_track,\n",
" create_silk,\n",
" create_silk,\n",
" optimize_points,\n", " optimize_points,\n",
" chaikin,\n", " chaikin,\n",
")\n", ")\n",
"from pcb_json import dump_json, plot_json\n", "from pcb_json import (\n",
" dump_json,\n",
" plot_json,\n",
" create_via,\n",
" create_pad,\n",
" create_pin,\n",
" create_track,\n",
" create_silk,\n",
" create_silk,\n",
" create_mounting_hole,\n",
")\n",
"\n", "\n",
"from enum import Enum\n", "from enum import Enum\n",
"\n", "\n",
@ -44,11 +49,22 @@
"VIA_DIAM = 0.8\n", "VIA_DIAM = 0.8\n",
"VIA_DRILL = 0.4\n", "VIA_DRILL = 0.4\n",
"# this is for a 1.27mm pitch pin\n", "# this is for a 1.27mm pitch pin\n",
"PAD_DIAM = 1.0\n", "PIN_DIAM = 1.0\n",
"PAD_DRILL = 0.65\n", "PIN_DRILL = 0.65\n",
"\n",
"# this is for the PCB connector - see https://www.farnell.com/datasheets/2003059.pdf\n",
"PAD_WIDTH = 6\n",
"PAD_HEIGHT = 2\n",
"PAD_PITCH = 2.5\n",
"\n",
"# where to put the input pads\n",
"INPUT_PAD_RADIUS = 19.5\n",
"\n", "\n",
"# PCB Edge size\n", "# PCB Edge size\n",
"STATOR_RADIUS = 18\n", "STATOR_RADIUS = 23\n",
"STATOR_HOLE_RADIUS = 5\n",
"SCREW_HOLE_RADIUS = 20\n",
"SCREW_HOLE_DRILL_DIAM = 3.2 # 3.2mm drill for a 3mm screw\n",
"STATOR_HOLE_RADIUS = 5\n", "STATOR_HOLE_RADIUS = 5\n",
"\n", "\n",
"# Track width and spacing\n", "# Track width and spacing\n",
@ -242,6 +258,8 @@
"tracks_f = []\n", "tracks_f = []\n",
"tracks_b = []\n", "tracks_b = []\n",
"pads = []\n", "pads = []\n",
"pins = []\n",
"mounting_holes = []\n",
"silk = []\n", "silk = []\n",
"\n", "\n",
"# create the pads at CONNECTION_PINS radius - 2 for each of the coils, A, B and C\n", "# create the pads at CONNECTION_PINS radius - 2 for each of the coils, A, B and C\n",
@ -370,9 +388,9 @@
"vias.append(create_via(get_arc_point(5 * 360 / 12, outer_connection_radius_C)))\n", "vias.append(create_via(get_arc_point(5 * 360 / 12, outer_connection_radius_C)))\n",
"vias.append(create_via(get_arc_point(8 * 360 / 12, outer_connection_radius_C)))\n", "vias.append(create_via(get_arc_point(8 * 360 / 12, outer_connection_radius_C)))\n",
"\n", "\n",
"# create pads for the input\n", "# create pins for the input\n",
"for angle in range(0, 360, 15):\n", "# for angle in range(0, 360, 15):\n",
" pads.append(create_pad(CONNECTION_PINS_RADIUS, angle, \"A\"))\n", "# pins.append(create_pin(CONNECTION_PINS_RADIUS, angle, \"A\"))\n",
"\n", "\n",
"# coils_f[0].append(get_arc_point(0, CONNECTION_PINS_RADIUS))\n", "# coils_f[0].append(get_arc_point(0, CONNECTION_PINS_RADIUS))\n",
"# coils_f[1].append(get_arc_point(1 * 360 / 12, CONNECTION_PINS_RADIUS))\n", "# coils_f[1].append(get_arc_point(1 * 360 / 12, CONNECTION_PINS_RADIUS))\n",
@ -380,7 +398,18 @@
"\n", "\n",
"# coils_f[0].append(get_arc_point(15, CONNECTION_PINS_RADIUS))\n", "# coils_f[0].append(get_arc_point(15, CONNECTION_PINS_RADIUS))\n",
"# coils_f[1].append(get_arc_point(15 + 1 * 360 / 12, CONNECTION_PINS_RADIUS))\n", "# coils_f[1].append(get_arc_point(15 + 1 * 360 / 12, CONNECTION_PINS_RADIUS))\n",
"# coils_f[2].append(get_arc_point(15 + 2 * 360 / 12, CONNECTION_PINS_RADIUS))" "# coils_f[2].append(get_arc_point(15 + 2 * 360 / 12, CONNECTION_PINS_RADIUS))\n",
"\n",
"# create mounting holes at 45 degree angles\n",
"mounting_holes = [\n",
" create_mounting_hole(get_arc_point(angle, SCREW_HOLE_RADIUS), SCREW_HOLE_DRILL_DIAM)\n",
" for angle in [45, 135, 225, 315]\n",
"]\n",
"\n",
"# create the pads for connecting the inputs to the coils\n",
"pads.append(create_pad((INPUT_PAD_RADIUS, -PAD_PITCH), PAD_WIDTH, PAD_HEIGHT, \"b\"))\n",
"pads.append(create_pad((INPUT_PAD_RADIUS, 0), PAD_WIDTH, PAD_HEIGHT, \"b\"))\n",
"pads.append(create_pad((INPUT_PAD_RADIUS, PAD_PITCH), PAD_WIDTH, PAD_HEIGHT, \"b\"))"
] ]
}, },
{ {
@ -395,15 +424,17 @@
" STATOR_RADIUS,\n", " STATOR_RADIUS,\n",
" STATOR_HOLE_RADIUS,\n", " STATOR_HOLE_RADIUS,\n",
" TRACK_WIDTH,\n", " TRACK_WIDTH,\n",
" PAD_DIAM,\n", " PIN_DIAM,\n",
" PAD_DRILL,\n", " PIN_DRILL,\n",
" VIA_DIAM,\n", " VIA_DIAM,\n",
" VIA_DRILL,\n", " VIA_DRILL,\n",
" vias,\n", " vias,\n",
" pins,\n",
" pads,\n", " pads,\n",
" silk,\n", " silk,\n",
" tracks_f,\n", " tracks_f,\n",
" tracks_b,\n", " tracks_b,\n",
" mounting_holes,\n",
")" ")"
] ]
}, },

130
coil_generator-6.ipynb
View file

@ -23,11 +23,16 @@
" flip_x,\n", " flip_x,\n",
" optimize_points,\n", " optimize_points,\n",
" chaikin,\n", " chaikin,\n",
")\n",
"from pcb_json import (\n",
" dump_json,\n",
" plot_json,\n",
" create_pad,\n", " create_pad,\n",
" create_silk,\n", " create_silk,\n",
" create_via,\n", " create_via,\n",
" create_mounting_hole,\n",
" create_pin,\n",
")\n", ")\n",
"from pcb_json import dump_json, plot_json\n",
"\n", "\n",
"from enum import Enum\n", "from enum import Enum\n",
"\n", "\n",
@ -43,13 +48,23 @@
"VIA_DIAM = 0.8\n", "VIA_DIAM = 0.8\n",
"VIA_DRILL = 0.4\n", "VIA_DRILL = 0.4\n",
"# this is for a 1.27mm pitch pin\n", "# this is for a 1.27mm pitch pin\n",
"PAD_DIAM = 1.0\n", "PIN_DIAM = 1.0\n",
"PAD_DRILL = 0.65\n", "PIN_DRILL = 0.65\n",
"\n",
"# this is for the PCB connector - see https://www.farnell.com/datasheets/2003059.pdf\n",
"PAD_WIDTH = 6\n",
"PAD_HEIGHT = 2\n",
"PAD_PITCH = 2.5\n",
"\n", "\n",
"# PCB Edge size\n", "# PCB Edge size\n",
"STATOR_RADIUS = 18\n", "STATOR_RADIUS = 23\n",
"SCREW_HOLE_RADIUS = 20\n",
"SCREW_HOLE_DRILL_DIAM = 3.2 # 3.2mm drill for a 3mm screw\n",
"STATOR_HOLE_RADIUS = 5\n", "STATOR_HOLE_RADIUS = 5\n",
"\n", "\n",
"# where to put the input pads\n",
"INPUT_PAD_RADIUS = 19.5\n",
"\n",
"# Track width and spacing\n", "# Track width and spacing\n",
"TRACK_WIDTH = 0.127\n", "TRACK_WIDTH = 0.127\n",
"TRACK_SPACING = 0.127\n", "TRACK_SPACING = 0.127\n",
@ -57,6 +72,10 @@
"# Coil params\n", "# Coil params\n",
"TURNS = 18\n", "TURNS = 18\n",
"COIL_CENTER_RADIUS = 11.5\n", "COIL_CENTER_RADIUS = 11.5\n",
"\n",
"# where do we want to stop routing any tracks?\n",
"MAX_TRACK_RADIUS = SCREW_HOLE_RADIUS - (SCREW_HOLE_DRILL_DIAM / 2 + TRACK_SPACING * 2)\n",
"\n",
"# where to place the pins\n", "# where to place the pins\n",
"CONNECTION_PINS_RADIUS = 16.5\n", "CONNECTION_PINS_RADIUS = 16.5\n",
"\n", "\n",
@ -295,22 +314,13 @@
"vias = []\n", "vias = []\n",
"tracks_f = []\n", "tracks_f = []\n",
"tracks_b = []\n", "tracks_b = []\n",
"pins = []\n",
"pads = []\n", "pads = []\n",
"\n", "\n",
"angle_A = 0\n", "angle_A = 0\n",
"angle_B = 120\n", "angle_B = 120\n",
"angle_C = 240\n", "angle_C = 240\n",
"\n", "\n",
"# create the pads at CONNECTION_PINS radius - 2 for each of the coils, A, B and C\n",
"pads.append(create_pad(CONNECTION_PINS_RADIUS, angle_A - 30, \"A\"))\n",
"pads.append(create_pad(CONNECTION_PINS_RADIUS, angle_A + 30, \"A\"))\n",
"\n",
"pads.append(create_pad(CONNECTION_PINS_RADIUS, angle_B - 30, \"B\"))\n",
"pads.append(create_pad(CONNECTION_PINS_RADIUS, angle_B + 30, \"B\"))\n",
"\n",
"pads.append(create_pad(CONNECTION_PINS_RADIUS, angle_C - 30, \"C\"))\n",
"pads.append(create_pad(CONNECTION_PINS_RADIUS, angle_C + 30, \"C\"))\n",
"\n",
"# the main coils\n", "# the main coils\n",
"coil_A_f = translate(rotate(points_f, angle_A), COIL_CENTER_RADIUS, angle_A)\n", "coil_A_f = translate(rotate(points_f, angle_A), COIL_CENTER_RADIUS, angle_A)\n",
"coil_A_b = translate(rotate(points_b, angle_A), COIL_CENTER_RADIUS, angle_A)\n", "coil_A_b = translate(rotate(points_b, angle_A), COIL_CENTER_RADIUS, angle_A)\n",
@ -368,7 +378,7 @@
"vias.append(create_via(get_arc_point(angle_C_opp, COIL_CENTER_RADIUS)))\n", "vias.append(create_via(get_arc_point(angle_C_opp, COIL_CENTER_RADIUS)))\n",
"\n", "\n",
"# connect the front copper opposite coils together\n", "# connect the front copper opposite coils together\n",
"common_connection_radius = STATOR_RADIUS - (VIA_DIAM / 2 + TRACK_SPACING)\n", "common_connection_radius = MAX_TRACK_RADIUS - (VIA_DIAM / 2 + TRACK_SPACING)\n",
"common_coil_connections_b = draw_arc(angle_A_opp, angle_C_opp, common_connection_radius)\n", "common_coil_connections_b = draw_arc(angle_A_opp, angle_C_opp, common_connection_radius)\n",
"coil_A_opp_f.append(get_arc_point(angle_A_opp, common_connection_radius))\n", "coil_A_opp_f.append(get_arc_point(angle_A_opp, common_connection_radius))\n",
"coil_B_opp_f.append(get_arc_point(angle_B_opp, common_connection_radius))\n", "coil_B_opp_f.append(get_arc_point(angle_B_opp, common_connection_radius))\n",
@ -380,27 +390,6 @@
"vias.append(create_via(get_arc_point(angle_B_opp, common_connection_radius)))\n", "vias.append(create_via(get_arc_point(angle_B_opp, common_connection_radius)))\n",
"vias.append(create_via(get_arc_point(angle_C_opp, common_connection_radius)))\n", "vias.append(create_via(get_arc_point(angle_C_opp, common_connection_radius)))\n",
"\n", "\n",
"# connect the coils to the pads\n",
"coil_A_f.append(get_arc_point(angle_A, common_connection_radius))\n",
"coil_B_f.append(get_arc_point(angle_B, common_connection_radius))\n",
"coil_C_f.append(get_arc_point(angle_C, common_connection_radius))\n",
"\n",
"tracks_f.append(\n",
" [get_arc_point(angle_A - 30, CONNECTION_PINS_RADIUS)]\n",
" + draw_arc(angle_A - 30, angle_A + 30, common_connection_radius)\n",
" + [get_arc_point(angle_A + 30, CONNECTION_PINS_RADIUS)]\n",
")\n",
"tracks_f.append(\n",
" [get_arc_point(angle_B - 30, CONNECTION_PINS_RADIUS)]\n",
" + draw_arc(angle_B - 30, angle_B + 30, common_connection_radius)\n",
" + [get_arc_point(angle_B + 30, CONNECTION_PINS_RADIUS)]\n",
")\n",
"tracks_f.append(\n",
" [get_arc_point(angle_C - 30, CONNECTION_PINS_RADIUS)]\n",
" + draw_arc(angle_C - 30, angle_C + 30, common_connection_radius)\n",
" + [get_arc_point(angle_C + 30, CONNECTION_PINS_RADIUS)]\n",
")\n",
"\n",
"# wires for connecting to opposite coils\n", "# wires for connecting to opposite coils\n",
"connection_radius1 = STATOR_HOLE_RADIUS + (2 * TRACK_SPACING)\n", "connection_radius1 = STATOR_HOLE_RADIUS + (2 * TRACK_SPACING)\n",
"connection_radius2 = connection_radius1 + (TRACK_SPACING + VIA_DIAM / 2)\n", "connection_radius2 = connection_radius1 + (TRACK_SPACING + VIA_DIAM / 2)\n",
@ -451,7 +440,68 @@
" create_silk(get_arc_point(angle_A, COIL_CENTER_RADIUS), \"A\"),\n", " create_silk(get_arc_point(angle_A, COIL_CENTER_RADIUS), \"A\"),\n",
" create_silk(get_arc_point(angle_B, COIL_CENTER_RADIUS), \"B\"),\n", " create_silk(get_arc_point(angle_B, COIL_CENTER_RADIUS), \"B\"),\n",
" create_silk(get_arc_point(angle_C, COIL_CENTER_RADIUS), \"C\"),\n", " create_silk(get_arc_point(angle_C, COIL_CENTER_RADIUS), \"C\"),\n",
"]" "]\n",
"\n",
"# create mounting holes at 45 degree angles\n",
"mounting_holes = [\n",
" create_mounting_hole(get_arc_point(angle, SCREW_HOLE_RADIUS), SCREW_HOLE_DRILL_DIAM)\n",
" for angle in [45, 135, 225, 315]\n",
"]\n",
"\n",
"# connect the coils to the input pads\n",
"# coil_A_f.append(get_arc_point(angle_A, common_connection_radius))\n",
"# coil_B_f.append(get_arc_point(angle_B, common_connection_radius))\n",
"# coil_C_f.append(get_arc_point(angle_C, common_connection_radius))\n",
"\n",
"# tracks_f.append(\n",
"# [get_arc_point(angle_A - 30, CONNECTION_PINS_RADIUS)]\n",
"# + draw_arc(angle_A - 30, angle_A + 30, common_connection_radius)\n",
"# + [get_arc_point(angle_A + 30, CONNECTION_PINS_RADIUS)]\n",
"# )\n",
"# tracks_f.append(\n",
"# [get_arc_point(angle_B - 30, CONNECTION_PINS_RADIUS)]\n",
"# + draw_arc(angle_B - 30, angle_B + 30, common_connection_radius)\n",
"# + [get_arc_point(angle_B + 30, CONNECTION_PINS_RADIUS)]\n",
"# )\n",
"# tracks_f.append(\n",
"# [get_arc_point(angle_C - 30, CONNECTION_PINS_RADIUS)]\n",
"# + draw_arc(angle_C - 30, angle_C + 30, common_connection_radius)\n",
"# + [get_arc_point(angle_C + 30, CONNECTION_PINS_RADIUS)]\n",
"# )\n",
"\n",
"# create the pins at CONNECTION_PINS radius - 2 for each of the coils, A, B and C\n",
"# pins.append(create_pin(CONNECTION_PINS_RADIUS, angle_A - 30, \"A\"))\n",
"# pins.append(create_pin(CONNECTION_PINS_RADIUS, angle_A + 30, \"A\"))\n",
"\n",
"# pins.append(create_pin(CONNECTION_PINS_RADIUS, angle_B - 30, \"B\"))\n",
"# pins.append(create_pin(CONNECTION_PINS_RADIUS, angle_B + 30, \"B\"))\n",
"\n",
"# pins.append(create_pin(CONNECTION_PINS_RADIUS, angle_C - 30, \"C\"))\n",
"# pins.append(create_pin(CONNECTION_PINS_RADIUS, angle_C + 30, \"C\"))\n",
"\n",
"\n",
"# create the pads for connecting the inputs to the coils\n",
"pads.append(create_pad((-PAD_PITCH, INPUT_PAD_RADIUS), PAD_HEIGHT, PAD_WIDTH, \"b\"))\n",
"pads.append(create_pad((0, INPUT_PAD_RADIUS), PAD_HEIGHT, PAD_WIDTH, \"b\"))\n",
"pads.append(create_pad((PAD_PITCH, INPUT_PAD_RADIUS), PAD_HEIGHT, PAD_WIDTH, \"b\"))\n",
"\n",
"# connect coil A to the top pad\n",
"coil_A_f.append((INPUT_PAD_RADIUS, PAD_PITCH))\n",
"# connect coil B to the middle pad\n",
"input_pad_connection_radius = STATOR_RADIUS - TRACK_SPACING - TRACK_WIDTH\n",
"tracks_f.append(\n",
" [(INPUT_PAD_RADIUS, 0)] + draw_arc(0, angle_B, input_pad_connection_radius, 5)\n",
")\n",
"# connect coil C to the bottom pad\n",
"tracks_f.append(\n",
" draw_arc(angle_C, 350, input_pad_connection_radius, 5)\n",
" + [(INPUT_PAD_RADIUS, -PAD_PITCH)]\n",
")\n",
"coil_B_f.append(get_arc_point(angle_B, input_pad_connection_radius))\n",
"coil_C_f.append(get_arc_point(angle_C, input_pad_connection_radius))\n",
"vias.append(create_via((INPUT_PAD_RADIUS, 0)))\n",
"vias.append(create_via((INPUT_PAD_RADIUS, PAD_PITCH)))\n",
"vias.append(create_via((INPUT_PAD_RADIUS, -PAD_PITCH)))"
] ]
}, },
{ {
@ -466,15 +516,17 @@
" STATOR_RADIUS,\n", " STATOR_RADIUS,\n",
" STATOR_HOLE_RADIUS,\n", " STATOR_HOLE_RADIUS,\n",
" TRACK_WIDTH,\n", " TRACK_WIDTH,\n",
" PAD_DIAM,\n", " PIN_DIAM,\n",
" PAD_DRILL,\n", " PIN_DRILL,\n",
" VIA_DIAM,\n", " VIA_DIAM,\n",
" VIA_DRILL,\n", " VIA_DRILL,\n",
" vias,\n", " vias,\n",
" pins,\n",
" pads,\n", " pads,\n",
" silk,\n", " silk,\n",
" tracks_f,\n", " tracks_f,\n",
" tracks_b,\n", " tracks_b,\n",
" mounting_holes,\n",
")" ")"
] ]
}, },

36
coil_plugin.py
View file

@ -44,8 +44,8 @@ class CoilPlugin(pcbnew.ActionPlugin):
track_width = coil_data["parameters"]["trackWidth"] track_width = coil_data["parameters"]["trackWidth"]
stator_hole_radius = coil_data["parameters"]["statorHoleRadius"] stator_hole_radius = coil_data["parameters"]["statorHoleRadius"]
stator_radius = coil_data["parameters"]["statorRadius"] stator_radius = coil_data["parameters"]["statorRadius"]
pad_diameter = coil_data["parameters"]["padDiameter"] pin_diameter = coil_data["parameters"]["pinDiameter"]
pad_drill = coil_data["parameters"]["padDrillDiameter"] pin_drill = coil_data["parameters"]["pinDrillDiameter"]
via_diameter = coil_data["parameters"]["viaDiameter"] via_diameter = coil_data["parameters"]["viaDiameter"]
via_drill_diameter = coil_data["parameters"]["viaDrillDiameter"] via_drill_diameter = coil_data["parameters"]["viaDrillDiameter"]
@ -82,21 +82,39 @@ class CoilPlugin(pcbnew.ActionPlugin):
board.Add(pcb_via) board.Add(pcb_via)
# pcb_group.AddItem(pcb_via) # pcb_group.AddItem(pcb_via)
# create the pads # create the pins
for pad in coil_data["pads"]: for pin in coil_data["pins"]:
module = pcbnew.FOOTPRINT(board) module = pcbnew.FOOTPRINT(board)
module.SetPosition(pcbnew.wxPointMM(pad["x"], pad["y"])) module.SetPosition(pcbnew.wxPointMM(pin["x"], pin["y"]))
board.Add(module) board.Add(module)
pcb_pad = pcbnew.PAD(module) pcb_pad = pcbnew.PAD(module)
pcb_pad.SetSize(pcbnew.wxSizeMM(pad_diameter, pad_diameter)) pcb_pad.SetSize(pcbnew.wxSizeMM(pin_diameter, pin_diameter))
pcb_pad.SetShape(pcbnew.PAD_SHAPE_CIRCLE) pcb_pad.SetShape(pcbnew.PAD_SHAPE_CIRCLE)
pcb_pad.SetAttribute(pcbnew.PAD_ATTRIB_PTH) pcb_pad.SetAttribute(pcbnew.PAD_ATTRIB_PTH)
pcb_pad.SetLayerSet(pcb_pad.PTHMask()) pcb_pad.SetLayerSet(pcb_pad.PTHMask())
pcb_pad.SetDrillSize(pcbnew.wxSizeMM(pad_drill, pad_drill)) pcb_pad.SetDrillSize(pcbnew.wxSizeMM(pin_drill, pin_drill))
pcb_pad.SetPosition(pcbnew.wxPointMM(pad["x"], pad["y"])) pcb_pad.SetPosition(pcbnew.wxPointMM(pin["x"], pin["y"]))
pcb_pad.SetNetCode(net.GetNetCode()) pcb_pad.SetNetCode(net.GetNetCode())
module.Add(pcb_pad) module.Add(pcb_pad)
# create the pads
lset = pcbnew.LSET()
lset.AddLayer(pcbnew.B_Cu)
for pin in coil_data["pads"]:
module = pcbnew.FOOTPRINT(board)
module.SetPosition(pcbnew.wxPointMM(pin["x"], pin["y"]))
board.Add(module)
pcb_pad = pcbnew.PAD(module)
pcb_pad.SetSize(pcbnew.wxSizeMM(pin["width"], pin["height"]))
pcb_pad.SetShape(pcbnew.PAD_SHAPE_RECT)
pcb_pad.SetAttribute(pcbnew.PAD_ATTRIB_SMD)
pcb_pad.SetLayerSet(pcb_pad.SMDMask())
# pcb_pad.SetLayerSet(lset)
pcb_pad.SetPosition(pcbnew.wxPointMM(pin["x"], pin["y"]))
pcb_pad.SetNetCode(net.GetNetCode())
pcb_pad.Flip(pcbnew.wxPointMM(pin["x"], pin["y"]), False)
module.Add(pcb_pad)
# create any silk screen # create any silk screen
for text in coil_data["silk"]: for text in coil_data["silk"]:
pcb_txt = pcbnew.PCB_TEXT(board) pcb_txt = pcbnew.PCB_TEXT(board)
@ -108,7 +126,6 @@ class CoilPlugin(pcbnew.ActionPlugin):
board.Add(pcb_txt) board.Add(pcb_txt)
# pcb_group.AddItem(pcb_txt) # pcb_group.AddItem(pcb_txt)
# create the stator outline # create the stator outline
arc = pcbnew.PCB_SHAPE(board) arc = pcbnew.PCB_SHAPE(board)
arc.SetShape(pcbnew.SHAPE_T_CIRCLE) arc.SetShape(pcbnew.SHAPE_T_CIRCLE)
@ -133,4 +150,5 @@ class CoilPlugin(pcbnew.ActionPlugin):
board.Add(arc) board.Add(arc)
# pcb_group.AddItem(arc) # pcb_group.AddItem(arc)
CoilPlugin().register() # Instantiate and register to Pcbnew]) CoilPlugin().register() # Instantiate and register to Pcbnew])

BIN
coils.png Normal file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 420 KiB

24
helpers.py
View file

@ -49,30 +49,6 @@ def flip_x(points):
return [[-x, y] for x, y in points] return [[-x, y] for x, y in points]
def create_pad(radius, angle, name):
return {
"x": radius * np.cos(np.deg2rad(angle)),
"y": radius * np.sin(np.deg2rad(angle)),
"name": name,
}
def create_silk(point, text):
return {
"x": point[0],
"y": point[1],
"text": text,
}
def create_via(point):
return {"x": point[0], "y": point[1]}
def create_track(points):
return [{"x": x, "y": y} for x, y in points]
def optimize_points(points): def optimize_points(points):
# follow the line and remove points that are in the same direction as the previous poin # follow the line and remove points that are in the same direction as the previous poin
# keep doing this until the direction changes significantly # keep doing this until the direction changes significantly

163
pcb_json.py
View file

@ -1,26 +1,71 @@
import json import json
import pandas as pd import pandas as pd
import numpy as np
import matplotlib.pyplot as plt import matplotlib.pyplot as plt
def create_pin(radius, angle, name):
return {
"x": radius * np.cos(np.deg2rad(angle)),
"y": radius * np.sin(np.deg2rad(angle)),
"name": name,
}
def create_pad(point, width, height, layer):
return {
"x": point[0],
"y": point[1],
"width": width,
"height": height,
"layer": layer,
}
def create_silk(point, text):
return {
"x": point[0],
"y": point[1],
"text": text,
}
def create_via(point):
return {"x": point[0], "y": point[1]}
def create_track(points): def create_track(points):
return [{"x": x, "y": y} for x, y in points] return [{"x": x, "y": y} for x, y in points]
def create_mounting_hole(point, diameter):
return {
"x": point[0],
"y": point[1],
"diameter": diameter,
}
def create_track_json(points):
return [{"x": x, "y": y} for x, y in points]
def dump_json( def dump_json(
filename, filename,
stator_radius, stator_radius,
stator_hole_radius, stator_hole_radius,
track_width, track_width,
pad_diam, pin_diam,
pad_drill, pin_drill,
via_diam, via_diam,
via_drill, via_drill,
vias, vias,
pins,
pads, pads,
silk, silk,
tracks_f, tracks_f,
tracks_b, tracks_b,
mounting_holes,
): ):
# dump out the results to json # dump out the results to json
json_result = { json_result = {
@ -30,16 +75,18 @@ def dump_json(
"statorRadius": stator_radius, "statorRadius": stator_radius,
"viaDiameter": via_diam, "viaDiameter": via_diam,
"viaDrillDiameter": via_drill, "viaDrillDiameter": via_drill,
"padDiameter": pad_diam, "pinDiameter": pin_diam,
"padDrillDiameter": pad_drill, "pinDrillDiameter": pin_drill,
}, },
"vias": vias, "vias": vias,
"pins": pins,
"pads": pads, "pads": pads,
"silk": silk, "silk": silk,
"tracks": { "tracks": {
"f": [create_track(points) for points in tracks_f], "f": [create_track_json(points) for points in tracks_f],
"b": [create_track(points) for points in tracks_b], "b": [create_track_json(points) for points in tracks_b],
}, },
"mounting_holes": mounting_holes,
} }
json.dump(json_result, open(filename, "w")) json.dump(json_result, open(filename, "w"))
return json_result return json_result
@ -48,8 +95,8 @@ def dump_json(
def plot_json(json_result): def plot_json(json_result):
stator_radius = json_result["parameters"]["statorRadius"] stator_radius = json_result["parameters"]["statorRadius"]
stator_hole_radius = json_result["parameters"]["statorHoleRadius"] stator_hole_radius = json_result["parameters"]["statorHoleRadius"]
pad_diam = json_result["parameters"]["padDiameter"] pin_diam = json_result["parameters"]["pinDiameter"]
pad_drill = json_result["parameters"]["padDrillDiameter"] pin_drill = json_result["parameters"]["pinDrillDiameter"]
# track_width = json_result["parameters"]["trackWidth"] # track_width = json_result["parameters"]["trackWidth"]
via_dim = json_result["parameters"]["viaDiameter"] via_dim = json_result["parameters"]["viaDiameter"]
via_drill = json_result["parameters"]["viaDrillDiameter"] via_drill = json_result["parameters"]["viaDrillDiameter"]
@ -69,7 +116,57 @@ def plot_json(json_result):
# hide the legend # hide the legend
ax.legend().set_visible(False) ax.legend().set_visible(False)
# make the plot bigger # make the plot bigger
ax.figure.set_size_inches(10, 10) ax.figure.set_size_inches(11, 11)
# set the axis range
ax.set_xlim(-stator_radius - 1, stator_radius + 1)
ax.set_ylim(-stator_radius - 1, stator_radius + 1)
# plot the pads
for pad in json_result["pads"]:
color = "red"
if pad["layer"] == "b":
color = "blue"
ax.add_patch(
plt.Rectangle(
(pad["x"] - pad["width"] / 2, pad["y"] - pad["height"] / 2),
pad["width"],
pad["height"],
fill=True,
color=color,
)
)
# plot the pins
for pin in json_result["pins"]:
ax.add_patch(
plt.Circle(
(pin["x"], pin["y"]),
radius=pin_diam / 2,
fill=True,
color="orange",
)
)
ax.add_patch(
plt.Circle(
(pin["x"], pin["y"]),
radius=pin_drill / 2,
fill=True,
color="white",
)
)
# plot the silk
for silk in json_result["silk"]:
ax.text(
silk["x"],
silk["y"],
silk["text"],
horizontalalignment="center",
verticalalignment="center",
color="black",
fontsize=50,
)
# plot the vias # plot the vias
for via in json_result["vias"]: for via in json_result["vias"]:
@ -90,13 +187,24 @@ def plot_json(json_result):
) )
) )
# plot the mounting holes
for hole in json_result["mounting_holes"]:
ax.add_patch(
plt.Circle(
(hole["x"], hole["y"]),
radius=hole["diameter"] / 2,
fill=False,
color="orange",
)
)
# plot the edge cuts # plot the edge cuts
ax.add_patch( ax.add_patch(
plt.Circle( plt.Circle(
(0, 0), (0, 0),
radius=stator_radius, radius=stator_radius,
fill=False, fill=False,
color="yellow", color="orange",
) )
) )
ax.add_patch( ax.add_patch(
@ -104,37 +212,8 @@ def plot_json(json_result):
(0, 0), (0, 0),
radius=stator_hole_radius, radius=stator_hole_radius,
fill=False, fill=False,
color="yellow", color="orange",
) )
) )
# save to file
# plot the pads ax.figure.savefig("coils.png")
for pad in json_result["pads"]:
ax.add_patch(
plt.Circle(
(pad["x"], pad["y"]),
radius=pad_diam / 2,
fill=True,
color="yellow",
)
)
ax.add_patch(
plt.Circle(
(pad["x"], pad["y"]),
radius=pad_drill / 2,
fill=True,
color="white",
)
)
# plot the silk
for silk in json_result["silk"]:
ax.text(
silk["x"],
silk["y"],
silk["text"],
horizontalalignment="center",
verticalalignment="center",
color="black",
fontsize=50,
)