Bifilar pancake coil overunity experiment

[ayeaye]

On the figure below, is the collector voltage (relative to the circuit ground) when the transistor is conducting. With the voltage scale even less, the oscilloscope started to distort the waveform. My oscilloscope is 20 MHz Hitachi V-222, and it was calibrated by every detail of the manual.

The frequency was 50 kHz, the duty cycle was 10%, voltage scale was 0.5 V, time scale was 0.5 us, base resistor R1 was 560 ohms, Arduino was used as the signal generator, the power supply voltage was 11.6 V. It was aligned with the ground before measuring DC, the ground was on the central X axis on the screen.

It was the most precise measurement that i can make of the collector voltage. It appears to be even less than the previous less precise measurement. As it can be seen, It starts from almost 0.2 V, then goes to 0.1 V, and then goes back to 0.2 V. In the calculations thus it should better considered to be 0.15 V, instead of 0.2 V as i suggested earlier. The difference will be never greater than 0.05 V, which is small enough to measure only one channel as i said, with no significant imprecision.

About drawing the analog oscilloscope screen images with Inkscape, it may sound weird but it appears to be the most precise method. The drawn images can be compared to the original, to estimate any imprecision. It is likely more precise than weighing paper, as TinselKoala suggested, as drawing on the paper is less precise, it can be drawn with great zoom in Inkscape. With high enough resolution, the precision is great enough. What concerns extracting the samples directly from the images, the traces there look something like a cloud, i see no way to do it with any precision. The digital scope screen images are better, as they are digitally made, i have done that here. But even there, the traces are rendered and antialiased, so the result is not precise enough. What concerns the Inkscape script, it should be the following.

import sys

def next(separator):
    global pos
    begin = pos + 1
    pos = str.find(separator, begin)
    if (pos == -1): pos = len(str)
    return int(round(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))

As i just noticed, that Inkscape once wrote there something like 94.998 instead of 95. In spite that when it always snaps to grid, all numbers in the path except the first two, must be integers. That one wasn't, this must be a bug kind of. Why always snap to grid, because in the path, for every point there is written the difference from the previous point. When the path is long, adding the float numbers will every time be a bit inexact, but adding integers is always exact. Make the grid as small as you like, but always snap to grid.

Say that we call it svgtolist.py, we paste the text from above into eg worpad, then save it with that name. We can run it on the command line like the following. It reads the standard input and writes to the standard output as such simple scripts do. We can provide a file as an input such as mypath.svg, that was written with Inkscape, with <, and we can provide a file where the output goes with >, like list.txt. Works in linux and in windows cmd console. In ide-s there are other ways to provide input and output, by copying or providing file names somewhere.

python svgtolist.py < mypath.svg > list.txt

[ayeaye]

I continue to struggle with the Inkscape script, i cannot make it perfect, i don't know how Inkscape really does things and i don't have all the time in the world to find out, i just hope that i can make it usable.

In the following version of the Inkscape script i simply made the added x absolute. As i encountered a case where the change of x was negative, and the biggest problem was that i couldn't figure out when it is negative, as both times the beginning x coordinate of the path was negative. Inkscape also did other weird things, like i added a segment to the beginning. Joining the nodes of the segment and the path should merge all into one path, which it did, but the problem, the beginning segment was still missing in the path in the svg file. What was the reason for that, i yet cannot figure.

import sys

def next(separator):
    global pos
    begin = pos + 1
    pos = str.find(separator, begin)
    if (pos == -1): pos = len(str)
    return int(round(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] + abs(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))

On the figure below is the plot of the collector voltage from above. The oscilloscope screen image was drawn with Inkscape with 50 units in a big square, converted to samples with the script above, and the list of samples was then plotted. As the scale was 50 units and considering the oscilloscope scale, 10 units there correspond to 0.1 V. The following are the gnuplot commands to plot this, collector.txt is the file that contains the output of the Inkscape script, sample list.

set xtics 10
set ytics 1
set grid xtics lt 1 lw 2 lc "gray"
set grid ytics lt 1 lw 2 lc "gray"
set yrange [0 : 40]
plot "collector.txt" w l lw 3 lc "blue"

