GDPR and DSGVO law

Storing Cookies (See : http://ec.europa.eu/ipg/basics/legal/cookies/index_en.htm ) help us to bring you our services at overunity.com . If you use this website and our services you declare yourself okay with using cookies .More Infos here:
https://overunity.com/5553/privacy-policy/
If you do not agree with storing cookies, please LEAVE this website now. From the 25th of May 2018, every existing user has to accept the GDPR agreement at first login. If a user is unwilling to accept the GDPR, he should email us and request to erase his account. Many thanks for your understanding.
Amazon Warehouse Deals ! Now even more Deep Discounts ! Check out these great prices on slightly used or just opened once only items.I always buy my gadgets via these great Warehouse deals ! Highly recommended ! Many thanks for supporting OverUnity.com this way.

User Menu

Powerbox

Smartbox

3D Solar

3D Solar Panels

DC2DC converter

Micro JouleThief

FireMatch

FireMatch

CCKnife

CCKnife

CCTool

CCTool

Magpi Magazine

Magpi Magazine Free Rasberry Pi Magazine

Battery Recondition

Battery Recondition

Arduino

Ultracaps

YT Subscribe

Gravity Machines

Tesla-Ebook

Magnet Secrets

Lindemann Video

Navigation

Products

Products

WaterMotor kit

Statistics

  • *Total Members: 82889
  • *Latest: themehow

  • *Total Posts: 501303
  • *Total Topics: 14929
  • *Online Today: 44
  • *Most Online: 103
(December 19, 2006, 11:27:19 PM)
  • *Users: 6
  • *Guests: 27
  • *Total: 33

Author Topic: Bifilar pancake coil overunity experiment  (Read 6945 times)

Offline ayeaye

  • Sr. Member
  • ****
  • Posts: 409
Re: Bifilar pancake coil overunity experiment
« Reply #120 on: October 05, 2018, 10:03:08 PM »
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.


Free Energy | searching for free energy and discussing free energy

Re: Bifilar pancake coil overunity experiment
« Reply #120 on: October 05, 2018, 10:03:08 PM »

Online citfta

  • Hero Member
  • *****
  • Posts: 669
Re: Bifilar pancake coil overunity experiment
« Reply #121 on: October 05, 2018, 10:44:28 PM »
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

Offline ayeaye

  • Sr. Member
  • ****
  • Posts: 409
Re: Bifilar pancake coil overunity experiment
« Reply #122 on: October 05, 2018, 11:06:02 PM »
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.


Free Energy | searching for free energy and discussing free energy

Re: Bifilar pancake coil overunity experiment
« Reply #122 on: October 05, 2018, 11:06:02 PM »
Sponsored links:




Offline ayeaye

  • Sr. Member
  • ****
  • Posts: 409
Re: Bifilar pancake coil overunity experiment
« Reply #123 on: October 06, 2018, 10:05:48 PM »
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).

Quote
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.

Quote
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))

« Last Edit: October 07, 2018, 12:44:45 AM by ayeaye »

Offline ayeaye

  • Sr. Member
  • ****
  • Posts: 409
Re: Bifilar pancake coil overunity experiment
« Reply #124 on: October 07, 2018, 04:08:36 AM »
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.

Quote
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))

Quote
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))


Free Energy | searching for free energy and discussing free energy

Re: Bifilar pancake coil overunity experiment
« Reply #124 on: October 07, 2018, 04:08:36 AM »
Sponsored links:




Offline ayeaye

  • Sr. Member
  • ****
  • Posts: 409
Re: Bifilar pancake coil overunity experiment
« Reply #125 on: October 07, 2018, 06:35:26 PM »
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.

Quote
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.

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

« Last Edit: October 08, 2018, 02:36:23 AM by ayeaye »

Offline ayeaye

  • Sr. Member
  • ****
  • Posts: 409
Re: Bifilar pancake coil overunity experiment
« Reply #126 on: October 09, 2018, 02:31:05 AM »
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.

Quote
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.

Quote
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"


Free Energy | searching for free energy and discussing free energy

Re: Bifilar pancake coil overunity experiment
« Reply #126 on: October 09, 2018, 02:31:05 AM »
Sponsored links:




Offline TinselKoala

  • Hero Member
  • *****
  • Posts: 13817
Re: Bifilar pancake coil overunity experiment
« Reply #127 on: October 09, 2018, 07:19:50 PM »
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.



Offline ayeaye

  • Sr. Member
  • ****
  • Posts: 409
Re: Bifilar pancake coil overunity experiment
« Reply #128 on: October 09, 2018, 07:20:23 PM »
Quote
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.

Quote
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

« Last Edit: October 09, 2018, 10:01:00 PM by ayeaye »

