Bifilar pancake coil overunity experiment

[ayeaye]

I now changed the transistor's base resistor, R1, from 1k to 560 ohms. This looks like right for Arduino and 5 V, for ne555 and 12 V, 1k is likely still right.

As you see on the figure below, with that resistor the voltage on the collector of the open transistor starts from almost 0.3 V, goes to almost 0.1 V, and then back to 0.3 V. As 0.3 V is the maximum voltage on the saturated c945, then this means that with that resistor the transistor was fully open.

The figure below is the same as the figure in my previous post, except that the time scale is 0.5 us, y scale is still 2 V. I tried to increase the y scale, but it didn't trigger then.

Yes, the ground was aligned with the central x axis, and the left edge of it exactly with the first vertical grid line on the figure below.

So now i think that 0.2 V in the script (or spreadsheet) as the voltage on the open transistor, is almost correct, the difference is then never more than 0.1 V, which is not more than 1% of the voltage on R2.

I just showed that the voltage on the open transistor doesn't change much, thus for this experiment only one channel, channel 1, should be measured, there is thus no need to measure two channels.

[citfta]

Ayeaye,


You keep using a term that drives me crazy when talking about transistor operation.  When a transistor is turned fully on it is saturated as you have correctly written.  However the term open is very confusing.  Most novices use that term when talking about transistors.  BUT some of them mean the transistor is open like a switch or in other words turned OFF.  And some of them use the term open to mean open like a valve or in other words turned ON.  I just read a few articles online and easily found both uses of the term open when talking about transistors.  And I also found some articles where they used the term closed to mean a transistor was either on or off.


In the real world of electronics the term open refers to a bad transistor that has one or more of the internal junctions blown open, usually by an overvoltage or overcurrent condition.  The proper terms for talking about transistors is either on or off or in the active region.  Using those terms there can be no confusion as to what you mean.

Respectfully,
Carroll

[ayeaye]

I see. When i said that the transistor is open, i meant that the transistor is conducting. I will from now on say that the transistor is conducting instead of open, as this is the only word i know to substitute.

[ayeaye]

The following is only for these who have analog scopes. All here seem to be advanced people, and all seem to use digital desktop oscilloscopes, signal generators and everything. All i have though is analog oscilloscope.

Ok, make it simple, and make it much more flexible. This vector format, what concerns the oscilloscopes, all they seem to use is samples, so let's ditch the vector data completely. Inkscape though is the best thing to draw with, and the only thing to do it in any conceivable way. So just write a script that converts Inkscape path to sample list. So that this is all it does. Which means that it assumes that there is only one path in the svg file, which means that there should be separate svg files for creating the input list and output list. This also means that the output list is not inverted, thus this should be done later in the calculations.

An example calculation in script, with Y scale initially given in V, and X scale initially given in us. In calculations mV and ns are used, hence multiplying by 1000. The grid scale being 20 units means dividing that by 20. In digital oscilloscopes one should instead consider how many samples are in a time scale (in Rigol i guess it is 50) and how many units are in Y scale (when the sample length is 256 then may be maximum 32, but that is only a guess. one should know that exactly).

XU *= 1000 / 20
YU *= 1000 / 20

This is a very flexible method. All this script really does, is converting Inkscape path to sample list. No matter for what these sample lists may be used for. It' may even be useful for some other purposes, than drawing the oscilloscope traces.

Most importantly, the path always has to start from x = 0, y = 0, that is, the coordinates of the first point in the path are considered to be coordinates of the x axis and the initial x. It can end anywhere and usually not on the x axis. The script simply ignores the coordinates of the first point of the path, and considers them to be (0, 0). It is a very simple script.

I like to create a grid 1 unit in a square, and 20 squares in a big square, this is precise enough and higher precision is rather insane. But it doesn't really matter, this script always creates a sample list from the path, always. One big square represents one oscilloscope scale, and the number of units in it should be included in the calculation script or in the calculation spreadsheet, as the number of units in the x scale and y scale.

First in the document properties, select snap to grid only closer than, then move the slider below to the leftmost position. This enables to easily align the grid of the imported oscilloscope screen image with the drawing grid. When it's aligned, don't forget to check snap always before starting to draw the path, not doing so may cause a lot of trouble and weird results.

After creating the input and output lists with the following script, one can go ahead and calculate the input and output power with the same scripts or spreadsheets that are used for calculations for digital scopes.

import sys

def next(separator):
    global pos
    begin = pos + 1
    pos = str.find(separator, begin)
    if (pos == -1): pos = len(str)
    return int(float(str[begin:pos]))

str = ""
for s in sys.stdin:
    begin = s.find("d=\"m ")
    if (begin == -1): continue
    begin = s.find(" ", begin)
    end = s.find("\"", begin)
    str = s[begin : end]

pos = 0
list = []
next(",")
next(" ")
list.append([0, 0, 0, 0])
while (True):
    x = list[-1][0] + next(",")
    y = list[-1][1] - next(" ")
    list[-1][2] = x
    list[-1][3] = y
    if (pos == len(str)): break
    list.append([x, y, 0, 0])

n = 0
for j in range(list[-1][2]):
    while (j >= list[n][2]): n += 1
    lx = list[n][2] - list[n][0]
    ly = list[n][3] - list[n][1]
    ratio = float(j - list[n][0]) / lx
    if (j): print list[n][1] + int(round(ly * ratio))

[ayeaye]

What concerns code, the following (input and output), and that in the previous post, is all the code that i ever use for this. I use python, but one can use whatever else.

import sys

#Time scale in us
XU = 2.0
#Voltage scale in V
YU = 0.2
#Resistors 2 and 3 resistances in ohms
R2 = 987.2
R3 = 99.91
#Voltages of power and collector in V
V = 11.6
VC = 0.2
#Frequency in kHz
F = 50.0

#Scale is 20 units
#In calculations XU and YU are in ns and mV for unit
#Voltages are in mV and frequency is in Hz
V *= 1000
VC *= 1000
F *= 1000
XU *= 1000 / 20
YU *= 1000 / 20
e = 0.0
for s in sys.stdin:
    if (s.strip() == ""): continue
    vlr = int(s) * YU
    pr = vlr * vlr / R3 / 1000
    ilr = (V - VC - vlr) / R2
    plr = ilr * vlr / 1000
    pl = plr - pr
    e += pl
e *= XU / 1000000
print("Input power was %.3f uW" % (F * e))

import sys

#Time scale in us
XU = 2.0
#Voltage scale in V
YU = 0.2
#Resistor 3 resistance in ohms
R3 = 99.91
#Frequency in kHz
F = 50.0

#Scale is 20 units
#In calculations XU and YU are in ns and mV for unit
#Voltages are in mV and frequency is in Hz
F *= 1000
XU *= 1000 / 20
YU *= 1000 / 20
e = 0.0
for s in sys.stdin:
    if (s.strip() == ""): continue
    vlr = -1 * int(s) * YU
    pr = vlr * vlr / R3 / 1000
    e += pr
e *= XU / 1000000
print("Output power was %.3f uW" % (F * e))