[TinselKoala]

You could check for one type of oscilloscope artifact (DC bias offset) by inverting the channel display on the oscilloscope and then running your analysis on that inversion. Your normal trace has the input pulse above the baseline and the return pulse below the baseline. Inverting the channel will put the return pulse above and the input pulse below the channel baseline. If your effect is not the result of a scope channel DC bias offset, the output pulse may still be larger than the input pulse even when their positions relative to the baseline have flipped.  On the other hand if the "OU" does not survive channel inversion.... well, we may have learned something about oscilloscopes and measurements.

[ayeaye]

You could check for one type of oscilloscope artifact (DC bias offset) by inverting the channel display on the oscilloscope and then running your analysis on that inversion.

I don't quite understand what do you mean, if i invert something, then i also invert that in the calculations.

You should understand simple code, there is really not much in it to understand. You may ask questions, i will answer. I'm not the best coder in the world, but things like that i certainly can do, and i think everyone can when learning a bit. I don't think it's good to add comments to every line of code, because then one cannot really see what the code does. Also i have no idea what one doesn't understand, so i don't know what to explain. But as you wanted a commented code, that is the following.

import sys

#Return next number, ending with the separator
def next(separator):
    #pos can be changed in this function
    global pos
    begin = pos + 1
    #Find the separator, starting from begin
    pos = str.find(separator, begin)
    #If not found, then that's the last number
    if (pos == -1): pos = len(str)
    #Return the number as int from rounded float
    return int(round(float(str[begin : pos])))

str = ""
#Iterate through the input, every line will be in the string s
for s in sys.stdin:
    #Find the start of the path
    begin = s.find("d=\"m ")
    #If not found, go to the next iteration
    if (begin == -1): continue
    #Find the beginning of the sequence of pairs
    begin = s.find(" ", begin)
    #Find the quotation mark that ends the sequence
    end = s.find("\"", begin)
    #Assign the found sequence to the string str
    str = s[begin : end]

#The index of the current character in str
pos = 0
#Create the list of segments
list = []
#Ignore the first pair
next(",")
next(" ")
#Make the start of the path to be (0, 0)
list.append([0, 0, 0, 0])
#Iterate through the sequence in str
while (True):
    #Add the change to the last x and y
    x = list[-1][0] + abs(next(","))
    y = list[-1][1] - next(" ")
    #Assign them as the end coordinates of the segment
    list[-1][2] = x
    list[-1][3] = y
    #When the end of the string was reached, don't continue
    if (pos == len(str)): break
    #Add next segment, with last x and y as start coordinates
    list.append([x, y, 0, 0])

#The index of the segment in the segment list
n = 0
#Iterate through the segments, ending with the last x
for j in range(list[-1][2]):
    #While the iterator is last x or more, go to next segment
    while (j >= list[n][2]): n += 1
    #The x and y length of the segment
    lx = list[n][2] - list[n][0]
    ly = list[n][3] - list[n][1]
    #The ratio of the current position to the x length
    ratio = float(j - list[n][0]) / lx
    #Output the start y, adding length corresponding to ratio
    if (j): print list[n][1] + int(round(ly * ratio))

The Inkscape script above run in the ideone online compiler

https://ideone.com/UGNXl1

[TinselKoala]

I don't quite understand what do you mean, if i invert something, then i also invert that in the calculations.

Really? You don't understand? That indicates two things to me: First, you don't understand the kinds of errors that oscilloscopes can suffer, and second, you don't understand how to do control experiments to check whether you are suffering from systematic experimental errors, like BUT NOT LIMITED TO improper use and understanding of your test equipment.




Let's say you have two weights that you need to compare, and your only measurement tool is a two-pan balance scale. So you put weight A on the left pan and you put weight B on the right pan, and sure enough, the scale deflects with weight A being lower than weight B. Do you immediately conclude that A is heavier.... OR DO YOU DO THE CONTROL EXPERIMENT of swapping positions and putting A on the RIGHT pan and B on the LEFT pan to see if the "heaviness" follows the A weight or stays on the same side with the SCALE itself being out of kilter some how....?


Do you get it now?