Bifilar pancake coil overunity experiment

[ayeaye]

Tinsel, i don't know whether the cable that i used in my coil was the following, but it looks similar. A shielded speaker cable, this is a pair of coaxial cables, two coaxial cables in parallel.

https://www.konigelectronic.com/audio-video/cables-connectors/speaker-cable-reel-2x-014-mm2-100-m-black-55938694

I made a pancake coil out of it, with 17 turns. Then connected one of this pair of cables as a bifilar pancake coil, and then the other too. Then connected these two coils in series, which is like two pancake coils one on the other, connected in series.

The coil made of coaxial cable that you used, looks like very small. The equivalent to the one i used may be two bifilar pancake coils made of coaxial cable, one on the other, then it will be much bigger.

I will now do calculations for your test with the coaxial cable coil, from your oscilloscope screen image above. For that i will increase precision of the method 10 times. You don't have the trace for ch2 provided, so i make calculations assuming that your power supply was 12V, the voltage on the collector of your transistor was 0.3 V when the pulse was on (taken from the datasheet of c945), and that both of these remained the same during the first part of the cycle.

What was the real voltage of your power supply, what was the voltage on the collector of your transistor measured from the circuit ground during your test with the coaxial cable coil, and were these stable, or changed during the pulse on?

You have also a weird thing in your trace with the coaxial cable coil, like Evostars in this thread also pointed  out, the oscillations start to increase before the pulse starts, like it did anticipate that the pulse is coming. Evostars also had a large spike before the pulse starting. I cannot explain this. I mean, it is not necessarily future changing past or anything because these cycles are repeating, rather then some pattern settling in that fits the conditions during the whole cycle the best. But again i cannot explain this.

What concerns the drawing, i increased the precision in Inkscape to 100 squares per oscilloscope scale. This precision is very high and completely sufficient for anything. The problem though, is that these are not samples on the screen, this is some kind of rendering, and the trace can be lighter and darker. So it is difficult to decide where to put this end of the next line, how dark should the trace be where it really stops, etc. This brings imprecision. I will continue doing the calculations though.

[ayeaye]

Tinsel, ok, i did the calculations of your test with the coaxial cable coil as i said. I don't know whether all was correct, but by the ones i did it's very far from overunity. With the power source 12V, but in fact if it were 11V, it were still very far from overunity. It was very imprecise too, because the x scale was very narrow and it did ring a lot.

One question, is your table or bench made of steel perhaps? This will act as a core. Your spikes look very narrow, these resemble more the ones when there is a core, this does it, and then it's more like an ordinary coil with very unlikely any overunity.

L 1000 70 1000 510 *
L 1000 510 1020 900 *
L 1020 900 1020 3500 *
L 1020 3500 1040 3300 *
L 1040 3300 1040 2690 *
L 1040 2690 1060 2530 *
L 1060 2530 1060 2180 *
L 1060 2180 1080 2340 *
L 1080 2340 1100 2500 *
L 1100 2500 1100 2650 *
L 1100 2650 1120 2510 *
L 1120 2510 1120 2090 *
L 1120 2090 1140 1930 *
L 1140 1930 1140 1660 *
L 1140 1660 1160 1460 *
L 1160 1460 1160 990 *
L 1160 990 1180 770 *
L 1180 770 1190 610 *
L 1190 610 1200 480 *
L 1200 480 1220 370 *
L 1220 370 1220 170 *
L 1220 170 1260 330 *
L 1260 330 1280 200 *
L 1280 200 1300 330 *
L 1300 330 1400 50 *
L 1400 50 1430 130 *
L 1430 130 1460 50 *
L 1460 50 1500 130 *
L 1500 130 1520 50 *
L 1520 50 1540 90 *
L 1540 90 1610 0 *
L 1610 0 1740 30 *
L 1740 30 1790 130 *
L 1790 130 1970 0 *
L 1970 0 2220 90 *
L 2220 90 2350 30 *
L 2350 30 2650 -10 *
L 2650 -10 2680 -70 *
L 2680 -70 2700 -150 *
L 2700 -150 2720 -270 *
L 2720 -270 2740 -470 *
L 2740 -470 2740 -710 *
L 2740 -710 2760 -1030 *
L 2760 -1030 2760 -2050 *
L 2760 -2050 2780 -2400 *
L 2780 -2400 2780 -2680 *
L 2780 -2680 2800 -2510 *
L 2800 -2510 2800 -2340 *
L 2800 -2340 2820 -2240 *
L 2820 -2240 2840 -2440 *
L 2840 -2440 2860 -2080 *
L 2860 -2080 2880 -1590 *
L 2880 -1590 2900 -1350 *
L 2900 -1350 2900 -1080 *
L 2900 -1080 2920 -870 *
L 2920 -870 2920 -640 *
L 2920 -640 2940 -510 *
L 2940 -510 2940 -440 *
L 2940 -440 2960 -300 *
L 2960 -300 2960 -210 *
L 2960 -210 2990 -170 *
L 2990 -170 3020 -130 *
L 3020 -130 3060 -170 *
L 3060 -170 3080 -70 *
L 3080 -70 3110 -30 *
L 3110 -30 3170 0 *
L 3170 0 3260 -30 *
L 3260 -30 3360 50 *
L 3360 50 3410 -30 *
L 3410 -30 3460 50 *
L 3460 50 3580 -30 *
L 3580 -30 3690 50 *
L 3690 50 3820 -10 *
L 3820 -10 4000 50 *
L 4000 50 4210 -30 *
L 4210 -30 4410 50 *
L 4410 50 4630 -30 *
L 4630 -30 4820 90 *
L 4820 90 5010 -70 *
L 5010 -70 5200 90 *
L 5200 90 5380 -70 *
L 5380 -70 5530 50 *
L 0 0 6000 0 *