Free Energy | searching for free energy and discussing free energy

Re: Bifilar pancake coil overunity experiment
« Reply #128 on: October 09, 2018, 07:20:23 PM »
3D Solar Panels

Offline TinselKoala

  • Hero Member
  • *****
  • Posts: 13817
Re: Bifilar pancake coil overunity experiment
« Reply #129 on: October 09, 2018, 10:38:51 PM »
Quote
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?




Offline ayeaye

  • Sr. Member
  • ****
  • Posts: 409
Re: Bifilar pancake coil overunity experiment
« Reply #130 on: October 09, 2018, 11:06:08 PM »
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....?

With weights yes. With oscilloscope... Sure what goes through the different circuits there, can be different, though it mostly isn't. I calibrated my oscilloscope to the inverted channels too, as much as i remember. Or then was it written in the manual, i did everything written in the manual.

But about programming. It should really not be an unsurmountable obstacle to take samples from the oscilloscope and write some simple code to do calculations from these. The results of these calculations can be trusted too, they are reality, telling what really is there. Or it can be found out how much they correspond to the reality. More than that, when taking samples from the oscilloscope, it's more precise, as samples are precise.

Even with an analog oscilloscope, like look at the screen image of the collector voltage above, you cannot very exactly see where it goes, right? But after drawing it with Inkscape on the image of the oscilloscope screen, and plotting the obtained samples, one can easily see the particular values of the voltage.

Like as my mathematics teacher once told, computer is a tool of perception  And this is what it really is, computer is for modeling reality.

What concerns all kind of finding an area, etc, this is making simpler the things that don't need to be made simpler. As when there are samples, it's not difficult to do all kind of calculations from these, area is the most trivial.

The following are scripts that calculate from lists, also put in ideone. With i don't know what lists, just that you can see that it works. There is unfortunately no other way, that i know, to change the code, than to go to main page, and paste the code and input again. Not really the best, certainly not for python, but it is most widely used. Why so, it's more like a paste board for code, that then runs it too.

Input.

https://ideone.com/KpnQoU

Output.

https://ideone.com/gZVrj5

Is it really so complicated? Like run the following in ideone. Write any sequence of numbers in stdin, run it, and in stdout will be all these numbers multiplied by 1.2. In that case no lines in stdin should be empty, including the last one. In every iteration, the string s is the next line in the standard input, and float(s) converts it to a floating point number. If there is something that can be converted to a number. There must be : after the for statement, and say 4 spaces before every statement in the loop. Assigning like 0.0 to variable, creates a floating point variable. Then it should be no problem to do any calculations from the list. import sys imports the sys module, to read the standard input. That's all.

Quote
import sys
 
a = 1.2
for s in sys.stdin:
   print(float(s) * a)

There is also a python interactive shell, at the following link. Code can be pasted there. I tried the input script, it worked when i pasted all  bout the last two sentences, and pressed enter. Then pasted the list, then pressed ctrl-d, this ends the input. Then pasted the last two statements, and got the right result. It's very nice to play, to learn python.

https://www.python.org/shell

« Last Edit: October 10, 2018, 08:11:36 AM by ayeaye »

Free Energy | searching for free energy and discussing free energy

Re: Bifilar pancake coil overunity experiment
« Reply #130 on: October 09, 2018, 11:06:08 PM »
3D Solar Panels

Offline ayeaye

  • Sr. Member
  • ****
  • Posts: 409
Re: Bifilar pancake coil overunity experiment
« Reply #131 on: October 11, 2018, 03:56:29 AM »
One small problem that i encountered, some versions of python require parentheses after print, some don't. So the Inkscape script should better be the following for it to work with all versions.

Quote
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)))

I played with online shells, in the  python shell i had to right click at the bottom right and select open frame in the new tab, as otherwise in my browser the last line was rather half. There are other shells like the following, and all worked for me.

https://trinket.io/console

There is also the following online compiler that also enables to edit code. It is perhaps the best onine compiler, but rather difficult to use.

https://repl.it

Python, some say no, spreadsheet. I showed before that spreadsheets are not precise enough when many numbers need to be calculated and added. Sometimes they may be good enough. But that spreadsheets are overall good for electronics calculations, i don't quite agree, but opinions may vary.

I think i now told everything. For this experiment it's necessary to somehow calculate power from samples for the input part and output part. Thus all the python scripts and such. No matter what one prefers for that. I hope that i at least provided enough information to show what calculations have to be done, and how to do them. I think that i have nothing more to say, ask if anything is not clear.

« Last Edit: October 11, 2018, 08:16:57 AM by ayeaye »

Offline ayeaye

  • Sr. Member
  • ****
  • Posts: 409
