2022-10-01 20:09:14 +00:00
{
"cells": [
{
"cell_type": "code",
2022-10-06 09:18:11 +00:00
"execution_count": 245,
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",
2022-10-04 17:43:35 +00:00
"import scipy\n",
2022-10-02 19:15:44 +00:00
"from skspatial.objects import LineSegment\n",
"from enum import Enum"
2022-10-01 20:09:14 +00:00
]
},
{
"cell_type": "code",
2022-10-06 09:18:11 +00:00
"execution_count": 246,
2022-10-02 18:46:28 +00:00
"metadata": {},
"outputs": [],
"source": [
2022-10-04 17:43:35 +00:00
"VIA_DIAM = 0.8\n",
"VIA_DRILL = 0.4\n",
"STATOR_HOLE_RADIUS = 4\n",
2022-10-06 09:18:11 +00:00
"TRACK_WIDTH = 0.15\n",
"TRACK_SPACING = 0.15\n",
"TURNS = 16\n",
2022-10-02 19:15:44 +00:00
"STATOR_RADIUS = 20\n",
"Layer = Enum('Layer', 'FRONT BACK')"
2022-10-02 18:46:28 +00:00
]
},
{
"cell_type": "code",
2022-10-06 09:18:11 +00:00
"execution_count": 247,
2022-10-01 20:09:14 +00:00
"metadata": {},
"outputs": [],
"source": [
"# create a square shape\n",
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",
2022-10-01 20:09:14 +00:00
"# create a triangle\n",
2022-10-06 09:18:11 +00:00
"# template = [(-2, 0), (2, -3), (2, 3)]\n",
2022-10-01 20:09:14 +00:00
"# interpolate the shape using numpy\n",
"\n",
"# create a circle template\n",
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",
2022-10-01 20:09:14 +00:00
"\n"
]
},
{
"cell_type": "code",
2022-10-06 09:18:11 +00:00
"execution_count": 248,
2022-10-01 20:09:14 +00:00
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
2022-10-06 09:18:11 +00:00
"[<matplotlib.lines.Line2D at 0x1374bc040>]"
2022-10-01 20:09:14 +00:00
]
},
2022-10-06 09:18:11 +00:00
"execution_count": 248,
2022-10-01 20:09:14 +00:00
"metadata": {},
"output_type": "execute_result"
},
{
"data": {
2022-10-06 09:18:11 +00:00
"image/png": "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
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",
2022-10-06 09:18:11 +00:00
"execution_count": 249,
2022-10-02 14:38:17 +00:00
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
2022-10-06 09:18:11 +00:00
"[<matplotlib.lines.Line2D at 0x13352ce80>]"
2022-10-02 14:38:17 +00:00
]
},
2022-10-06 09:18:11 +00:00
"execution_count": 249,
2022-10-02 14:38:17 +00:00
"metadata": {},
"output_type": "execute_result"
},
{
"data": {
2022-10-06 09:18:11 +00:00
"image/png": "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
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",
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",
2022-10-02 14:38:17 +00:00
" return chaikin(smoothed, iterations - 1)\n",
"\n",
2022-10-02 15:50:49 +00:00
"template = chaikin(template, 2)\n",
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",
2022-10-06 09:18:11 +00:00
"execution_count": 250,
2022-10-01 20:09:14 +00:00
"metadata": {},
"outputs": [],
"source": [
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",
2022-10-06 09:18:11 +00:00
" for angle in np.arange(0, 360+2, 2):\n",
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",
2022-10-01 20:09:14 +00:00
"\n",
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",
2022-10-02 15:50:49 +00:00
" if cache is None:\n",
" cache = get_template_point_cache(template)\n",
" points = []\n",
2022-10-06 09:18:11 +00:00
" for angle in np.arange(0, 360 * turns + 2, 2):\n",
2022-10-02 15:50:49 +00:00
" offset = spacing * angle / 360\n",
2022-10-02 19:15:44 +00:00
" if layer == Layer.BACK:\n",
" angle = angle + 180\n",
" intersection, segment = cache[angle % 360]\n",
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",
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",
2022-10-02 15:50:49 +00:00
" return points\n"
]
},
{
"cell_type": "code",
2022-10-06 09:18:11 +00:00
"execution_count": 251,
2022-10-02 15:50:49 +00:00
"metadata": {},
"outputs": [],
"source": [
"cache = get_template_point_cache(template)"
]
},
{
"cell_type": "code",
2022-10-06 09:18:11 +00:00
"execution_count": 242,
2022-10-02 15:50:49 +00:00
"metadata": {},
"outputs": [
{
2022-10-06 09:18:11 +00:00
"name": "stdout",
"output_type": "stream",
"text": [
"180 300 420\n"
]
2022-10-02 15:50:49 +00:00
}
],
"source": [
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",
2022-10-02 15:50:49 +00:00
"\n",
2022-10-06 09:18:11 +00:00
"COIL_CENTER_RADIUS = STATOR_RADIUS/2+1.5\n",
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",
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",
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",
2022-10-02 15:50:49 +00:00
"\n",
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",
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",
2022-10-04 17:43:35 +00:00
"\n",
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",
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",
2022-10-06 09:18:11 +00:00
"# connect the front copper oppoisite coils together\n",
"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",
"a_connection_radius = STATOR_HOLE_RADIUS + (TRACK_WIDTH+TRACK_SPACING)\n",
"coil_A_b.append((a_connection_radius * np.cos(np.deg2rad(angle_A)), a_connection_radius * np.sin(np.deg2rad(angle_A))))\n",
"coil_A_opp_b.append((a_connection_radius * np.cos(np.deg2rad(angle_A_opp)), a_connection_radius * np.sin(np.deg2rad(angle_A_opp))))\n",
"a_comnection_b = [\n",
" (a_connection_radius * np.cos(np.deg2rad(angle)), a_connection_radius * np.sin(np.deg2rad(angle)))\n",
" for angle in np.arange(angle_A, angle_A_opp+5, 5)\n",
"]\n",
"\n",
"# connect coil B to it's opposite\n",
"\n",
"# connect coil C to it's opposite\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 243,
"metadata": {},
"outputs": [],
"source": [
"\n",
"def create_track(points):\n",
" return [{\"x\": x, \"y\": y} for x, y in points]"
]
},
{
"cell_type": "code",
"execution_count": 244,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"(3.631083333333333, 18.347250000000003, -6.13134708429227, 6.065404237330151)"
]
},
"execution_count": 244,
"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": {
"image/png": "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
"text/plain": [
"<Figure size 640x480 with 1 Axes>"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
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",
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",
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",
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",
" coil_C_opp_f]\n",
" ],\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",
" a_comnection_b]\n",
" ]\n",
" },\n",
2022-10-04 17:43:35 +00:00
"}\n",
"\n",
"import json\n",
"json.dump(json_result, open(\"coil.json\", \"w\"))\n",
"\n",
"\n",
2022-10-02 19:15:44 +00:00
"df = pd.DataFrame(coil_A_f, columns=['x', 'y'])\n",
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",
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",
2022-10-02 15:50:49 +00:00
"\n",
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",
2022-10-02 15:50:49 +00:00
"\n"
]
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
}