The Python scripts below are only for the case when the ch2 trace is not provided, and they are for high precision, 100 squares for an oscilloscope scale in Inkscape, don't use them otherwise. One more condition is that during the input part it always has to be greater or equal to zero. I think it should be changed, and the parts distinguished like by a different letter before, then they should be just two different paths in Inkscape. And i didn't really test very thoroughly that these ones are correct, i tested thoroughly the previous ones.

import sys

def next(s, str, list):
    global i1
    i0 = i1 + 1
    i1 = s.find(str, i0)
    if (i1 == -1): i1 = len(s)
    list.append(int(float(s[i0:i1])))
    return i1 == len(s)

i1 = 0
lines = []
for s in sys.stdin:
    l = []
    i1 = s.find("d=\"m ")
    if (i1 == -1): continue
    i1 = s.find(" ", i1)
    ends = s.find("\"", i1)
    s = s[i1 : ends]
    i1 = 0
    next(s, ",", l)
    next(s, " ", l)
    l[0] = 5000 + l[0]
    l[1] = 5000 - l[1]
    lines.append([l[0], l[1], 0, 0])
    while (True):
        l = []
        next(s, ",", l)
        done = next(s, " ", l)
        l[0] = lines[-1][0] + l[0]
        l[1] = lines[-1][1] - l[1]
        lines[-1][2] = l[0]
        lines[-1][3] = l[1]
        if (done): break
        lines.append([l[0], l[1], 0, 0])
x0 = lines[-1][0]
y0 = lines[-1][1]
for i in range(len(lines)):
    lines[ i ][0] -= x0
    lines[ i ][2] -= x0
    lines[ i ][1] -= y0
    lines[ i ][3] -= y0
for l in lines:
    print("L %d %d %d %d *" % (l[0], l[1], l[2], l[3]))

import sys

#Oscilloscope scale is 100 squares, square is 10 units
#Time for unit in ns
XU = 2.0
#Voltage for unit for ch 1 in mV
YU1 = 0.225
#Resistors 2 and 3 resistances in ohms
R2 = 987.2
R3 = 99.91
#Voltage of the power supply in mV
V = 12000.0
#Collector voltage in mV when pulse is on
VC = 300
#Frequency in Hz
F = 110001.0

def getlist(list, x0, y0, invert):
    for i in range(len(list)):
        list[ i ][0] -= x0
        list[ i ][2] -= x0
        if (invert):
            list[ i ][1] = y0 - list[ i ][1]
            list[ i ][3] = y0 - list[ i ][3]
        else:
            list[ i ][1] -= y0
            list[ i ][3] -= y0
    return list

def gety(list, i, t):
    lx = float(list[ i ][2] - list[ i ][0])
    ly = float(list[ i ][3] - list[ i ][1])
    dx = float(t - list[ i ][0])
    dy = ly * abs(dx / lx)
    return list[ i ][1] + dy

