kopia lustrzana https://github.com/miguelvaca/vk3cpu
558 wiersze
29 KiB
HTML
558 wiersze
29 KiB
HTML
<!DOCTYPE html>
|
|
<html lang="en">
|
|
<head>
|
|
<meta charset="UTF-8">
|
|
<meta name="viewport" content="width=device-width, initial-scale=1.0">
|
|
<title>VK3CPU RF Inductor Calculator</title>
|
|
<link rel="stylesheet" href="inductor.css">
|
|
</head>
|
|
<body>
|
|
<header>Miguel <a href="mailto:vk3cpu@gmail.com">VK3CPU</a> - RF Inductor Calculator<br><a href="inductor_imp.html">[Wire AWG]</a> <a href="inductor_swg.html">[Wire SWG]</a> <a href="inductor_lrg.html">[Coax Metric]</a></header>
|
|
<section class="gridLayoutClass">
|
|
<div id="inductor-container" class="inductor-container" style="position: relative;">
|
|
<canvas id="inductor2D" class="inductorClass" width="350" height="350">
|
|
</canvas>
|
|
</div>
|
|
<div class="slider_container">
|
|
<div class="sliders">
|
|
<label for="conductor_diameter_slider">⌀a:</label>
|
|
<input type="range" id="conductor_diameter_slider" min="0.1" max="4.0" value="0.8" step="0.05">
|
|
</div>
|
|
<div class="sliders">
|
|
<label for="loop_diameter_slider">⌀b:</label>
|
|
<input type="range" id="loop_diameter_slider" min="5.0" max="50.0" value="25.0" step="0.1">
|
|
</div>
|
|
<div class="sliders">
|
|
<label for="loop_spacing_slider">c/a:</label>
|
|
<input type="range" id="loop_spacing_slider" min="1.1" max="4.0" value="2.0" step="0.01">
|
|
</div>
|
|
<div class="sliders">
|
|
<label for="loop_turns_slider">N:</label>
|
|
<input type="range" id="loop_turns_slider" min="2" max="100" value="8.0" step="1.0">
|
|
</div>
|
|
<div class="sliders">
|
|
<label for="frequency_slider">f:</label>
|
|
<input type="range" id="frequency_slider" min="1.0" max="54.0" value="7.0" step="0.05">
|
|
</div>
|
|
</div>
|
|
<div id="notes" class="notes">
|
|
<br>
|
|
<b><u>Notes:</u></b><br>
|
|
RF Inductor Calculator was developed to help users predict the RF characteristics of a single-layer solenoid-style air-core inductor. <br><br>
|
|
<u>Inputs via the slider widgets:</u>
|
|
<ul>
|
|
<li>⌀a : Conductor diameter in millimeters (mm). Estimated equivalent AWG & SWG wire sizes are also displayed when appropriate.</li>
|
|
<li>⌀b : Coil diameter in millimeters (mm).</li>
|
|
<li>c/a : 'c' is the inter-winding spacing, and 'a' is the conductor diameter, so 'c/a' is the spacing ratio. (Must be >= 1.1)
|
|
A low-value will increase the resistance due to the proximity effect.</li>
|
|
<li>N : Number of turns or windings.</li>
|
|
<li>f : The frequency of interest (MHz) for some of the calculations.</li>
|
|
</ul>
|
|
<p>Characteristics on the left are independent of frequency, while the characteristics on the right are dependent on the selected frequency. <br><br>
|
|
Each of the graphic representations attempt to keep the relative geometry correct, without exceeding the drawing boundary. The coil diameter
|
|
relative to the coil length is representative. </p>
|
|
<u>Calculated dimensions:</u>
|
|
<ul>
|
|
<li>⌀o : Outer coil diameter (mm) </li>
|
|
<li>⌀i : Inner coil diameter (mm) - corresponds to the diameter of the winding former.</li>
|
|
<li>c : Distance between windings, measured from the conductor centers (mm).</li>
|
|
<li>ℓ : Length of the coil (mm). Equal to c x N.</li>
|
|
</ul>
|
|
<u>Calculated parameters:</u>
|
|
<ul> <b>Frequency independent:[L]</b>
|
|
<li>L : Inductance is calculated using Nagaoka's equation incorporating his coefficient.</li>
|
|
<li>C : Capacitance is calculated using Knight's 2016 paper on self-resonance and self-capacitance of solenoid coils.</li>
|
|
<li>Rdc : DC resistance is calculated using conductor length divided by the conductor cross-sectional area, assuming a copper conductor.</li>
|
|
<li>SRF : Self-resonant frequency (MHz) for the unloaded coil. </li>
|
|
<li>wire : Length of wire required to wind the inductor. </li>
|
|
</ul>
|
|
<ul> <b>Frequency dependent:[R]</b> (Text goes <font color="red">RED</font> when selected frequency > SRF. Inductor model is not accurate once SRF is exceeded.)
|
|
<li>f : Selected frequency in MHz</li>
|
|
<li>δ : Skin depth due to skin effect (μm)</li>
|
|
<li>Rac : AC resistance is calculated using the skin effect and proximity resistance from empirical data collected by Medhurst using the spacing ratio, and length-to-diameter ratio.</li>
|
|
<li>Xₗ : Inductive reactance at the given frequency. (Ω) - pure inductive component, ignoring parasitic capacitance </li>
|
|
<li>Z : Complex impedance at the given frequency. (Ω) - includes losses due to series Rac and parallel parasitic C</li>
|
|
<li>|Z| : Impedance magnitude at the given frequency. (Ω)</li>
|
|
<li>Q : Effective Quality Factor of the inductor at the given frequency. - (|Z.im|/Z.re)</li>
|
|
</ul>
|
|
</div>
|
|
</section>
|
|
<script src="https://cdnjs.cloudflare.com/ajax/libs/mathjs/7.5.1/math.min.js"></script>
|
|
<script src="inductor.js"></script>
|
|
<script>
|
|
// Define global storage for calculated values, so we don't recalculate the same things multiple times:
|
|
var inductor = {
|
|
loop_diameter_meters : 0.0,
|
|
cond_diameter_meters : 0.0,
|
|
spacing_ratio : 0.0,
|
|
loop_turns : 0.0,
|
|
frequency_hz : 0.0,
|
|
|
|
L : 0.0,
|
|
C : 0.0,
|
|
Rdc : 0.0,
|
|
SRF : 0.0,
|
|
|
|
Xl : 0.0,
|
|
Xc : 0.0,
|
|
Z : 0.0,
|
|
skin_depth : 0.0,
|
|
Rac : 0.0,
|
|
Q : 0.0
|
|
};
|
|
|
|
// Solve all the parameters, and re-draw the canvas:
|
|
function recalculate() {
|
|
// Input variables:
|
|
inductor.loop_diameter_meters = 0.001 * loop_diameter_slider.value; // Inches to mm then to m
|
|
inductor.cond_diameter_meters = 0.001 * conductor_diameter_slider.value;
|
|
inductor.spacing_ratio = 1.0 * loop_spacing_slider.value;
|
|
inductor.loop_turns = 1.0 * loop_turns_slider.value;
|
|
inductor.frequency_hz = 1e6 * frequency_slider.value;
|
|
// Frequency independent characteristics:
|
|
inductor.L = getInductance(inductor.loop_diameter_meters, inductor.cond_diameter_meters, inductor.spacing_ratio, inductor.loop_turns);
|
|
inductor.C = multiloopCapacitance(inductor.loop_diameter_meters, inductor.cond_diameter_meters, inductor.spacing_ratio, inductor.loop_turns);
|
|
inductor.Rdc = dcResistance(inductor.loop_diameter_meters, inductor.cond_diameter_meters, inductor.spacing_ratio, inductor.loop_turns);
|
|
inductor.SRF = selfResonantFrequency(inductor.L, inductor.C);
|
|
// Frequency dependent characteristics:
|
|
inductor.Xl = inductiveReactance(inductor.frequency_hz, inductor.L);
|
|
inductor.Xc = capacitiveReactance(inductor.frequency_hz, inductor.C);
|
|
inductor.skin_depth = skinDepth(inductor.frequency_hz);
|
|
inductor.Rac = acResistance(inductor.loop_diameter_meters, inductor.cond_diameter_meters, inductor.spacing_ratio, inductor.loop_turns, inductor.frequency_hz);
|
|
//inductor.Q = qualityFactor(inductor.Xl, inductor.Rac);
|
|
// Calculate impedance:
|
|
var Zl = math.complex(inductor.Rac, inductor.Xl);
|
|
var Zc = math.complex(0, inductor.Xc);
|
|
inductor.Z = math.divide(math.multiply(Zl, Zc), math.add(Zl, Zc));
|
|
inductor.Q = Math.abs(inductor.Z.im) / inductor.Z.re;
|
|
// Redraw the canvas:
|
|
drawDesign();
|
|
}
|
|
|
|
loop_diameter_slider.oninput = function() {
|
|
recalculate();
|
|
}
|
|
|
|
conductor_diameter_slider.oninput = function() {
|
|
recalculate();
|
|
}
|
|
|
|
loop_turns_slider.oninput = function() {
|
|
recalculate();
|
|
}
|
|
|
|
loop_spacing_slider.oninput = function() {
|
|
recalculate();
|
|
}
|
|
|
|
frequency_slider.oninput = function() {
|
|
recalculate();
|
|
}
|
|
|
|
window.onresize = function() {
|
|
recalculate();
|
|
}
|
|
|
|
window.onorientationchange = function() {
|
|
recalculate();
|
|
}
|
|
|
|
window.onbeforeprint = function() {
|
|
console.log("onbeforeprint");
|
|
drawDesign();
|
|
}
|
|
|
|
const afront_canvas = document.getElementById("inductor2D");
|
|
const fctx = afront_canvas.getContext('2d');
|
|
|
|
function drawDesign() {
|
|
const win_width = document.getElementById("inductor-container").clientWidth;
|
|
const win_height = document.getElementById("inductor-container").clientHeight;
|
|
afront_canvas.width = win_width-12;
|
|
afront_canvas.height = win_height-12;
|
|
|
|
fctx.clearRect(0, 0, win_width, win_height);
|
|
const loop_radius = 0.11 * win_height;
|
|
var cond_radius = loop_radius * (inductor.cond_diameter_meters / inductor.loop_diameter_meters);
|
|
const loopx = win_width/2;
|
|
const loopy = win_height/4;
|
|
|
|
const loop_diameter_mm = inductor.loop_diameter_meters * 1000.0;
|
|
const cond_diameter_mm = inductor.cond_diameter_meters * 1000.0;
|
|
const loop_diameter_inches = loop_diameter_mm / 25.4;
|
|
const cond_diameter_inches = cond_diameter_mm / 25.4;
|
|
|
|
|
|
fctx.font = "bold 14px arial";
|
|
fctx.textAlign = "center";
|
|
fctx.fillText("Wire - Metric", win_width*0.5, 18);
|
|
|
|
// Draw loop ends first, then draw the loop after:
|
|
fctx.strokeStyle = "grey";
|
|
fctx.beginPath();
|
|
fctx.arc(loopx - 0.5*loop_radius, loopy + 1.414*loop_radius, 0.5 * loop_radius, 0.0, -0.40 * Math.PI, true);
|
|
fctx.lineWidth = cond_radius * 2.0;
|
|
fctx.stroke();
|
|
fctx.strokeStyle = "black";
|
|
|
|
fctx.beginPath();
|
|
fctx.arc(loopx + 0.5*loop_radius, loopy + 1.414*loop_radius, 0.5 * loop_radius, Math.PI, -0.60 * Math.PI, false);
|
|
fctx.lineWidth = cond_radius * 2.0;
|
|
fctx.stroke();
|
|
|
|
// Draw loop:
|
|
fctx.beginPath();
|
|
fctx.arc(loopx, loopy, loop_radius, 0.0, 2.0 * Math.PI, false);
|
|
fctx.stroke();
|
|
fctx.lineWidth = 1.0;
|
|
|
|
// Draw loop diameter arrow:
|
|
const y_offset = loopy + loop_radius + 20;
|
|
var arrow_size = 10.0;
|
|
fctx.beginPath();
|
|
fctx.moveTo(loopx - loop_radius, loopy);
|
|
fctx.lineTo(loopx - loop_radius, y_offset);
|
|
fctx.lineTo(loopx - loop_radius - arrow_size, y_offset - arrow_size);
|
|
fctx.lineTo(loopx - loop_radius - arrow_size, y_offset + arrow_size);
|
|
fctx.lineTo(loopx - loop_radius, y_offset);
|
|
fctx.lineTo(loopx - loop_radius - 3.0*arrow_size, y_offset);
|
|
fctx.stroke();
|
|
|
|
fctx.beginPath();
|
|
fctx.moveTo(loopx + loop_radius, loopy);
|
|
fctx.lineTo(loopx + loop_radius, y_offset);
|
|
fctx.lineTo(loopx + loop_radius + arrow_size, y_offset - arrow_size);
|
|
fctx.lineTo(loopx + loop_radius + arrow_size, y_offset + arrow_size);
|
|
fctx.lineTo(loopx + loop_radius, y_offset);
|
|
fctx.lineTo(loopx + loop_radius + 3.0*arrow_size, y_offset);
|
|
fctx.stroke();
|
|
|
|
// Write conductor diameter symbol:
|
|
fctx.font = "12px arial";
|
|
fctx.textAlign = "right";
|
|
fctx.fillText("\u2300a = " + cond_diameter_mm.toFixed(2).toString() + "mm", loopx - loop_radius - 2.0*arrow_size, loopy - 6);
|
|
fctx.fillText("(" + cond_diameter_inches.toFixed(3).toString() + "\") ", loopx - loop_radius - 3.0*arrow_size, loopy + 8);
|
|
fctx.fillText("A=" + (cond_diameter_mm**2).toFixed(2).toString() + " mm\u00B2", loopx - loop_radius - 3.0*arrow_size, loopy + 22);
|
|
|
|
// Write loop diameter symbol:
|
|
fctx.fillText("\u2300b = " + loop_diameter_mm.toFixed(1).toString() + "mm", loopx - loop_radius - 2.0*arrow_size, y_offset - 4);
|
|
fctx.fillText("(" + loop_diameter_inches.toFixed(2).toString() + "\")", loopx - loop_radius - 2.0*arrow_size, y_offset + 12);
|
|
|
|
// Draw inner-diameter arrows: (for using a winding former)
|
|
const inner_dia_y = loopy + loop_radius + 40;
|
|
fctx.beginPath();
|
|
fctx.moveTo(loopx - loop_radius + cond_radius, loopy);
|
|
fctx.lineTo(loopx - loop_radius + cond_radius, inner_dia_y);
|
|
fctx.lineTo(loopx - loop_radius + cond_radius - arrow_size, inner_dia_y - arrow_size);
|
|
fctx.lineTo(loopx - loop_radius + cond_radius - arrow_size, inner_dia_y + arrow_size);
|
|
fctx.lineTo(loopx - loop_radius + cond_radius, inner_dia_y);
|
|
fctx.lineTo(loopx - loop_radius - 3.0*arrow_size, inner_dia_y);
|
|
fctx.stroke();
|
|
|
|
fctx.beginPath();
|
|
fctx.moveTo(loopx + loop_radius - cond_radius, loopy);
|
|
fctx.lineTo(loopx + loop_radius - cond_radius, inner_dia_y);
|
|
fctx.lineTo(loopx + loop_radius - cond_radius + arrow_size, inner_dia_y - arrow_size);
|
|
fctx.lineTo(loopx + loop_radius - cond_radius + arrow_size, inner_dia_y + arrow_size);
|
|
fctx.lineTo(loopx + loop_radius - cond_radius, inner_dia_y);
|
|
fctx.lineTo(loopx + loop_radius + 3.0*arrow_size, inner_dia_y);
|
|
fctx.stroke();
|
|
fctx.textAlign = "left";
|
|
fctx.fillText("\u2300i = " + (loop_diameter_mm - 0.5*cond_diameter_mm).toFixed(2).toString() + "mm", loopx + loop_radius + 2.0*arrow_size, inner_dia_y - 4);
|
|
fctx.fillText("(" + (loop_diameter_inches - 0.5 * cond_diameter_inches).toFixed(3).toString() + "\")", loopx + loop_radius + 2.0*arrow_size, inner_dia_y + 12);
|
|
|
|
// Draw outer-diameter arrows: (for using a winding former)
|
|
const outer_dia_y = loopy + loop_radius + 0;
|
|
fctx.beginPath();
|
|
fctx.moveTo(loopx - loop_radius - cond_radius, loopy);
|
|
fctx.lineTo(loopx - loop_radius - cond_radius, outer_dia_y);
|
|
fctx.lineTo(loopx - loop_radius - cond_radius - arrow_size, outer_dia_y - arrow_size);
|
|
fctx.lineTo(loopx - loop_radius - cond_radius - arrow_size, outer_dia_y + arrow_size);
|
|
fctx.lineTo(loopx - loop_radius - cond_radius, outer_dia_y);
|
|
fctx.lineTo(loopx - loop_radius - 3.0*arrow_size, outer_dia_y);
|
|
fctx.stroke();
|
|
|
|
fctx.beginPath();
|
|
fctx.moveTo(loopx + loop_radius + cond_radius, loopy);
|
|
fctx.lineTo(loopx + loop_radius + cond_radius, outer_dia_y);
|
|
fctx.lineTo(loopx + loop_radius + cond_radius + arrow_size, outer_dia_y - arrow_size);
|
|
fctx.lineTo(loopx + loop_radius + cond_radius + arrow_size, outer_dia_y + arrow_size);
|
|
fctx.lineTo(loopx + loop_radius + cond_radius, outer_dia_y);
|
|
fctx.lineTo(loopx + loop_radius + 3.0*arrow_size, outer_dia_y);
|
|
fctx.stroke();
|
|
fctx.fillText("\u2300o = " + (loop_diameter_mm+0.5*cond_diameter_mm).toFixed(2).toString() + "mm", loopx + loop_radius + 2.0*arrow_size, outer_dia_y - 4);
|
|
fctx.fillText("(" + (loop_diameter_inches+0.5*cond_diameter_inches).toFixed(3).toString() + "\")", loopx + loop_radius + 2.0*arrow_size, outer_dia_y + 12);
|
|
|
|
// Write loop inductance:
|
|
fctx.font = "12px arial";
|
|
fctx.textAlign = "left";
|
|
const L = inductor.L * 1.0e+6;
|
|
fctx.fillText("L = " + L.toPrecision(3).toString() + " \u03bcH", 8, 18);
|
|
fctx.fillText("C = " + (inductor.C * 1e12).toFixed(1) + " pF", 8, 32);
|
|
fctx.fillText("Rdc = " + inductor.Rdc.toFixed(2) + " \u03A9", 8, 46);
|
|
fctx.fillText("SRF = " + (inductor.SRF * 1e-6).toFixed(1) + " MHz", 8, 60);
|
|
const wire_length_m = Math.sqrt((inductor.loop_turns * inductor.spacing_ratio * inductor.cond_diameter_meters)**2 + (Math.PI * inductor.loop_diameter_meters * inductor.loop_turns)**2);
|
|
fctx.fillText("wire = " + (wire_length_m*100.0).toFixed(1) + " cm", 8, 74);
|
|
|
|
// Draw conductor diameter arrow:
|
|
fctx.beginPath();
|
|
fctx.moveTo(loopx - loop_radius - cond_radius, loopy);
|
|
fctx.lineTo(loopx - loop_radius - cond_radius - arrow_size, loopy - arrow_size);
|
|
fctx.lineTo(loopx - loop_radius - cond_radius - arrow_size, loopy + arrow_size);
|
|
fctx.lineTo(loopx - loop_radius - cond_radius, loopy);
|
|
fctx.lineTo(loopx - loop_radius - 3.0*arrow_size, loopy);
|
|
fctx.stroke();
|
|
|
|
fctx.beginPath();
|
|
fctx.moveTo(loopx - loop_radius + cond_radius, loopy);
|
|
fctx.lineTo(loopx - loop_radius + cond_radius + arrow_size, loopy - arrow_size);
|
|
fctx.lineTo(loopx - loop_radius + cond_radius + arrow_size, loopy + arrow_size);
|
|
fctx.lineTo(loopx - loop_radius + cond_radius, loopy);
|
|
fctx.lineTo(loopx - loop_radius + cond_radius + 2.0*arrow_size, loopy);
|
|
fctx.stroke();
|
|
|
|
var awg = "";
|
|
var swg = "";
|
|
switch(cond_diameter_mm) {
|
|
case 0.100 :
|
|
awg = "\u224838AWG";
|
|
break;
|
|
case 0.150 :
|
|
awg = "\u224835AWG";
|
|
break;
|
|
case 0.200 :
|
|
awg = "\u224832AWG";
|
|
swg = "\u224836SWG";
|
|
break;
|
|
case 0.250 :
|
|
awg = "\u224830AWG";
|
|
swg = "\u224833SWG";
|
|
break;
|
|
case 0.300 :
|
|
awg = "\u224829AWG";
|
|
swg = "\u224831SWG";
|
|
break;
|
|
case 0.350 :
|
|
awg = "\u224827AWG";
|
|
swg = "\u224829SWG";
|
|
break;
|
|
case 0.400 :
|
|
awg = "\u224826AWG";
|
|
swg = "\u224827SWG";
|
|
break;
|
|
case 0.450 :
|
|
awg = "\u224825AWG";
|
|
swg = "\u224826SWG";
|
|
break;
|
|
case 0.500 :
|
|
awg = "\u224824AWG";
|
|
swg = "\u224825SWG";
|
|
break;
|
|
case 0.550 :
|
|
awg = "\u224823AWG";
|
|
swg = "\u224824SWG";
|
|
break;
|
|
case 0.600 :
|
|
swg = "\u224823SWG";
|
|
break;
|
|
case 0.650 :
|
|
awg = "\u224822AWG";
|
|
break;
|
|
case 0.700 :
|
|
awg = "\u224821AWG";
|
|
swg = "\u224822SWG";
|
|
break;
|
|
case 0.800 :
|
|
awg = "\u224820AWG";
|
|
swg = "\u224821SWG";
|
|
break;
|
|
case 0.900 :
|
|
awg = "\u224819 AWG";
|
|
swg = "\u224820 SWG";
|
|
break;
|
|
case 1.00 :
|
|
awg = "\u224818AWG";
|
|
swg = "\u224819SWG";
|
|
break;
|
|
case 1.15 :
|
|
awg = "\u224817AWG";
|
|
break;
|
|
case 1.20 :
|
|
swg = "\u224818SWG";
|
|
break;
|
|
case 1.30 :
|
|
awg = "\u224816AWG";
|
|
break;
|
|
case 1.40 :
|
|
swg = "\u224817SWG";
|
|
break;
|
|
case 1.45 :
|
|
awg = "\u224815AWG";
|
|
break;
|
|
case 1.55 :
|
|
awg = "\u224814AWG";
|
|
break;
|
|
case 1.65 :
|
|
swg = "\u224816SWG";
|
|
break;
|
|
case 1.80 :
|
|
awg = "\u224813AWG";
|
|
break;
|
|
case 1.85 :
|
|
swg = "\u224815SWG";
|
|
break;
|
|
case 2.00 :
|
|
awg = "\u224812AWG";
|
|
break;
|
|
case 2.05 :
|
|
swg = "\u224814SWG";
|
|
break;
|
|
case 2.30 :
|
|
awg = "\u224811AWG";
|
|
break;
|
|
case 2.60 :
|
|
awg = "\u224810AWG";
|
|
break;
|
|
case 2.90 :
|
|
awg = "\u22489AWG";
|
|
break;
|
|
case 3.25 :
|
|
awg = "\u22488AWG";
|
|
break;
|
|
case 3.65 :
|
|
awg = "\u22487AWG";
|
|
break;
|
|
case 4.10 :
|
|
awg = "\u22486AWG";
|
|
break;
|
|
case 4.60 :
|
|
awg = "\u22485AWG";
|
|
break;
|
|
}
|
|
fctx.textAlign = "center";
|
|
fctx.font = "14px courier";
|
|
fctx.fillText(awg, loopx, loopy - 6);
|
|
fctx.fillText(swg, loopx, loopy + 12);
|
|
fctx.font = "12px arial";
|
|
|
|
var cond_spacing = 2.0 * cond_radius * inductor.spacing_ratio;
|
|
if((cond_spacing * inductor.loop_turns) > (0.8 * win_width)) {
|
|
cond_radius = ((0.8 * win_width) / (inductor.loop_turns * 2.0*inductor.spacing_ratio));
|
|
cond_spacing = 2.0 * cond_radius * inductor.spacing_ratio;
|
|
}
|
|
var start_x = win_width/2.0 - inductor.loop_turns * cond_spacing * 0.5;
|
|
var top_y = win_height * 0.56;
|
|
var bot_y = top_y + 2.0 * cond_radius * (inductor.loop_diameter_meters / inductor.cond_diameter_meters);
|
|
var angle = math.atan2((cond_spacing * 0.5), (bot_y - top_y));
|
|
|
|
for (let i = 0; i < inductor.loop_turns; i++) {
|
|
fctx.beginPath();
|
|
fctx.arc(start_x + (i+0.5) * cond_spacing, top_y, cond_radius, Math.PI-angle, -angle, false);
|
|
fctx.arc(start_x + (i+1) * cond_spacing, bot_y, cond_radius, -angle, Math.PI-angle, false);
|
|
fctx.fillStyle = "grey";
|
|
fctx.fill();
|
|
|
|
fctx.beginPath();
|
|
fctx.arc(start_x + (i * cond_spacing), bot_y, cond_radius, angle, Math.PI+angle);
|
|
fctx.arc(start_x + (cond_spacing * 0.5) + i * cond_spacing, top_y, cond_radius, Math.PI+angle, angle);
|
|
fctx.fillStyle = "black";
|
|
fctx.fill();
|
|
}
|
|
|
|
// Draw the wire ends:
|
|
fctx.fillRect(start_x - cond_radius, bot_y, 2.0 * cond_radius, 20);
|
|
fctx.fillStyle = "grey";
|
|
fctx.fillRect(start_x + inductor.loop_turns * cond_spacing - cond_radius, bot_y, 2.0 * cond_radius, 20);
|
|
fctx.fillStyle = "black";
|
|
|
|
// Draw left spacing arrow:
|
|
const dim_y = win_height * 0.88;
|
|
fctx.beginPath();
|
|
fctx.moveTo(start_x - 20, dim_y);
|
|
fctx.lineTo(start_x, dim_y);
|
|
fctx.lineTo(start_x - 7, dim_y + 7)
|
|
fctx.lineTo(start_x - 7, dim_y - 7)
|
|
fctx.lineTo(start_x, dim_y);
|
|
fctx.moveTo(start_x, dim_y - 7);
|
|
fctx.lineTo(start_x, dim_y + 7);
|
|
fctx.stroke();
|
|
|
|
// Draw right spacing arrow:
|
|
fctx.beginPath();
|
|
fctx.moveTo(start_x + cond_spacing + 20, dim_y);
|
|
fctx.lineTo(start_x + cond_spacing, dim_y);
|
|
fctx.lineTo(start_x + cond_spacing + 7, dim_y + 7)
|
|
fctx.lineTo(start_x + cond_spacing + 7, dim_y - 7)
|
|
fctx.lineTo(start_x + cond_spacing, dim_y);
|
|
fctx.moveTo(start_x + cond_spacing, dim_y - 7);
|
|
fctx.lineTo(start_x + cond_spacing, dim_y + 7);
|
|
fctx.stroke();
|
|
|
|
// Draw right length arrow:
|
|
fctx.beginPath();
|
|
fctx.moveTo(start_x + inductor.loop_turns * cond_spacing + 20, dim_y);
|
|
fctx.lineTo(start_x + inductor.loop_turns * cond_spacing, dim_y);
|
|
fctx.lineTo(start_x + inductor.loop_turns * cond_spacing + 7, dim_y + 7)
|
|
fctx.lineTo(start_x + inductor.loop_turns * cond_spacing + 7, dim_y - 7)
|
|
fctx.lineTo(start_x + inductor.loop_turns * cond_spacing, dim_y);
|
|
fctx.moveTo(start_x + inductor.loop_turns * cond_spacing, dim_y - 7);
|
|
fctx.lineTo(start_x + inductor.loop_turns * cond_spacing, dim_y + 7);
|
|
fctx.stroke();
|
|
|
|
// Extended lines:
|
|
fctx.strokeStyle = "grey";
|
|
fctx.beginPath();
|
|
fctx.moveTo(start_x, bot_y + 25);
|
|
fctx.lineTo(start_x, dim_y - 12);
|
|
fctx.moveTo(start_x + cond_spacing, bot_y + 10);
|
|
fctx.lineTo(start_x + cond_spacing, dim_y - 12);
|
|
fctx.moveTo(start_x + inductor.loop_turns * cond_spacing, bot_y + 25);
|
|
fctx.lineTo(start_x + inductor.loop_turns * cond_spacing, dim_y - 12);
|
|
fctx.stroke();
|
|
fctx.strokeStyle = "black";
|
|
|
|
fctx.textAlign = "center";
|
|
fctx.fillText("N = " + inductor.loop_turns.toString(), win_width/2, win_height * 0.52);
|
|
|
|
// Draw spacing text: (gap is to avoid collision of spacing and length texts)
|
|
fctx.textAlign = "right";
|
|
var gap = ((inductor.loop_turns * cond_spacing - cond_spacing) < 60) ? (60 - (inductor.loop_turns * cond_spacing - cond_spacing)) : 0;
|
|
const spc = inductor.spacing_ratio * cond_diameter_inches;
|
|
fctx.fillText("c = " + spc.toFixed(3).toString() + "\"", start_x + cond_spacing + 20 - gap, dim_y + 20);
|
|
fctx.fillText("(" + (spc*25.4).toFixed(3).toString() + "mm)", start_x + cond_spacing + 20 - gap, dim_y + 34);
|
|
|
|
// Draw length text:
|
|
const sol_len = inductor.loop_turns * spc;
|
|
fctx.fillText("\u2113 = " + sol_len.toFixed(3).toString() + "\"", start_x + inductor.loop_turns * cond_spacing + 20, dim_y + 20);
|
|
fctx.fillText("(" + (sol_len*25.4).toFixed(1).toString() + "mm)", start_x + inductor.loop_turns * cond_spacing + 20, dim_y + 34);
|
|
|
|
fctx.strokeStyle = "black";
|
|
if(inductor.frequency_hz <= inductor.SRF) {
|
|
fctx.fillStyle = "black";
|
|
} else {
|
|
fctx.fillStyle = "red";
|
|
}
|
|
|
|
fctx.font = "12px arial";
|
|
fctx.textAlign = "right";
|
|
var freq = 1e-6 * inductor.frequency_hz;
|
|
fctx.fillText("f = " + freq.toFixed(2) + " MHz", win_width-18, 18);
|
|
fctx.fillText("\u03B4 = " + (inductor.skin_depth * 1e6).toFixed(1) + " \u03BCm", win_width-18, 32);
|
|
fctx.fillText("Rac = " + inductor.Rac.toFixed(2) + " \u03A9", win_width-18, 46);
|
|
fctx.fillText("X\u2097 = " + inductor.Xl.toFixed(1) + " \u03A9", win_width-18, 60);
|
|
var str = "Z = " + inductor.Z.re.toFixed(1);
|
|
if(inductor.Z.im >= 0.0) {
|
|
str += " + j";
|
|
} else {
|
|
str += " - j";
|
|
}
|
|
str += Math.abs(inductor.Z.im).toFixed(1) + " \u03A9";
|
|
fctx.fillText(str, win_width-18, 74);
|
|
//fctx.fillText("Z = " + inductor.Z.re.toFixed(1) + " " + inductor.Z.im.toFixed(1) + "j \u03A9", win_width-18, 74);
|
|
fctx.fillText("|Z| = " + inductor.Z.toPolar().r.toFixed(1) + " \u03A9", win_width-18, 88);
|
|
fctx.fillText("Q = " + inductor.Q.toFixed(1), win_width-18, 102);
|
|
}
|
|
recalculate();
|
|
</script>
|
|
</body>
|
|
</html> |