Re: Bifilar pancake coil overunity experiment
« Reply #132 on: October 12, 2018, 07:49:59 AM »
No, i'm sorry, the trinket shell doesn't work when pasting the scripts. The python.org one however does. Go to the following link.

https://www.python.org

And there click on the > in the big yellow square. This launches the interactive shell. And when doing it like that, the last line was not half in my browser, it worked fine.

You cannot paste code beyond the for loop that reads the standard input. You can paste up to and including that loop and then press enter, this indicates that you entered the loop, and it will be executed. Then paste the input, then press ctrl-d, this ends the input. Then paste the rest of the code, it will be executed right away, and the result will be printed. One can even run the Inkscape script in that way, pasting all the content of the svg file. In the input loop it just finds that string of the path. You can write print(str) and see that it's there. Then paste the rest of the code, and it will output the list made from that string.

There is Trinket online compiler that enables editing. A text file can be created there, it is not so good though that it cannot be used as standard input. So to solve that, name that file always input.txt, and it is used the same as input. The following are the scripts in there, and they can be run and edited.

Inkscape.

https://trinket.io/python/bcebcac99c

Input part.

https://trinket.io/python/3b8301221e

Output part.

https://trinket.io/python/249128ab54

PS Rigol DS1052E has seemingly in its samples 25 units in one y scale and 50 samples ("points") in one time scale. In run mode it gives 600 samples that should correspond to one screen  https://rigol.desk.com/customer/en/portal/articles/2269119-how-do-i-format-the-data-returned-from-a-ds1000e-d-series-scope- . This can be tested. There the raw value is subtracted from 240, then the value corresponding to the center of the screen is subtracted.

« Last Edit: October 12, 2018, 04:50:28 PM by ayeaye »

Offline ayeaye

  • Sr. Member
  • ****
  • Posts: 409
Re: Bifilar pancake coil overunity experiment
« Reply #133 on: October 13, 2018, 02:03:27 AM »
The inherent error of Rigol DS1052E is by that +/- 2% of the voltage scale. Which is two times more than the error of the analog oscilloscope like mine, by its calibration requirements. By the specifications the precision of my oscilloscope is +/- 3%, but this doesn't correspond to the rest of data, and is thus likely artificially too low, as i said.

When the traces of the analog oscilloscope are drawn with 50 units per scale, and it's done correctly, then it's thus twice the precision of Rigol, and most of the error doesn't come from the method, but from the oscilloscope. But overall one can get the Rigol precision +/- 2% of the scale, when getting samples with that method.

To estimate the error thus, calculate the input part with 2% of the voltage scale added, and the output part with 2% of the voltage scale subtracted from all samples (points). The efficiency that there is by calculating in that way, is the minimal efficiency there is considering the errors. Based on what i can say from what i know so far.

Which is one more reason i think to get the waveform data out of the oscilloscope and do calculations from that. I don't have much idea how any calculations the oscilloscope itself may do, can be altered in that way. The other reason being that about the calculations that the oscilloscope does, it is likely not known how these calculations are exactly done, and thus their possible error cannot be estimated.


Offline ayeaye

  • Sr. Member
  • ****
  • Posts: 409
Re: Bifilar pancake coil overunity experiment
« Reply #134 on: October 14, 2018, 02:04:52 AM »
I'm sorry, reading things here, get some new ideas. Or just to explain. TinselKoala thought that a coil, and a capacitor in parallel with it or something, is an equivalent of a bifilar coil that has capacitance. This is certainly not the equivalent, one thing it has not twice the inductance of the ordinary coil, as a bifilar coil has.

But i thought, what may be closer to an equivalent, is. Add capacitors between the windings, in several places of the coil. Like, the coil has the radius 100 mm, one capacitor between the bifilar windings for every 10 mm of the radius, that is, one 10 mm from the center, other 20 mm from the center, etc. Then the current doesn't have long way to go to the nearest capacitor, and maybe not so much lenz effect. That way bifilar coils can be made with a great capacitance between the windings, that cannot otherwise be made an all.

Just an idea that came to my mind, when reading some things. Don't judge me, i have not analyzed that idea, not tested, don't know whether it's right or any good. Just got an idea and put it out.

Yes, Trinket is a good online Python. Very easy to change both the code and the input data, all in one place, nothing else really provides that. Except spreadsheet, yes spreadsheet, spreadsheet is not good for all calculations.

https://trinket.io/python/403945f28d

https://trinket.io/python

I created a thread about it here.

https://overunity.com/17949/python-online-compiler

When you get the waveform data out of the oscilloscope somehow, then i may help to convert it and do any calculations from it.


 

OneLink