def output(s, e):
    #Energy in uJ
    e *= XU / 10 / 1000000
    print("%s power was %.3f uW" % (s, F * e))

lines = []
for s in sys.stdin:
    l = []
    i1 = 1
    if (s[0] != "L"): continue
    for j in range(4):
        i0 = i1 + 1
        i1 = s.find(" ", i0)
        l.append(int(s[i0:i1]))
    lines.append(l)

x0 = lines[0][0]
y0 = lines[-1][1]
lines.pop()
i1 = map(lambda l: l[1] < y0, lines).index(True)
x1 = lines[i1][0]
ilist = getlist(lines[: i1], x0, y0, False)
olist = getlist(lines[i1 :], x1, y0, True)

e = 0.0
i1 = 0
for t in range(ilist[-1][2]):
    while (t >= ilist[i1][2]): i1 += 1;
    vlr = gety(ilist, i1, t) * YU1
    ilr = (V - VC - vlr) / R2
    plr = ilr * vlr / 1000
    pr = vlr * vlr / R3 / 1000
    pl = plr - pr
    e += pl
output("Input", e)

e = 0.0
i1 = 0
for t in range(olist[-1][2]):
    while (t >= olist[i1][2]): i1 += 1;
    vlr = gety(olist, i1, t) * YU1
    pr = vlr * vlr / R3 / 1000
    e += pr
output("Output", e)

The output was the following.

Input power was 17.349 uW
Output power was 7.993 uW

[TinselKoala]

Hmm... I wonder why the scope produced a decreasing integral then. You may be missing spikes, or the scope may be just giving me garbage, or both.

I don't have any wire equivalent to yours but I do have more of the same coax that I used and I'll try to extend my coil and make 2 layers like yours, if I am understanding your description. A diagram would be very helpful.
No, all my testing is done on a wooden table. I am well aware of the effect of a "core" of flat iron or ferrite on the pancake coils, although when the windings are using coaxial cable things might be different.  In any case the coil I used simply doesn't have enough inductance. I tried a pure commercial inductor of 1.5 mH and it gives traces visually very similar to what I got with my own TBF coil, but not OU probably.
It would still be nice if you could reconstruct your circuit and your oscilloscope for some testing back and forth.
One thing I've noticed is that the transistor I'm using takes a while to turn off once the FG's pulse goes to zero. I am sure this affects interpretation of the data but I am not quite sure just how or if the effect is real. I am going to examine this further before I comment further, but you might look to see if the same thing is true for your transistor.

[ayeaye]

The svg file from these last coaxial cable coil calculations, was the following.

https://justpaste.it/4wikb

By theory, the collector voltage should remain the same when the transistor is open (saturated). Assuming that the power supply voltage also remains the same, only the channel 1 should be measured. The following Python scripts were made to calculate in that way. They are all checked and worked correctly. The following assumes using these scripts.

In Inkscape, turn off the document border in document settings, select snap always, and create grid 10 pixels per square, with 100 squares one big square. This big square corresponds to one oscilloscope scale. Draw the input part as one path, output path as another path, and x axis as third path, always in that order, this is important. The following Python script extracts values from the svg file made in that way.

import sys

def next(s, str, list):
    global i1
    i0 = i1 + 1
    i1 = s.find(str, i0)
    if (i1 == -1): i1 = len(s)
    list.append(int(float(s[i0:i1])))
    return i1 == len(s)

def getlist(list, l, s):
    list.append([l[0], l[1], 0, 0])
    while (True):
        l = []
        next(s, ",", l)
        done = next(s, " ", l)
        l[0] = list[-1][0] + l[0]
        l[1] = list[-1][1] - l[1]
        list[-1][2] = l[0]
        list[-1][3] = l[1]
        if (done): break
        list.append([l[0], l[1], 0, 0])

def printlist(list, letter):
    x0 = list[0][0]
    for n in range(len(list)):
        list[n][0] -= x0
        list[n][2] -= x0
        if (letter == "I"):
            list[n][1] -= y0
            list[n][3] -= y0
        else:
            list[n][1] = y0 - list[n][1]
            list[n][3] = y0 - list[n][3]
        print("%s %d %d %d %d" % (letter, list[n][0],
            list[n][1], list[n][2], list[n][3]))

