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
292 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:46:59 +00:00
"execution_count": 438,
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:46:59 +00:00
"execution_count": 439,
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:46:59 +00:00
"execution_count": 440,
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",
"execution_count": 441,
Arbitrary coil POC
2022-10-01 20:09:14 +00:00
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
Connect coils
2022-10-06 11:46:59 +00:00
"[<matplotlib.lines.Line2D at 0x137c7c940>]"
Arbitrary coil POC
2022-10-01 20:09:14 +00:00
]
},
Connect coils
2022-10-06 11:46:59 +00:00
"execution_count": 441,
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:46:59 +00:00
"execution_count": 442,
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:46:59 +00:00
"[<matplotlib.lines.Line2D at 0x142ae5930>]"
Adds chailin's corner cutting algorithm to smooth corners
2022-10-02 14:38:17 +00:00
]
},
Connect coils
2022-10-06 11:46:59 +00:00
"execution_count": 442,
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:46:59 +00:00
"execution_count": 443,
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:46:59 +00:00
"execution_count": 444,
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:46:59 +00:00
"execution_count": 445,
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:46:59 +00:00
"execution_count": 446,
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:46:59 +00:00
"execution_count": 447,
Working version
2022-10-06 09:18:11 +00:00
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
Connect coils
2022-10-06 11:46:59 +00:00
"(3.4735833333333335, 18.354750000000003, -6.13134708429227, 6.065404237330151)"
Working version
2022-10-06 09:18:11 +00:00
]
},
Connect coils
2022-10-06 11:46:59 +00:00
"execution_count": 447,
Working version
2022-10-06 09:18:11 +00:00
"metadata": {},
"output_type": "execute_result"
},
{
"data": {
"image/png": "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
"text/plain": [
"<Figure size 640x480 with 1 Axes>"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
Connect coils
2022-10-06 11:46:59 +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"
}
],
"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