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
pcb-stator-coil-generator/coil.ipynb

477 lines
246 KiB
Text
Raw Normal View History

Arbitrary coil POC
2022-10-01 20:09:14 +00:00
{
"cells": [
{
"cell_type": "code",
Connect coils
2022-10-06 11:47:07 +00:00
"execution_count": 448,
Arbitrary coil POC
2022-10-01 20:09:14 +00:00
"metadata": {},
"outputs": [],
"source": [
"import pandas as pd\n",
"import numpy as np\n",
"import matplotlib as plt\n",
Drive the plugin off json
2022-10-04 17:43:35 +00:00
"import scipy\n",
Tidy up layer handling
2022-10-02 19:15:44 +00:00
"from skspatial.objects import LineSegment\n",
"from enum import Enum"
Arbitrary coil POC
2022-10-01 20:09:14 +00:00
]
},
{
"cell_type": "code",
Connect coils
2022-10-06 11:47:07 +00:00
"execution_count": 449,
fatter coils
2022-10-02 18:46:28 +00:00
"metadata": {},
"outputs": [],
"source": [
Drive the plugin off json
2022-10-04 17:43:35 +00:00
"VIA_DIAM = 0.8\n",
"VIA_DRILL = 0.4\n",
"STATOR_HOLE_RADIUS = 4\n",
Connect coils
2022-10-06 11:46:59 +00:00
"TRACK_WIDTH = 0.2\n",
"TRACK_SPACING = 0.2\n",
"TURNS = 11\n",
Tidy up layer handling
2022-10-02 19:15:44 +00:00
"STATOR_RADIUS = 20\n",
"Layer = Enum('Layer', 'FRONT BACK')"
fatter coils
2022-10-02 18:46:28 +00:00
]
},
{
"cell_type": "code",
Connect coils
2022-10-06 11:47:07 +00:00
"execution_count": 450,
Arbitrary coil POC
2022-10-01 20:09:14 +00:00
"metadata": {},
"outputs": [],
"source": [
"# create a square shape\n",
Working version
2022-10-06 09:18:11 +00:00
"template = [(-1.5, -0.05), (1.5, -1.25), (1.5, 1.25), (-1.5, 0.05)]\n",
"# template = [(-6, -0.05), (6, -3), (6, 3), (-6, 0.05)]\n",
Arbitrary coil POC
2022-10-01 20:09:14 +00:00
"# create a triangle\n",
Working version
2022-10-06 09:18:11 +00:00
"# template = [(-2, 0), (2, -3), (2, 3)]\n",
Arbitrary coil POC
2022-10-01 20:09:14 +00:00
"# interpolate the shape using numpy\n",
"\n",
"# create a circle template\n",
Working version
2022-10-06 09:18:11 +00:00
"# template = [(np.cos(np.deg2rad(theta)), np.sin(np.deg2rad(theta))) for theta in np.linspace(0, 360, 360)]\n",
Arbitrary coil POC
2022-10-01 20:09:14 +00:00
"\n"
]
},
{
"cell_type": "code",
Connect coils
2022-10-06 11:46:59 +00:00
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
Connect coils
2022-10-06 11:47:07 +00:00
"execution_count": 451,
Arbitrary coil POC
2022-10-01 20:09:14 +00:00
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
Connect coils
2022-10-06 11:47:07 +00:00
"[<matplotlib.lines.Line2D at 0x137ceefe0>]"
Arbitrary coil POC
2022-10-01 20:09:14 +00:00
]
},
Connect coils
2022-10-06 11:47:07 +00:00
"execution_count": 451,
Arbitrary coil POC
2022-10-01 20:09:14 +00:00
"metadata": {},
"output_type": "execute_result"
},
{
"data": {
Connect coils
2022-10-06 11:46:59 +00:00
"image/png": "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
Arbitrary coil POC
2022-10-01 20:09:14 +00:00
"text/plain": [
"<Figure size 640x480 with 1 Axes>"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"# plot the template shape wrapping around to the first point\n",
"plt.pyplot.plot([x for x, y in template] + [template[0][0]], [y for x, y in template] + [template[0][1]])"
]
},
{
"cell_type": "code",
Connect coils
2022-10-06 11:47:07 +00:00
"execution_count": 452,
Adds chailin's corner cutting algorithm to smooth corners
2022-10-02 14:38:17 +00:00
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
Connect coils
2022-10-06 11:47:07 +00:00
"[<matplotlib.lines.Line2D at 0x113717100>]"
Adds chailin's corner cutting algorithm to smooth corners
2022-10-02 14:38:17 +00:00
]
},
Connect coils
2022-10-06 11:47:07 +00:00
"execution_count": 452,
Adds chailin's corner cutting algorithm to smooth corners
2022-10-02 14:38:17 +00:00
"metadata": {},
"output_type": "execute_result"
},
{
"data": {
Connect coils
2022-10-06 11:46:59 +00:00
"image/png": "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
Adds chailin's corner cutting algorithm to smooth corners
2022-10-02 14:38:17 +00:00
"text/plain": [
"<Figure size 640x480 with 1 Axes>"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"# apply Chaikin's algorithm to the template - corner cuttine\n",
"def chaikin(arr, iterations):\n",
" if iterations == 0:\n",
" return arr\n",
" l = len(arr)\n",
" smoothed = []\n",
" for i in range(l):\n",
" x1, y1 = arr[i]\n",
" x2, y2 = arr[(i+1)%l]\n",
Working version
2022-10-06 09:18:11 +00:00
" smoothed.append([0.95*x1 + 0.05*x2,0.95*y1 + 0.05*y2])\n",
" smoothed.append([0.05*x1 + 0.95*x2,0.05*y1 + 0.95*y2])\n",
Adds chailin's corner cutting algorithm to smooth corners
2022-10-02 14:38:17 +00:00
" return chaikin(smoothed, iterations - 1)\n",
"\n",
plot multiple coils
2022-10-02 15:50:49 +00:00
"template = chaikin(template, 2)\n",
Adds chailin's corner cutting algorithm to smooth corners
2022-10-02 14:38:17 +00:00
"plt.pyplot.plot([x for x, y in template] + [template[0][0]], [y for x, y in template] + [template[0][1]]) "
]
},
{
"cell_type": "code",
Connect coils
2022-10-06 11:47:07 +00:00
"execution_count": 453,
Arbitrary coil POC
2022-10-01 20:09:14 +00:00
"metadata": {},
"outputs": [],
"source": [
plot multiple coils
2022-10-02 15:50:49 +00:00
"# this speeds things up dramatically as we only have to compute the line intersections once\n",
"# there are probably much faster ways of doing this - we're just doing a brute force search\n",
"# for the intersections - consult algorithms from games for inspiration...\n",
"def get_template_point_cache(template):\n",
" # sweep a line from the origin through 360 degress times the number of turns in 1 degree increments\n",
" # and find the intersection points with the template shape\n",
" cache = {}\n",
Working version
2022-10-06 09:18:11 +00:00
" for angle in np.arange(0, 360+2, 2):\n",
plot multiple coils
2022-10-02 15:50:49 +00:00
" line = LineSegment(np.array([0, 0]), np.array([1000 * np.cos(np.deg2rad(angle)), 1000 * np.sin(np.deg2rad(angle))]))\n",
" for i in range(len(template)):\n",
" segment = LineSegment(np.array(template[i]), np.array(template[(i + 1) % len(template)]))\n",
" try:\n",
" intersection = line.intersect_line_segment(segment)\n",
" if intersection is not None:\n",
" cache[angle] = (intersection, segment)\n",
" except ValueError:\n",
" pass\n",
" return cache\n",
Arbitrary coil POC
2022-10-01 20:09:14 +00:00
"\n",
Tidy up layer handling
2022-10-02 19:15:44 +00:00
"# get the points in a coil shape\n",
"# Use reverse for bottom layer (basically flips the y coordinate so that the coil goes in the opposite direction)\n",
"# Also rotates the endpoints by 90 degress so that the exit point on the bottom layer is to the left hand side\n",
"def get_points(template, turns, spacing, layer=Layer.FRONT, cache = None):\n",
plot multiple coils
2022-10-02 15:50:49 +00:00
" if cache is None:\n",
" cache = get_template_point_cache(template)\n",
" points = []\n",
Working version
2022-10-06 09:18:11 +00:00
" for angle in np.arange(0, 360 * turns + 2, 2):\n",
plot multiple coils
2022-10-02 15:50:49 +00:00
" offset = spacing * angle / 360\n",
Tidy up layer handling
2022-10-02 19:15:44 +00:00
" if layer == Layer.BACK:\n",
" angle = angle + 180\n",
" intersection, segment = cache[angle % 360]\n",
plot multiple coils
2022-10-02 15:50:49 +00:00
" vector = np.array(segment.point_a) - np.array(segment.point_b)\n",
" normal = vector / np.linalg.norm(vector)\n",
" # rotate the vector 90 degrees\n",
" normal = np.array([-normal[1], normal[0]])\n",
" # move the intersection point along the normal vector by the spacing\n",
Tidy up layer handling
2022-10-02 19:15:44 +00:00
" coil_point = intersection + normal * offset\n",
" if layer == Layer.BACK:\n",
" points.append((coil_point[0], -coil_point[1]))\n",
" else:\n",
" points.append(coil_point)\n",
plot multiple coils
2022-10-02 15:50:49 +00:00
" return points\n"
]
},
{
"cell_type": "code",
Connect coils
2022-10-06 11:47:07 +00:00
"execution_count": 454,
plot multiple coils
2022-10-02 15:50:49 +00:00
"metadata": {},
"outputs": [],
"source": [
"cache = get_template_point_cache(template)"
]
},
{
"cell_type": "code",
Connect coils
2022-10-06 11:47:07 +00:00
"execution_count": 455,
plot multiple coils
2022-10-02 15:50:49 +00:00
"metadata": {},
"outputs": [
{
Working version
2022-10-06 09:18:11 +00:00
"name": "stdout",
"output_type": "stream",
"text": [
"180 300 420\n"
]
plot multiple coils
2022-10-02 15:50:49 +00:00
}
],
"source": [
Drive the plugin off json
2022-10-04 17:43:35 +00:00
"points_f = [(0,0)] + get_points(template, TURNS, TRACK_SPACING+TRACK_WIDTH, Layer.FRONT, cache) \n",
"points_b = [(0,0)] + get_points(template, TURNS, TRACK_SPACING+TRACK_WIDTH, Layer.BACK, cache)\n",
plot multiple coils
2022-10-02 15:50:49 +00:00
"\n",
Working version
2022-10-06 09:18:11 +00:00
"COIL_CENTER_RADIUS = STATOR_RADIUS/2+1.5\n",
plot multiple coils
2022-10-02 15:50:49 +00:00
"\n",
"angle_A = 0\n",
"angle_B = 120\n",
"angle_C = 240\n",
"\n",
"# roate the points by the required angle\n",
"def rotate(points, angle):\n",
" return [[x * np.cos(np.deg2rad(angle)) - y * np.sin(np.deg2rad(angle)), x * np.sin(np.deg2rad(angle)) + y * np.cos(np.deg2rad(angle))] for x, y in points]\n",
"\n",
"# move the points out to the distance at the requited angle\n",
"def translate(points, distance, angle):\n",
" return [[x + distance * np.cos(np.deg2rad(angle)), y + distance * np.sin(np.deg2rad(angle))] for x, y in points]\n",
"\n",
Drive the plugin off json
2022-10-04 17:43:35 +00:00
"# flip the y coordinate\n",
"def flip(points):\n",
" return [[x, -y] for x, y in points]\n",
"\n",
"# the main coils\n",
Tidy up layer handling
2022-10-02 19:15:44 +00:00
"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",
plot multiple coils
2022-10-02 15:50:49 +00:00
"\n",
Drive the plugin off json
2022-10-04 17:43:35 +00:00
"coil_B_f = translate(rotate(points_f, angle_B), COIL_CENTER_RADIUS, angle_B)\n",
"coil_B_b = translate(rotate(points_b, angle_B), COIL_CENTER_RADIUS, angle_B)\n",
"\n",
"coil_C_f = translate(rotate(points_f, angle_C), COIL_CENTER_RADIUS, angle_C)\n",
"coil_C_b = translate(rotate(points_b, angle_C), COIL_CENTER_RADIUS, angle_C)\n",
"\n",
"# the opposite coils - for more power!\n",
"angle_A_opp = angle_A + 180\n",
"angle_B_opp = angle_B + 180\n",
"angle_C_opp = angle_C + 180\n",
"\n",
Working version
2022-10-06 09:18:11 +00:00
"print(angle_A_opp, angle_B_opp, angle_C_opp)\n",
"\n",
"coil_A_opp_f = translate(rotate(flip(points_f),angle_A_opp), COIL_CENTER_RADIUS, angle_A_opp)\n",
"coil_A_opp_b = translate(rotate(flip(points_b), angle_A_opp), COIL_CENTER_RADIUS,angle_A_opp)\n",
Drive the plugin off json
2022-10-04 17:43:35 +00:00
"\n",
Working version
2022-10-06 09:18:11 +00:00
"coil_B_opp_f = translate(rotate(flip(points_f),angle_B_opp), COIL_CENTER_RADIUS, angle_B_opp)\n",
Drive the plugin off json
2022-10-04 17:43:35 +00:00
"coil_B_opp_b = translate(rotate(flip(points_b), angle_B_opp), COIL_CENTER_RADIUS, angle_B_opp)\n",
"\n",
"coil_C_opp_f = translate(rotate(flip(points_f), angle_C_opp), COIL_CENTER_RADIUS, angle_C_opp)\n",
"coil_C_opp_b = translate(rotate(flip(points_b), angle_C_opp), COIL_CENTER_RADIUS, angle_C_opp)\n",
"\n",
Connect coils
2022-10-06 11:46:59 +00:00
"# connect the front copper opposite coils together\n",
Working version
2022-10-06 09:18:11 +00:00
"common_connection_radius = STATOR_RADIUS - (TRACK_WIDTH+TRACK_SPACING) \n",
"common_coil_connections_b = [\n",
" (common_connection_radius * np.cos(np.deg2rad(angle)), common_connection_radius * np.sin(np.deg2rad(angle)))\n",
" for angle in np.arange(angle_A_opp, angle_C_opp+5, 5)\n",
"]\n",
"coil_A_opp_f.append((common_connection_radius * np.cos(np.deg2rad(angle_A_opp)), common_connection_radius * np.sin(np.deg2rad(angle_A_opp))))\n",
"coil_B_opp_f.append((common_connection_radius * np.cos(np.deg2rad(angle_B_opp)), common_connection_radius * np.sin(np.deg2rad(angle_B_opp))))\n",
"coil_C_opp_f.append((common_connection_radius * np.cos(np.deg2rad(angle_C_opp)), common_connection_radius * np.sin(np.deg2rad(angle_C_opp))))\n",
"\n",
"# connect coil A to it's opposite\n",
Connect coils
2022-10-06 11:46:59 +00:00
"connection_radius1 = STATOR_HOLE_RADIUS + (TRACK_SPACING)\n",
"connection_radius2 = connection_radius1 + (TRACK_SPACING+VIA_DIAM/2)\n",
"# draw a 45 degree line from coil A at connection radius 1\n",
"# then connect up to connection radius 2\n",
"# draw a 45 degree line to the opposite coil\n",
"coil_A_b.append((connection_radius1 * np.cos(np.deg2rad(angle_A)), connection_radius1 * np.sin(np.deg2rad(angle_A))))\n",
"coil_A_opp_b.append((connection_radius2 * np.cos(np.deg2rad(angle_A_opp)), connection_radius2 * np.sin(np.deg2rad(angle_A_opp))))\n",
"a_connection_b = [\n",
" (connection_radius1 * np.cos(np.deg2rad(angle)), connection_radius1 * np.sin(np.deg2rad(angle)))\n",
" for angle in np.arange(angle_A, angle_A+90+5, 5)\n",
Working version
2022-10-06 09:18:11 +00:00
"]\n",
Connect coils
2022-10-06 11:46:59 +00:00
"a_connection_f = [\n",
" (connection_radius2 * np.cos(np.deg2rad(angle)), connection_radius2 * np.sin(np.deg2rad(angle)))\n",
" for angle in np.arange(angle_A+90, angle_A+180+5, 5)\n",
"]\n",
"a_connection_b.append(a_connection_f[0])\n",
Working version
2022-10-06 09:18:11 +00:00
"\n",
Connect coils
2022-10-06 11:46:59 +00:00
"coil_B_b.append((connection_radius1 * np.cos(np.deg2rad(angle_B)), connection_radius1 * np.sin(np.deg2rad(angle_B))))\n",
"coil_B_opp_b.append((connection_radius2 * np.cos(np.deg2rad(angle_B_opp)), connection_radius2 * np.sin(np.deg2rad(angle_B_opp))))\n",
"b_connection_b = [\n",
" (connection_radius1 * np.cos(np.deg2rad(angle)), connection_radius1 * np.sin(np.deg2rad(angle)))\n",
" for angle in np.arange(angle_B, angle_B+90+5, 5)\n",
"]\n",
"b_connection_f = [\n",
" (connection_radius2 * np.cos(np.deg2rad(angle)), connection_radius2 * np.sin(np.deg2rad(angle)))\n",
" for angle in np.arange(angle_B+90, angle_B+180+5, 5)\n",
"]\n",
"b_connection_b.append(b_connection_f[0])\n",
Working version
2022-10-06 09:18:11 +00:00
"\n",
Connect coils
2022-10-06 11:46:59 +00:00
"coil_C_b.append((connection_radius1 * np.cos(np.deg2rad(angle_C)), connection_radius1 * np.sin(np.deg2rad(angle_C))))\n",
"coil_C_opp_b.append((connection_radius2 * np.cos(np.deg2rad(angle_C_opp)), connection_radius2 * np.sin(np.deg2rad(angle_C_opp))))\n",
"c_connection_b = [\n",
" (connection_radius1 * np.cos(np.deg2rad(angle)), connection_radius1 * np.sin(np.deg2rad(angle)))\n",
" for angle in np.arange(angle_C, angle_C+90+5, 5)\n",
"]\n",
"c_connection_f = [\n",
" (connection_radius2 * np.cos(np.deg2rad(angle)), connection_radius2 * np.sin(np.deg2rad(angle)))\n",
" for angle in np.arange(angle_C+90, angle_C+180+5, 5)\n",
"]\n",
"c_connection_b.append(c_connection_f[0])\n",
Working version
2022-10-06 09:18:11 +00:00
"\n"
]
},
{
"cell_type": "code",
Connect coils
2022-10-06 11:47:07 +00:00
"execution_count": 456,
Working version
2022-10-06 09:18:11 +00:00
"metadata": {},
"outputs": [],
"source": [
"\n",
"def create_track(points):\n",
" return [{\"x\": x, \"y\": y} for x, y in points]"
]
},
{
"cell_type": "code",
Connect coils
2022-10-06 11:47:07 +00:00
"execution_count": 457,
Working version
2022-10-06 09:18:11 +00:00
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
Connect coils
2022-10-06 11:47:07 +00:00
"(3.548111111111111, 17.889666666666667, -5.67602742669668, 5.588103630747186)"
Working version
2022-10-06 09:18:11 +00:00
]
},
Connect coils
2022-10-06 11:47:07 +00:00
"execution_count": 457,
Working version
2022-10-06 09:18:11 +00:00
"metadata": {},
"output_type": "execute_result"
},
{
"data": {
Connect coils
2022-10-06 11:47:07 +00:00
"image/png": "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
Working version
2022-10-06 09:18:11 +00:00
"text/plain": [
"<Figure size 640x480 with 1 Axes>"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
Connect coils
2022-10-06 11:47:07 +00:00
"image/png": "iVBORw0KGgoAAAANSUhEUgAAAiIAAAGwCAYAAACU8g7/AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy89olMNAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOyddVhU2/fGXzrs7u6gFMFGr9119doFKlio17z3qmO3AoKgAip2dxeK0o2EhQEK0h0TZ//+mN+cL9yrzp7BQdT9eR4e5cA7e88wc846e6/1LjVCCAGDwWAwGAzGd0D9e0+AwWAwGAzGrwsLRBgMBoPBYHw3WCDCYDAYDAbju8ECEQaDwWAwGN8NFogwGAwGg8H4brBAhMFgMBgMxneDBSIMBoPBYDC+G5rfewJfg+M4fPz4ERUqVICamtr3ng6DwWAwGAwKCCHIzs5G3bp1oa7+9TWPMh2IfPz4EQ0aNPje02AwGAwGg6EEcXFxqF+//ld/p0wHIhUqVAAgfSIVK1b8zrNhMBgMBoNBQ1ZWFho0aMBfx79GmQ5EZNsxFStWZIEIg8FgMBg/GDRpFSxZlcFgMBgMxneDBSIMBoPBYDC+GywQYTAYDAaD8d0o0zkiDAaDwWCUBIlEApFI9L2n8dOhpaUFDQ2Nb/JYLBBhMBgMxk8HIQSJiYnIyMj43lP5aalcuTJq165dYp8vFogwGAwG46dDFoTUrFkT+vr6zBTzG0IIQV5eHpKSkgAAderUKdHjsUCEwWAwGD8VEomED0KqVav2vafzU6KnpwcASEpKQs2aNUu0TcOSVRkMBoPxUyHLCdHX1//OM/m5kb2+Jc3BYYEIg8FgMH5K2HaMavlWry8LRBgMBoPBYHw3WCDCYDAYDAbju8ECEQaDwWAwfjIEAgGMjY3576dPn46RI0d+t/l8DRaIMBiMnwpCCBKyE/Ap5xMyCzJRIC4AIeR7T4vBoCYxMRELFixA06ZNoaOjgwYNGmDYsGG4f/8+9WMsXbpUod/39PSEmpoa/6Wnp4d27drhwIEDyjwFhWDluwwG46cgMScRR0KPwD3UHS9SX/zn59oa2tDV1IWupi50NHSk/2rqfP37Lxyn0n7mex0NHZZAyfgqb9++Rbdu3VC5cmXs2LEDBgYGEIlEuH37NubNm4eYmBiqxylfvjzKly+v8PjPnz9HxYoVkZ+fj6tXr8LGxgbNmjVDnz59FH4sWlggwmAwflhEEhFuvLwB91B3XH9xHRIiAQCoq6mDI1yx3xVKhBBKhMgqzPoeU+VhAdH3gRCCPFFeqY+rr6WYmdrcuXOhpqYGf39/lCtXjj/erl07zJw5k//+/fv3WLBgAe7fvw91dXUMHDgQe/fuRa1atQBIt2YuXbqE0NBQheZbs2ZNVK5cGQCwcOFCODg4IDg4mAUiDAaDUZSYlBi4h7jDI8wDn3I/8ce7NuiKmcYzMa7dOJTXLg8RJ0KBuACF4kLpv5LCz35P8zv/+f5fx7/2u0UpKwGRjoaO4kHMv44rGgDpaupCT1MP1fWrl3oglCfKQ/ktiq8QlJScVTkop11O/i8CSEtLw61bt7Bp06ZiQYgMWYDAcRxGjBiB8uXL49GjRxCLxZg3bx7++OMPeHp6fpN5E0Jw+/ZtvH//Hubm5t/kMb8EC0QYDMYPQb4oH6eenYJbiBuexj3lj9csVxNTDadipslMtKnRpphGW0Mb2hragE5pz/Z/EELKZEBUKClEoaTwuwRELau1xKwOszDTZCaq6lUt9fHLKq9evQIhBK1bt/7q792/fx8RERF48+YNGjRoAADw8PBAu3btEBAQgE6dOik9h/r16wMACgsLwXEc1q9fj549eyr9eDSwQITBYJRpYtNj4RzgDPdQd6TlpwGQbr0MbjEYliaWGNJiCLQ0tL7zLL+MmpraDxMQKRQAfSEgovndF6kvsOzuMjj6OyJ4TnCpBCP6WvrIWZWj8nE+Ny4ttEnV0dHRaNCgAR+EAEDbtm1RuXJlREdHlygQ8fLyQoUKFVBYWAh/f3/Mnz8fVatWhY2NjdKPKQ8WiDAYjDIHRzjcfX0XjgGOuP7iOgikJ+hGlRphTsc5mGY8DXUr1P3Os/yxKCsBUXZhNk49O4WNXhvxLvMdrK9Z4/Tvp1W+VaOmpka9RfK9aNGiBdTU1KgTUlVBkyZN+C2gdu3awc/PD5s2bVJpIMLKdxkMRpkhoyADdr52aOXYCgOPD8S1F9dAQDCg2QBcGX8Frxe+xqoeq1gQ8gNTQacCZnWchXNjz0FDTQNno87iWPix7z2tMkHVqlUxYMAAODk5ITc39z8/z8jIAAC0adMGcXFxiIuL438WFRWFjIwMtG3b9pvOSUNDA/n5+d/0Mf8NC0QYDMZ3JyYlBvOuz0P93fWx+PZivEp7hUo6lbDIfBGez3+OW5NvYVirYdBQV77DJ6Ns0aleJwh6CQAA827Mw9uMt991PmUFJycnSCQSmJmZ4fz583j58iWio6Ph4OCALl26AAD69u0LAwMDTJo0CcHBwfD398fUqVNhYWEBU1PTEo2flJSExMREvHv3DmfPnsXRo0cxYsSIb/HUvgjbmmEwGN8FjnC4/eo27P3scfv1bf54+5rtMb/TfEwynITy2qVf5cAoPVZ2X4mbr27CO84bUy5Ogec0z18+2GzatCmCg4OxadMm/Pnnn0hISECNGjXQsWNHODs7A5BuM12+fBkLFixAz549i5XvlpRWrVoBADQ1NdGgQQPMmTMHAoGgxI/7NdRIGbYczMrKQqVKlZCZmYmKFSt+7+kwGIxvQHZhNo6EHcFe/7288Zga1DC81XDYmtuiV+Nev5zHxa9MbHosjFyMkCPMwZY+W7Cy+8oSP2ZBQQHevHmDJk2aQFdX9xvMkvE5vvY6K3L9ZisiDAajVIhNj4WjvyPcQtz4ktGKOhVhaWKJ+Wbz0bRK0+88Q8b3oGmVptg7aC9mXJ6B1Q9Xo3+z/uhQp8P3nhajFGGBCIPBUBmEEDx8+xD2fva4+vwqX/3SslpLLDRbiGnG09j2CwPTjKbh2otrOB99HpMuTELQ7CCFyl4ZPzYsEGEwGN8coUSIU89OYaf3TkQkRfDHBzYfiIVmCzGg+QCoq6k+V14oEeLK8ys4+ewkMgoyeKfPrzmGyrNGl/ezXz3HQRnU1NSwf+h+eMd5IyYlBsvvLofjYMfvPS1GKcECEQaD8c3ILMjEgaADsPezx4fsDwCAclrlMM1oGhaYL0Dr6l93jPxWPEt6BrdgNxyLOIaUvJRSGVOGhprGf4KVr9mf62jqQFdD+cDnSz/T1tD+oXJtqulXw+GRhzHg2AA4BThhcIvBGNxicIkeswynQP4UfKvXlwUiDAajxMRlxsHezx4Hgg4gW5gNAKhdvjZszW0xp+McVNGrovI5ZBZk4tSzU3APdYf/B3/+eN0KdTHdaDra12wvtTX/iutnobgQBZLPO4N+zWFU1mwPACREglxRLnJF//WBKG2+GPiUUlCkr6UPHU1697T+zfrD1twW9n72mHl5JiJsIlCjXA2Fn7eWltRpNy8vD3p6egrrGXTk5UmbCMpeb2VhgQiDwVCa8E/h2Om9EyefnYSYEwMA2tZoi6VdlmKiwUSFLkLKQAiB13svuAa74lzUOeSLpcZLmuqaGN5qOCxNLNG/WX9oqqv2VCfmxF8MVuQGPl/62VcCny/9TCgRFpuX7HFQqNKn/0XUoIb+zfpjdsfZGN5qONXfYUufLbgXew+RyZGYdXUWLv5xUeGVHQ0NDVSuXBlJSUkAAH19xTrgMr4OIQR5eXlISkpC5cqVoaFRsu1IVr7LYDAUJjQxFAJPAS4/v8wf69W4F5Z1XYaBzQeqPP8jR5iDo2FH4RTghMjkSP54m+ptYGliiSlGU1CzXE2VzqEsQgiBUCJULvD5xkERR7hicxvZeiQujLtAFRCEJYbBzNUMQokQB4cdhFUHK6Vei8TERN6NlPHtqVy5MmrXrv3Zv6ki128WiDAYDGqeJT2DwFOA89HnAUibz41tOxZLuy6Fad2SOTrS8DzlOfYF7MPhsMN8CbC+lj4mtp8Iyw6WMK9
Working version
2022-10-06 09:18:11 +00:00
"text/plain": [
"<Figure size 640x480 with 1 Axes>"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
Drive the plugin off json
2022-10-04 17:43:35 +00:00
"\n",
"# dump out the results to json\n",
"json_result = {\n",
" \"parameters\": {\n",
" \"trackWidth\": TRACK_WIDTH,\n",
" \"statorHoleRadius\": STATOR_HOLE_RADIUS,\n",
" \"viaDiameter\": VIA_DIAM,\n",
" \"viaDrillDiameter\": VIA_DRILL\n",
"\n",
" },\n",
" \"vias\": [\n",
" { \"x\": COIL_CENTER_RADIUS*np.cos(np.deg2rad(angle_A)), \"y\": COIL_CENTER_RADIUS*np.sin(np.deg2rad(angle_A)) },\n",
" { \"x\": COIL_CENTER_RADIUS*np.cos(np.deg2rad(angle_B)), \"y\": COIL_CENTER_RADIUS*np.sin(np.deg2rad(angle_B)) },\n",
Working version
2022-10-06 09:18:11 +00:00
" { \"x\": COIL_CENTER_RADIUS*np.cos(np.deg2rad(angle_C)), \"y\": COIL_CENTER_RADIUS*np.sin(np.deg2rad(angle_C)) },\n",
" { \"x\": COIL_CENTER_RADIUS*np.cos(np.deg2rad(angle_A_opp)), \"y\": COIL_CENTER_RADIUS*np.sin(np.deg2rad(angle_A_opp)) },\n",
" { \"x\": COIL_CENTER_RADIUS*np.cos(np.deg2rad(angle_B_opp)), \"y\": COIL_CENTER_RADIUS*np.sin(np.deg2rad(angle_B_opp)) },\n",
" { \"x\": COIL_CENTER_RADIUS*np.cos(np.deg2rad(angle_C_opp)), \"y\": COIL_CENTER_RADIUS*np.sin(np.deg2rad(angle_C_opp)) },\n",
" { \"x\": common_connection_radius * np.cos(np.deg2rad(angle_A_opp)), \"y\": common_connection_radius * np.sin(np.deg2rad(angle_A_opp)) },\n",
" { \"x\": common_connection_radius * np.cos(np.deg2rad(angle_B_opp)), \"y\": common_connection_radius * np.sin(np.deg2rad(angle_B_opp)) },\n",
" { \"x\": common_connection_radius * np.cos(np.deg2rad(angle_C_opp)), \"y\": common_connection_radius * np.sin(np.deg2rad(angle_C_opp)) },\n",
Connect coils
2022-10-06 11:46:59 +00:00
" # coil A connections\n",
" { \"x\": a_connection_f[0][0], \"y\": a_connection_f[0][1] },\n",
" { \"x\": a_connection_f[-1][0], \"y\": a_connection_f[-1][1] },\n",
" # coil B connections\n",
" { \"x\": b_connection_f[0][0], \"y\": b_connection_f[0][1] },\n",
" { \"x\": b_connection_f[-1][0], \"y\": b_connection_f[-1][1] },\n",
" # coil C connections\n",
" { \"x\": c_connection_f[0][0], \"y\": c_connection_f[0][1] },\n",
" { \"x\": c_connection_f[-1][0], \"y\": c_connection_f[-1][1] },\n",
Drive the plugin off json
2022-10-04 17:43:35 +00:00
" ],\n",
" \"silk\": [\n",
" { \"x\": COIL_CENTER_RADIUS*np.cos(np.deg2rad(angle_A)), \"y\": COIL_CENTER_RADIUS*np.sin(np.deg2rad(angle_A)), \"text\": \"A\" },\n",
" { \"x\": COIL_CENTER_RADIUS*np.cos(np.deg2rad(angle_B)), \"y\": COIL_CENTER_RADIUS*np.sin(np.deg2rad(angle_B)), \"text\": \"B\" },\n",
" { \"x\": COIL_CENTER_RADIUS*np.cos(np.deg2rad(angle_C)), \"y\": COIL_CENTER_RADIUS*np.sin(np.deg2rad(angle_C)), \"text\": \"C\" }\n",
" ],\n",
Working version
2022-10-06 09:18:11 +00:00
" \"tracks\": {\n",
" \"f\": [\n",
" create_track(points) for points in [\n",
" coil_A_f,\n",
" coil_A_opp_f,\n",
" coil_B_f,\n",
" coil_B_opp_f,\n",
" coil_C_f,\n",
Connect coils
2022-10-06 11:46:59 +00:00
" coil_C_opp_f,\n",
" a_connection_f,\n",
" b_connection_f,\n",
" c_connection_f]\n",
Working version
2022-10-06 09:18:11 +00:00
" ],\n",
" \"b\": [\n",
" create_track(points) for points in [\n",
" coil_A_b, \n",
" coil_A_opp_b, \n",
" coil_B_b, \n",
" coil_B_opp_b, \n",
" coil_C_b, \n",
" coil_C_opp_b,\n",
" common_coil_connections_b,\n",
Connect coils
2022-10-06 11:46:59 +00:00
" a_connection_b,\n",
" b_connection_b,\n",
" c_connection_b]\n",
Working version
2022-10-06 09:18:11 +00:00
" ]\n",
" },\n",
Drive the plugin off json
2022-10-04 17:43:35 +00:00
"}\n",
"\n",
"import json\n",
"json.dump(json_result, open(\"coil.json\", \"w\"))\n",
"\n",
"\n",
Tidy up layer handling
2022-10-02 19:15:44 +00:00
"df = pd.DataFrame(coil_A_f, columns=['x', 'y'])\n",
plot multiple coils
2022-10-02 15:50:49 +00:00
"ax = df.plot.line(x='x', y='y', label='Coil A', color='blue')\n",
"ax.axis('equal')\n",
Tidy up layer handling
2022-10-02 19:15:44 +00:00
"df = pd.DataFrame(coil_A_b, columns=['x', 'y'])\n",
"ax = df.plot.line(x='x', y='y', label='Coil B', color='green')\n",
"ax.axis('equal')\n",
"\n",
"# plot all three coils on the same graph\n",
"# df = pd.DataFrame(coil_A, columns=['x', 'y'])\n",
"# ax = df.plot.line(x='x', y='y', label='Coil A', color='blue')\n",
"# ax.axis('equal')\n",
"# df = pd.DataFrame(coil_B, columns=['x', 'y'])\n",
"# df.plot.line(x='x', y='y', ax=ax, label='Coil B', color='green')\n",
"# df = pd.DataFrame(coil_C, columns=['x', 'y'])\n",
"# df.plot.line(x='x', y='y', ax=ax, label='Coil C', color='red')\n",
plot multiple coils
2022-10-02 15:50:49 +00:00
"\n",
Tidy up layer handling
2022-10-02 19:15:44 +00:00
"# df = pd.DataFrame(coil_A_opposite, columns=['x', 'y'])\n",
"# df.plot.line(x='x', y='y', ax=ax, label='Coil A Opposite', color='blue')\n",
"# df = pd.DataFrame(coil_B_opposite, columns=['x', 'y'])\n",
"# df.plot.line(x='x', y='y', ax=ax, label='Coil B Opposite', color='green')\n",
"# df = pd.DataFrame(coil_C_opposite, columns=['x', 'y'])\n",
"# df.plot.line(x='x', y='y', ax=ax, label='Coil C Opposite', color='red')\n",
plot multiple coils
2022-10-02 15:50:49 +00:00
"\n"
]
Arbitrary coil POC
2022-10-01 20:09:14 +00:00
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3.10.7 ('venv': venv)",
"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.10.7"
},
"orig_nbformat": 4,
"vscode": {
"interpreter": {
"hash": "1ce20143987840b9786ebb5907032c9c3a8efacbb887dbb0ebc4934f2ad26cb3"
}
}
},
"nbformat": 4,
"nbformat_minor": 2
}
Reference in a new issue Copy permalink