ilist = []
olist = []
i1 = path = 0
for s in sys.stdin:
    l = []
    i1 = s.find("d=\"m ")
    if (i1 == -1): continue
    path += 1
    if (path > 3): break
    i1 = s.find(" ", i1)
    ends = s.find("\"", i1)
    s = s[i1 : ends]
    i1 = 0
    next(s, ",", l)
    next(s, " ", l)
    l[0] = 5000 + l[0]
    l[1] = 5000 - l[1]
    if (path == 1): getlist(ilist, l, s)
    if (path == 2): getlist(olist, l, s)
    y0 = l[1]
printlist(ilist, "I")
printlist(olist, "O")

The following was the output of that script, with the svg file above.

I 0 70 0 510
I 0 510 20 900
I 20 900 20 3500
I 20 3500 40 3300
I 40 3300 40 2690
I 40 2690 60 2530
I 60 2530 60 2180
I 60 2180 80 2340
I 80 2340 100 2500
I 100 2500 100 2650
I 100 2650 120 2510
I 120 2510 120 2090
I 120 2090 140 1930
I 140 1930 140 1660
I 140 1660 160 1460
I 160 1460 160 990
I 160 990 180 770
I 180 770 190 610
I 190 610 200 480
I 200 480 220 370
I 220 370 220 170
I 220 170 260 330
I 260 330 280 200
I 280 200 300 330
I 300 330 400 50
I 400 50 430 130
I 430 130 460 50
I 460 50 500 130
I 500 130 520 50
I 520 50 540 90
I 540 90 610 0
I 610 0 740 30
I 740 30 790 130
I 790 130 970 0
I 970 0 1220 90
I 1220 90 1350 30
I 1350 30 1650 -10
O 0 10 30 70
O 30 70 50 150
O 50 150 70 270
O 70 270 90 470
O 90 470 90 710
O 90 710 110 1030
O 110 1030 110 2050
O 110 2050 130 2400
O 130 2400 130 2680
O 130 2680 150 2510
O 150 2510 150 2340
O 150 2340 170 2240
O 170 2240 190 2440
O 190 2440 210 2080
O 210 2080 230 1590
O 230 1590 250 1350
O 250 1350 250 1080
O 250 1080 270 870
O 270 870 270 640
O 270 640 290 510
O 290 510 290 440
O 290 440 310 300
O 310 300 310 210
O 310 210 340 170
O 340 170 370 130
O 370 130 410 170
O 410 170 430 70
O 430 70 460 30
O 460 30 520 0
O 520 0 610 30
O 610 30 710 -50
O 710 -50 760 30
O 760 30 810 -50
O 810 -50 930 30
O 930 30 1040 -50
O 1040 -50 1170 10
O 1170 10 1350 -50
O 1350 -50 1560 30
O 1560 30 1760 -50
O 1760 -50 1980 30
O 1980 30 2170 -90
O 2170 -90 2360 70
O 2360 70 2550 -90
O 2550 -90 2730 70
O 2730 70 2880 -50

There the lines starting with "I" are the lines of the input part, and the lines starting with "O" are the lines of the output part. For each line there are four numbers, that are x and y coordinate of the beginning of the line, and x and y coordinate of the end of the line. Both the input and output part start with the x coordinate 0, y coordinates are relative to the x axis, and the output part is inverted. The following Python script takes that list as an input, and writes the input and output power of the coil, as an output.

import sys

#Time scale in us
XU = 2.0
#Voltage scale in V
YU = 0.225
#Resistors 2 and 3 resistances in ohms
R2 = 987.2
R3 = 99.91
#Voltage of the power supply in V
V = 12.0
#Collector voltage in V
VC = 0.3
#Frequency in kHz
F = 110.001

#Oscilloscope scale is 100 squares, square is 10 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
ilist = []
olist = []
e = 0.0
n = 0

def gety(list, n, t):
    lx = float(list[n][2] - list[n][0])
    ly = float(list[n][3] - list[n][1])
    dx = float(t - list[n][0])
    dy = ly * abs(dx / lx)
    return (list[n][1] + dy) * YU

def output(s, e):
    #Energy in uJ
    e *= XU / 10 / 1000000
    print("%s power was %.3f uW" % (s, F * e))

