Back
[01:06:07] * rue_shop3 tries to recall all the things on the todo list
[01:09:15] <SpeedEvil> #1 write todo list
[01:09:58] <DagoRed> SpeedEvil: google keep
[01:10:09] <SpeedEvil> yeah
[01:15:01] <DagoRed> It's amazing
[01:23:34] <rue_shop3> I have todo lists everywhere
[01:24:27] * DagoRed works on this observer some more.
[01:29:30] * rue_shop3 designs a leveling foot for the new reprap to replace the new ones that have never been used yet
[01:32:43] * rue_shop3 opens up a cad program and lets half his mind drift off to sleep while the other half works
[01:37:34] <DagoRed> nice
[02:30:48] * rue_house chants to himself "its only midnight"
[02:32:48] <Loshki> rue_shop3: until you have todo lists of todo lists, you're just an amateur
[02:33:43] * rue_house suddenly downs in thoughts of how to recursivly structure the todo items
[02:33:57] <rue_house> *burp* drowns
[02:34:28] <rue_house> I have mental issues, I cant work on anything at any point in time
[02:34:37] <rue_house> what I do needs to fit what I'm capable of at the time
[02:34:50] <rue_house> right now I'm starring at code
[02:35:07] <rue_house> but the part of my mind that can get anywhere with it went to sleep some time ago
[02:36:13] <rue_house> http://paste.debian.net/417246/
[02:36:55] <rue_house> I need to find the block called entities
[02:37:12] <rue_house> when I find a code 2 thats got the string "entities" I'm there
[02:38:29] <rue_house> code: 0, value SECTION
[02:38:29] <rue_house> code: 2, value ENTITIES
[02:38:30] <rue_house> code: 0, value LINE
[02:38:30] <rue_house> code: 0, value ENDSEC
[02:43:18] <DagoRed> rue_house: for find section... just use grep.
[02:44:47] <rue_house> this is a C library for reading dxf files, not a flipping bash script
[02:45:09] <rue_house> why dont I just import emacs and write a lisp cam for it?
[02:45:12] <rue_house> geeeez
[02:47:30] <rue_house> http://paulbourke.net/dataformats/dxf/
[02:47:36] <rue_house> trying to understand the basic code
[02:47:53] <DagoRed> ok
[02:48:12] <DagoRed> FYI, I wouldn't have made input a global variable but that is just me .
[02:48:55] <rue_house> I'm focusing on learning how to parse dxf files
[02:49:04] <rue_house> I converted the BASIC code to C
[02:49:21] <rue_house> it didn't work casue its too old, there are new sections its not familiar with
[02:49:28] <rue_house> but I'm learning
[02:50:22] <rue_house> aaah I see
[02:52:43] <DagoRed> :)
[02:53:19] <rue_house> this can be really sloppy
[02:53:38] <DagoRed> For learning... yeah
[02:53:59] <DagoRed> I'm creating my own observation class for the first time.
[02:54:05] <rue_house> I dont do global variables, but it was a quick pass on the transation from basic
[02:54:13] <DagoRed> understood
[02:54:29] <rue_house> converting basic with all the gotos was evil enough
[02:54:39] <rue_house> I cant belive I used to write that stuff
[02:54:48] <DagoRed> You can perform jmps's in c
[02:55:22] <rue_house> yes, but if I do a goto in C my soul will be burned alive by satan himself
[02:55:27] <DagoRed> You've done a lot and it is quite impressive. Its ok to be at a point where you forget more than most people have done.
[02:55:42] <DagoRed> truth about actually using goto's in C
[02:57:22] <rue_house> code: 0, value LINE
[02:57:23] <rue_house> code: 5, value 43
[02:57:23] <rue_house> code: 100, value AcDbEntity
[02:57:23] <rue_house> code: 100, value AcDbLine
[02:57:23] <rue_house> code: 8, value 0
[02:57:24] <rue_house> code: 62, value 256
[02:57:26] <rue_house> code: 370, value -1
[02:57:28] <rue_house> code: 6, value ByLayer
[02:57:30] <rue_house> code: 10, value 0.0
[02:57:32] <rue_house> code: 20, value 0.0
[02:57:34] <rue_house> code: 30, value 0.0
[02:57:36] <rue_house> code: 11, value 25.0
[02:57:38] <rue_house> code: 21, value 42.0
[02:57:40] <rue_house> code: 31, value 0.0
[02:57:42] <rue_house> code: 0, value ENDSEC
[02:57:44] <DagoRed> ... spamming hard enough?
[02:57:44] <rue_house> perfect.
[02:57:54] <rue_house> yea cause the channel is SO busy
[02:57:55] <DagoRed> oh damn
[02:58:01] <DagoRed> and... point
[02:58:52] <rue_house> so the only way I know its a line is cause code 0, "LINE" ?
[02:59:06] * DagoRed shrugs
[03:00:01] <rue_house> code 8 is layer name
[03:00:12] <rue_house> and the line IS indeed on layer 0
[03:00:51] <rue_house> 62 Color index (if not BYLAYER).
[03:01:34] <rue_house> 370 isn't known by the document I'm reading
[03:01:48] <rue_house> 6 Entity linetype
[03:02:04] <rue_house> ok, so
[03:02:36] <rue_house> I suppose I'm looking for 0, LINE and then gathering up 10,20, 11,21
[03:03:02] <rue_house> I wonder if I should care about layer
[03:03:53] <DagoRed> probably
[03:04:31] <rue_house> I dont like the format much since you can only imply where the end of things is
[03:04:59] <rue_house> for example, it looks like the only way I'd know the data for that line stops is because there would be another 0, LINE for the next one
[03:05:44] <rue_house> and I didn't know that dxf was a 3d format that handled extrusions
[03:07:18] <DagoRed> that's interesting.
[03:10:11] <rue_house> yea, so you see a code 0 thats called LINE and you know you have line data starting
[03:10:51] <rue_house> when you see the next code 0, you look back on any code 10,11, 20, 21 you have collected and expect its the co-ords of the last line
[03:11:11] <rue_house> the code 0 you see will either be the end of a section or another line
[03:11:36] <rue_house> this begs to be implemented as a state machine
[03:13:38] * DagoRed needs to crash
[03:13:50] <DagoRed> Oh...
[03:14:07] <DagoRed> So the file is broken for instructions from point to point
[03:14:32] <rue_house> its.. implicit to some degree
[03:14:34] <DagoRed> That is badass... and simple (from the perspective of I'm not writing a parser for all the codes).
[03:14:46] <DagoRed> implicit yes, but effective.
[03:14:50] <rue_house> yea, you can skip data like crazy
[03:15:02] <rue_house> heaven forbid you get a broken file
[03:15:14] <DagoRed> yeah... then you're boned
[03:15:30] <DagoRed> anyway, bedtime for me. Creating this observer model is a pain!!!
[03:15:58] <DagoRed> Essentially, redoing something similar to this:
https://sourcemaking.com/design_patterns/observer/cpp/3
[03:16:02] <DagoRed> .info
[03:16:04] <makepi> DagoRed: Observer Design Pattern in C++-
http://j.mp/1UI1zPL
[03:17:09] <rue_house> http://ruemohr.org/~ircjunk/images/sandblaster.jpg
[03:17:12] <rue_house> mmmm blacka nd red
[03:17:24] <rue_house> hah , its totally a nightrider theme
[03:17:45] <DagoRed> Get it to say hello Micheal and its perfect.
[03:18:15] <rue_house> ... dont tempt me
[03:25:20] <Jak_o_Shadows> Oh yeah, dxf is 3d
[03:25:23] <rue_house> Line 0.000000,0.000000 - 25.000000,42.000000
[03:25:27] <rue_house> wow, it worked
[03:25:53] <rue_house> I suppose I have to make a test file with TWO lines in it now
[03:25:58] <Jak_o_Shadows> haha
[03:26:11] <Jak_o_Shadows> I should learn how to parse text files prperly, I do it often enough in python
[03:26:38] <rue_house> you can use a regex in X
[03:26:41] <rue_house> er C
[03:27:33] <rue_house> Line 0.000000,0.000000 - 25.000000,42.000000
[03:27:36] <rue_house> Line 0.000000,0.000000 - 3.000000,3.000000
[03:27:42] <rue_house> sweeeet
[03:27:52] <rue_house> I can scrape lines from dxf files!
[03:28:21] <rue_house> next arcs and circles!
[03:28:22] <Jak_o_Shadows> You know, I'm never sure regex is the best way of parsing files.
[03:28:22] <z64555> parsers are basically fancy state machines. or at least, that's how mine turned out
[03:28:35] <Jak_o_Shadows> Yeah, I was thinking a state machine of some ind
[03:28:47] <rue_house> yes, state machines are a good way to do it if your good at writing them
[03:29:12] <z64555> node graphs are great for designing them. :)
[03:29:19] * rue_house chants to himself "its only 1am"
[03:29:32] <Jak_o_Shadows> Somebody clafified to me the other week that you can change state from more than onc eplace
[03:29:34] <rue_house> I need to get better with state machines
[03:29:35] <Jak_o_Shadows> That really helped me.
[03:30:18] <Jak_o_Shadows> Possibly I've gone too far and am now thinking of them too much as event driven. But I don't think so.
[03:31:03] <z64555> yeah, I'm not really seeing how state machines nor parsers could be event driven
[03:32:01] <z64555> state machines are a real simple concept, in program code they're a big-ass switch block inside of a while(1) loop
[03:32:45] <z64555> you switch from state to state by checking for certain criteria within each case
[03:33:05] <Jak_o_Shadows> Well, you change state based on an event. Sure, you do checking, etc. but you only do that every event
[03:33:20] <Jak_o_Shadows> Whether that event is just a clock tick or an interrupt
[03:33:50] <z64555> ah, that's what you meant by even driven
[03:34:08] <z64555> ok. For parsers, the state machine processing is done each time you process a token
[03:34:54] <z64555> get token; figure out what it is; do stuff; look for next valid token
[03:35:22] <z64555> if invalid token, set state to fail and maybe try to skip to the next line if you're able
[03:36:46] <z64555> lets say I want to read in a hex value from a text file
[03:37:01] <z64555> So, you read in a token "0xAB"
[03:37:32] <z64555> You check the first character, and see that it is a number
[03:37:52] <z64555> so you switch to the state that handles numbers
[03:38:03] <z64555> or
[03:38:16] <z64555> You see that is is a number, and see that it is a 0
[03:38:29] <z64555> As a rule, numbers that start with 0 are not decimal
[03:38:43] <z64555> and are either hex, binary, or octal
[03:38:55] <z64555> so you switch to the state that handles those
[03:38:58] <rue_house> http://paste.debian.net/417260/
[03:39:15] <rue_house> this is a memory state machines for tracking encoders
[03:40:04] <rue_house> http://paste.debian.net/417261/
[03:40:59] <rue_house> wait a min
[03:41:11] <rue_house> screw that its just a lookup table
[03:41:13] <rue_house> wtf
[03:41:20] <rue_house> where is my state machine?
[03:42:12] <z64555> yeah, I was about to say
[03:42:47] <rue_house> ok, apparently I forgot where I used my memory mapped C state machine
[03:42:58] <rue_house> .. thats gonna eat at me
[03:43:09] <z64555> anyway. so now you're in the state what the encoded number is
[03:43:38] <z64555> if the next characer is an x, it's hex. if it's b, it's binary, and if it's o it's octal
[03:43:53] <z64555> so then you switch states to the corresponding handler
[03:45:20] <rue_house> dear god, I just opened the source for the regex parser I wrote and it looks like it came from space
[03:45:22] <rue_house> coool
[03:45:46] <z64555> Yes, they do tend to be quite different from "normal" looking code
[03:46:11] <rue_house> well its recursive
[03:47:10] <rue_house> man I did a pretty good job on that
[03:48:25] <rue_house> http://ruemohr.org/~ircjunk/tutorials/elex/fsmflash/main.html
[03:48:28] <rue_house> there is always that
[03:48:45] <rue_house> just a simple clocked state machine with no inputs
[03:48:50] <rue_house> just feedback
[03:50:54] <z64555> neat
[03:51:03] <rue_house> CIRCLE 10, 20, 30 (center), 40 (radius)
[03:51:08] <rue_house> ARC 10, 20, 30 (center), 40 (radius), 50 (start angle), 51
[03:51:08] <rue_house> (end angle).
[03:51:26] <rue_house> that should be everything i want
[03:51:37] <rue_house> start angle eh?
[03:51:42] <rue_house> this could get ugly
[03:54:39] <z64555> wonder why they defined it as two angles instead of one angle and an arc length
[03:54:52] <z64555> (which is technically also an angle)
[03:55:06] <z64555> uh. no. no it isn't. sorry
[03:55:21] <rue_house> the hell comes in when your trying to work out if one of the ends meets up with a line somewhere
[03:56:03] <rue_house> and if its 3d, what plane is the circle on!?
[03:56:05] <rue_house> eh? eh?
[03:57:09] <rue_house> and where is 0*?
[03:57:26] <rue_house> angle in degrees? radians? gradians?
[03:57:33] <rue_house> bingrees?
[03:57:59] <z64555> I'm guessing in degrees. radians wasn't too popular in drafting
[03:58:25] <z64555> definitely not radians
[03:58:52] <z64555> milliradians? possibly. but that's rather tiny arc
[03:59:34] <rue_house> there are 256 bingrees to a circle, good for old dos games
[04:00:56] <z64555> never heard of a bingree, but that does make sense
[04:01:18] <z64555> although it would be closer to radians, really
[04:01:27] <z64555> or revolutions
[04:02:33] <rue_house> zippo:/files/programming/c/tests# ./a.out
[04:02:34] <rue_house> Line 0.000000,0.000000 - 25.000000,42.000000
[04:02:34] <rue_house> Line 0.000000,0.000000 - 3.000000,3.000000
[04:02:34] <rue_house> Circle 1.000000,1.000000 - 25.000000
[04:02:34] <rue_house> Arc 2.000000,2.000000 - 15.000000 - 0.000000->45.000000
[04:02:39] <rue_house> its right, its right!
[04:03:35] <rue_house> the code is still ugly, but it works
[04:03:51] <z64555> better than code that doesn't work :P
[04:03:56] <z64555> https://github.com/z64555/fs2open.github.com/blob/master/code/debugconsole/consoleparse.cpp
[04:04:12] <rue_house> http://paste.debian.net/417266/ I can take to slicing and dicing it properly later
[04:04:26] <z64555> my state machine parserrs are near the bottom, they're the dc_parse ones
[04:05:29] <rue_house> erm,
[04:05:34] <rue_house> you ...
[04:05:49] * rue_house clears throat gently
[04:06:37] <z64555> hm?
[04:07:39] <z64555> oh, wait, the dc_parse_double isn't the state machine
[04:07:43] <z64555> where is it...
[04:08:40] <rue_house> something like strtol()?
[04:09:58] <z64555> there's a bug with strtol, which is why I had to resort to making my own
[04:10:11] <rue_house> ah
[04:10:29] <rue_house> http://paste.debian.net/417267/
[04:10:32] <z64555> think it as to do with the atoi() or something
[04:10:38] <rue_house> it looks like I had to dance a bit myself
[04:10:56] <z64555> anyway. dc_parse_double(), dc_parse_long(), and dc_parse_ulong() are the ones in question
[04:11:07] <z64555> there's a number of helper functions to keep the machines trim
[04:11:43] <rue_house> it looks like regex code
[04:11:53] <rue_house> but I think my regex code is shorter
[04:13:21] <rue_house> wow you have some interesting thigns in here
[04:14:23] <rue_house> I didn't actually end up using my regex engine in my equation parser
[04:14:44] <rue_house> zippo:/files/programming/c/Equation/eqv5$ calc Pi*2
[04:14:44] <rue_house> Pi*2 -->> 6.28319
[04:16:11] <rue_house> BAM, I should have a defaults file it loads with all the default variables and functions
[04:16:35] <rue_house> tho, the command line calc is just a test for the library
[04:17:10] <rue_house> the idea was that I could use equations in any numberic arguments to my programs
[04:17:23] <rue_house> zippo:/files/programming/c/Equation/eqv5$ circle -r 2
[04:17:23] <rue_house> Radius is : 2.000000
[04:17:23] <rue_house> Diameter is: 4.000000
[04:17:23] <rue_house> Circumfrence is : 12.566371
[04:17:23] <rue_house> Area is : 12.566371
[04:17:24] <rue_house> Sphere area: 50.265484
[04:17:26] <rue_house> Sphere volume: 33.510323
[04:17:30] <z64555> right, FSO has a pstypes.h which has a bunch of constants and macros used everywhere. I adopted the idea for some of my other projects
[04:17:40] <rue_house> so I could say, circle -r 9/2
[04:19:17] <rue_house> zippo:/files/programming/c/Equation/eqv5$ calc "A+B(A=3)(B=5)"
[04:19:17] <rue_house> A+B(A=3)(B=5) -->> 8
[04:19:55] <z64555> :)
[04:20:05] <rue_house> zippo:/files/programming/c/Equation/eqv5$ calc "A+B(A=0b11)(B=15)(ResultBase=16)"
[04:20:06] <rue_house> A+B(A=0b11)(B=15)(ResultBase=16) -->> 0x12
[04:20:24] <rue_house> the stuff in the brackets is parsed first,
[04:20:43] <rue_house> it removes parts of the string its evaluated
[04:21:24] <rue_house> calc "(A=4)"
[04:21:24] <rue_house> (A=4) -->> 4
[04:21:34] <rue_house> if all else, the result is the last result
[04:21:57] <rue_house> I love it
[04:22:26] <z64555> :) it's a special kind of feeling when you design something, and it just works with whatever you toss it
[04:22:26] <rue_house> EVERY time I look at the clock its an hour later
[04:22:40] <z64555> solution: stop looking at the clock
[04:22:44] <rue_house> hahah
[04:23:18] <rue_house> ok, I'm gonna find a big ugly dxf for this program and go to bed
[04:24:34] <rue_house> coooool
[04:24:44] <z64555> hm?
[04:24:55] <rue_house> yea it did it
[04:25:14] <z64555> congrats
[04:25:15] <rue_house> http://paste.debian.net/417268/
[04:25:19] <rue_house> all sorts of objects
[04:26:01] <rue_house> lots of my stuff have reference layers with junk on them, so it might be a good idea to be able to filter by layer
[04:26:11] <rue_house> but whatever, I'll look at that more later
[04:26:28] <rue_house> I'm like > < that close to dxf -> cnc file
[04:26:45] <rue_house> ok, maybe > <
[04:26:54] <rue_house> but thats leagues closer than I was
[04:28:26] <rue_house> z64555, if you want to add another chapter to your program, have it accept words
[04:28:48] <rue_house> One Hundred Thousand and Fourty Two and a Half
[04:28:58] <rue_house> }:)
[04:29:11] <rue_house> evil, but really coool
[04:29:29] <z64555> I can do that easily
[04:30:41] <z64555> but I'm not, because there's no need and it takes a good bit of boilerplate to implement the dictionary
[04:37:56] <zzz64> g'night
[09:17:38] <MrCurious> http://imgs.xkcd.com/comics/the_three_laws_of_robotics.png
[11:10:25] <rue_bed> I wonder how I work out a path from random dxf objects
[12:12:12] <rue_shop3> hmm, thin walls of a tube on a 3d print push out more than thick ones
[12:37:49] <flyback> rue_house, get ahold of yourself dammit
[12:37:54] <flyback> <rue_bed> I wonder how I work out a path from random dxf objects
[12:37:55] <flyback> * ideabile has quit (Ping timeout: 276 seconds)
[12:37:55] <flyback> <rue_shop3> hmm, thin walls of a tube on a 3d print push out more than thick ones
[12:37:58] <flyback> SKITZONUCK
[13:25:11] <rue_house> ok I designed a dump controller for the solar yard lights, and a battery protection circuit
[13:45:34] <rue_house> http://paste.debian.net/417426/
[13:45:36] <rue_house> that was fun
[13:46:29] * DagoRed looks
[13:47:02] <DagoRed> it's so clean!!!
[13:47:32] <DagoRed> 0,1,3,4 for the lines at the bottom rue_house?
[13:47:55] <rue_house> I need to start wrapping this into a global-variable free library with a data output
[13:48:14] <rue_house> heh, offset by 1 gets me again...
[13:48:50] <DagoRed> It tends to get me as well.
[13:49:23] * DagoRed fighting with this observer model.
[13:49:53] <DagoRed> Trying to make this model work so that the baseclass calls up all registered components without actually KNOWING the components so far has been interesting.
[13:49:54] <rue_house> I should move this from /tests/ to /libdev/
[13:50:47] <DagoRed> maybe
[13:54:03] <rue_house> I'm trying to understand what your using it for
[13:54:30] <rue_house> automatic propigation of updates when base information changes?
[13:54:45] <rue_house> like a file browser seeing a just-added file?
[13:55:31] <rue_house> maybe a numberical list-summer auto updating when a new entry is added to the list by another process?
[13:55:48] <rue_house> I'm in the C world, I'd be using callbacks
[13:57:43] <DagoRed> It's a OOP way of doing callbacks.
[13:58:33] <DagoRed> It's for my IoT concept. The server needs to allow "listeners" which will be on a seperate thread so it may parse the volume of incoming data in ways that will be configured after the initial program is written.
[13:58:45] <DagoRed> i.e. way to handle plugins as needed for different information.
[14:01:52] <DagoRed> rue_house: It's a proper design to combat some monolithic monstrosity at the end that needs to be adaptable.
[14:02:26] <rue_house> how about a message bus
[14:02:45] <rue_house> everyone needs to process messages that apply to them, but everyone recieves all messages
[14:03:01] <rue_house> thats how my home automation system works
[14:03:06] <rue_house> port 77 on dingdong
[14:03:14] <rue_house> every client connects to it
[14:03:23] <rue_house> there is a standard message format
[14:03:32] <rue_house> everyone ignores messages that dont apply to them
[14:03:50] <rue_house> anyting anyone says is echoed to everyone else
[14:03:52] <rue_house> software hub
[14:04:35] <rue_house> zippo:~$ telnet dingdong 77
[14:04:36] <rue_house> CID:3
[14:04:45] <rue_house> my unique client number is 3
[14:04:46] <DagoRed> I'm connected to a message bus. This application connects to the message protocol.
[14:04:55] <rue_house> k
[14:05:18] <DagoRed> I'm avoiding the message bus becaue the other applications for this system may need to secure communications.
[14:06:02] <DagoRed> rue_house: You're right, it would work if security and isolation of devices on the bus wasn't one of the goals.
[14:06:33] <rue_house> look what happened to bluetooth and wifi securrity
[14:06:42] <rue_house> "your searching now? you must be the one!"
[14:06:47] <DagoRed> lol
[14:07:09] <rue_house> heaven forbid 12 people in a room try to assosciate their devices all at once
[14:07:28] <DagoRed> Yeah....
[14:08:41] <rue_house> ok, for the trillionth time I need to write code for doing list managment
[14:08:49] <rue_house> its getting easier tho
[14:09:04] <rue_house> I think I just need to copy the last code and change the type of struct its storign
[14:09:19] <rue_house> funny I never use my dual linked list code
[14:09:24] <DagoRed> neat
[14:10:07] <rue_house> gonna go walk aimlessly around the yard for a while
[14:11:41] <DagoRed> later
[14:11:51] <DagoRed> .in 30 m head out to TK's
[14:11:51] <makepi> DagoRed: Okay, will remind at 19:16Z
[14:14:43] <zzz64> ahh, that's why I made the state machines
[14:15:31] <DagoRed> z64555: why?
[14:15:49] <z64555> rue_house: I did end up using strtol and strtod, but I needed some preprocessing on the strings to determine what the number base was, as well as ensure the number was well formed
[14:16:03] <z64555> oh, and DagoRed
[14:16:27] <DagoRed> oh neat
[14:17:00] <z64555> strtol and strtod both have some error checking already, but it's rather limited
[14:19:27] <z64555> it also allowed me to expand the encoding a bit, my parser can take in 0x, 0b, and 0o, while strtol can only take in 0x
[14:20:03] <z64555> (the parser strips out the 0x before passing it to strtol and sets the appropriate base)
[14:41:51] <makepi> DagoRed: head out to TK's
[15:57:29] <rue_house> "odd, clean laundry usually dosn't go 'clink' OH!, THATS A CLEAN WRENCH!"
[16:08:38] <flyback> funsorted enjoy
[16:08:38] <flyback> <flyback>
http://imgur.com/a/OuoJM
[17:37:23] <z64555> flyback: your camera has trouble focusing, or your hand's too shaky
[17:40:59] <z64555> yeah, looks like you left it on "near" focus when you went outdoors
[17:41:11] <z64555> interesting collection, though. thanks for sharing
[18:47:56] <flyback> yeah hands shake
[19:11:33] <z64555> TIL that UDP packets can arrive at the destination late, sometimes after their "future" packet already arrived
[19:12:42] <z64555> This can happen in wireless systems as well, suppose you have a packet blocked between sender and reciever, and the packet manages to bounce around the obstruction but arrives at the reciever late
[19:40:58] <SpeedEvil> UDP has no order or delivery guarantees
[19:41:06] <SpeedEvil> that's why it's called unordered data protocol
[19:41:31] <SpeedEvil> err
[19:41:36] <SpeedEvil> nvm, misremembered
[19:41:42] <SpeedEvil> user data
[19:53:50] <z64555> user datagram protocol :)
[20:30:16] * z64555 tries to remember what a time delay looks like
[21:01:08] <rue_shop3> the same problem exists with avian carrier packets
[21:01:15] <rue_shop3> they arrive in random order
[21:31:13] <z64555> https://www.dropbox.com/s/h4slan5npnhnfja/netgraph.svg?dl=0
[21:31:16] <z64555> I made a thing
[22:33:45] <Snert> x-1 permutations of N dimensional space?
[22:42:28] <flyback> that's what she said Snert
[22:47:15] <Snert> pretty darned lofty :)
[22:54:06] <z64555> hm? no it's a probability graph of packet travel
[22:54:46] <z64555> through a network, or passive space
[22:56:12] <z64555> one thing I'm not sure if I modeled right was echoes
[23:01:10] <Snert> hehe I call those Steven Hawking Diagrams
[23:03:17] <MoziM> Anyone familiar with the nasa sample return robot challenge?
[23:12:18] <rue_house> if you come back from the job you get paid?
[23:13:45] <orlock> rue
[23:13:50] <orlock> you should see my craptacular coding
[23:14:06] <orlock> https://github.com/graphworlok/Equatorial_Basic_RA_DEC_LX200_Driver/blob/master/Equatorial_Basic_RA_DEC_LX200_Driver.ino
[23:14:26] <orlock> lines 266 - 268
[23:15:35] <rue_house> you know, the dt will always work
[23:15:43] <rue_house> for unsigned values
[23:16:42] <orlock> dt?
[23:17:24] <orlock> i hot glued a laser pointer to the top of the motor and timed it spinning around
[23:18:00] <orlock> (so i could time it against an exact point 4 meters or so away)
[23:18:11] <rue_house> .. or not
[23:19:04] <orlock> dt?
[23:20:04] <rue_house> zippo:/morfiles/programming/c/tests$ cat rollover.c
[23:20:04] <rue_house> #include <stdio.h>
[23:20:05] <rue_house> int main(void) {
[23:20:05] <rue_house> unsigned char a, b, c;
[23:20:05] <rue_house> a = 200;
[23:20:05] <rue_house> b = 60;
[23:20:07] <rue_house> c = a+b;
[23:20:09] <rue_house> b = c-a;
[23:20:11] <rue_house> printf("delta time is %d\n", b);
[23:20:13] <rue_house> return 0;
[23:20:17] <rue_house> }
[23:20:19] <rue_house> zippo:/morfiles/programming/c/tests$ ./a.out
[23:20:21] <rue_house> delta time is 60
[23:20:23] <rue_house> it walks all over the rollover
[23:20:31] <rue_house> the delta still works
[23:20:35] <rue_house> just not with signed values
[23:21:32] <rue_house> if you dont use signed time, you should be ok
[23:21:55] <flyback> http://www.ex-parrot.com/pete/upside-down-ternet.html
[23:21:56] <rue_house> as long as your doing relative values of less than 1/2 the max timeframe
[23:22:05] <orlock> really?
[23:22:09] <orlock> ok, i will try tonight
[23:22:17] <rue_house> ^^^ compiel that code!
[23:22:37] <rue_house> I just wrote it to comonstrate that
[23:22:45] <rue_house> demonstate
[23:22:56] <rue_house> ok, the part of my brain that does typing obviously went to sleep
[23:25:18] <rue_house> hahah flyback nice
[23:27:24] <flyback> yep
[23:31:14] <z64555> Snert: that style of graph is also used for controls systems and state machiens
[23:32:06] <Snert> ummmmyea :)
[23:32:15] <z64555> they're easy to draw, but can become messy quickly