for s in sys.stdin:
    l = []
    i1 = 1
    if (s[0] != "I" and s[0] != "O"): continue
    for j in range(4):
        i0 = i1 + 1
        i1 = s.find(" ", i0)
        if (i1 == -1): i1 = len(s)
        l.append(int(s[i0:i1]))
    if (s[0] == "I"): ilist.append(l)
    if (s[0] == "O"): olist.append(l)

for t in range(ilist[-1][2]):
    while (t >= ilist[n][2]): n += 1;
    vlr = gety(ilist, n, t)
    pr = vlr * vlr / R3 / 1000
    ilr = (V - VC - vlr) / R2
    plr = ilr * vlr / 1000
    pl = plr - pr
    e += pl
output("Input", e)

n = 0
e = 0.0
for t in range(olist[-1][2]):
    while (t >= olist[n][2]): n += 1;
    vlr = gety(olist, n, t)
    pr = vlr * vlr / R3 / 1000
    e += pr
output("Output", e)

The output of that Python script with the svg file above, was the following. This was calculated assuming that the power supply voltage that TinselKoala used was 12V, that it was stable, and that the collector voltage when the transistor was open (conducting) was 0.3V, that was taken from the transistor c945 datasheet. And that it was also stable. He has not provided his real values for these yet, so these were the only ones that could been used.

Input power was 17.349 uW
Output power was 7.993 uW

[ayeaye]

Tinsel, the Python code, i don't know what is there to understand. Commenting it, i can comment it, but the code is self-commenting. And no this is not gigo, this is well written code, and you can try that it works.

What it is, mostly it's a classical parser. The first is what i would call a netlist converter. The graphs are in the form of paths in Inkscape. Path is, the coordinates of the first point, following by the series of pairs dx,dy of the differences of x and y from the previous point. Path is converted to netlist-like form, like in spice, a letter, and the coordinates of the beginning and end of the line. And they are normalized, the first x is 0, and y is relative to the x axis. Why is that, first that form enables to see better whether the extracted data corresponds to the drawn graph, but second it's easier to do calculations from a netlist-like data as well. Spice has wire diagrams and everything in that form, it's the easiest to work with.

The second script does the calclulations. And it in principle doesn't differ from doing calculations from sample data, just instead of sample data, it goes to the right line, and calculates the values there in the middle. Otherwise it like takes samples, after each small period of time, which is 1/1000 of the oscilloscope time scale. When the calculations were from samples, then it were for every sample. It's the easiest to do calculations in that way, the most straightforward, every going around makes it only more complicated, not simpler.

If you can get the samples of the waveform data from your oscilloscope, in any form, be it csv or any other, then you can send them to me, upload as file or when they can be written as text, write as text. I can then write a python script that does calculations from the data in any form. And i can do the calculations for you so that you don't have to, all you need is to get the data from your oscilloscope. Using spreadsheet, you know, real men don't use spreadsheets, real men use lists or maybe databases, but not spreadsheets. Spreadsheets are for wimps. But if you want to do it in spreadsheet, then i can do that as well. And in spreadsheet, you can do all the calculations that my python script does in every iteration, on ever spreadsheet row, then just add the energies of all trace, just as my python script really does.

When getting the data like in csv form, you would also need to visualize the data as a graph or such, to see where the parts really begin and end. I can do that with python, i can write it as an xpm image, but i can also use some graph libraries for python, these are easy to use, though not as minimalist to satisfy me. Spreadsheets can also draw graphs like from a data in a column, so you can use that. If the data is not in csv form, you can send it to me in a file, and i can convert it to csv or to whatever format.

I'm the most interested, can the calculations be done by only one trace, ch 1. It makes no sense to always measure two channels, when calculations can be done from one channel. The power supply voltage is always stable, at least when there is a good power source. Then the only thing left is the collector voltage, the voltage between the collector and the circuit ground. When the transistor is saturated, then this should always be the same. But is it always the same as on the datasheet, and is it always the same when the pulse is on and the transistor is conducting, and what its real value is, this should be measured.

I'm all for simplicity and minimalism, in everything, but then there is a question what the simplicity is.

Just for fun, on the figure 2 below is your oscilloscope screen, converted to 3 color xpm, i converted it with python code, after saving it as c source code image with gimp. I can do everything with it, make it to lines of single pixel, extract the values. But this makes no sense, because already the image converted to xpm is not exact, the original screen is rendered, with the shades of darkness, so it is a question what the right shade of darkness should be to be valid.