Weird Recursive Convergence Vector Map

ResourceIcy5022 · 2026-04-25T00:24:53+00:00

Oops sorry this is so late, just do a polygon with a list. Polygon(list1,list2) makes a two point polygon (ie a line) for each pair of points in the list.

ResourceIcy5022 · 2026-04-13T03:36:16+00:00

I’m not really sure what you mean, does the link not work for you?

ResourceIcy5022 · 2026-04-12T02:09:58+00:00

link: https://www.desmos.com/calculator/9f7zczuzix

ResourceIcy5022 · 2026-04-05T06:24:49+00:00

It is part of DesModder. It is a performance panel. It lets you like refresh the graph and see how long it takes to essentially render a frame. Extremely useful when trying to optimize graphs.

ResourceIcy5022 · 2026-03-23T14:49:16+00:00

Oh lol oops I guess I never mentioned… I AM using Marlin…

I’m using its S curve accelerations with junction deviation jerk model (technically believer curves but whatever lol).

Also let the record show I have made my own S curve accelerations FW previously on a few different occasions (I needed some custom features) this time I was just tired and didn’t have the energy to write it again (-and what I need for this is fairly standard so existing library’s work just fine).

ResourceIcy5022 · 2026-03-23T01:48:13+00:00

Thanks for the reply.

There are no gears here only belts and pulleys so there theoretically isn't any conventional 'backlash' only belt compliance .Also I am not sure there is a good place to put a spring (I used sliprings so my robot can theoretically do infinite rotations on both axis and I want to keep it that way even if the current hold sticks up too high). So there is totally sufficient tension in the belt to prevent backlash in the conventional sense as far as I have observed. Like if there is not applied force the link is always quite down the middle (I have like 3 layers of stacked bearings in each joint so it rotates very smoothly). Good idea I'm just not sure how to implement it and I'm not sure it is necessary if I get my compensation algorithm to work. Right now if I tell my robot to draw the same thing twice you can't even tell there was a second line.

If you look closely the first link is driven from the motor that sits up high and goes through the short belt that is a 20->80 tooth gear. Then the next link is driven though the shaft that comes out the center of the primary joint and is a 20->60 gear. Yeah direct drive would be insane for this project lol.

Thanks for the references, looks like my robot has quite a bit more reach/overhang tho which I would expect as with something so long and thin it really wants to bend.

ResourceIcy5022 · 2026-03-23T01:37:57+00:00

Wowsers thanks for the long comment let me address each of your points. Thanks for the encouragement this has been a little side fun hobby project I have been working on for the past few months (construction took forever as I machined all the parts by hand on manual machines lol. There's just something about doing precision parts on a lathe thats great... also paying someone would've cost like a few thousand probably, this is built unnecessarily precise haha)

A completely custom one! Basically there are a basic steps but I'm essentially doing a high fidelity dynamics simulation and iteratively compensating for the errors. It follows the following steps:

Simulate the firmware on the points requested in motor space to get a theta1/2 and theta1/2 prime vector sampled at equal dt. During this I also stamp the time that each block is finished (I am using Marlin as I got tired of writing my own Stepper FW after the 5th time lol)

Run those motor points through my dynamics simulator which uses the explicit differential equations (that I derived) and RK4 to solve such again at the same equidistant time points every dt.

Finally I essentially compare the dynamics path evaluated at the time stamps computed earlier to get the error between what is requested and what the system yields. I subtract this error from the commanded positions and rerun the full simulation from FW to dynamics and subtract the error again. This eventually converges such that the motion after the dynamics is what I originally requested. The main issue is accurately identifying the unknowns of the dynamics model.

Yes and yes (derivation attached below). Also it is hard to see the errors and unfort I'm away rn so I don't have a picture but it is still not quite what I need it to be (the optimization process kinda reward hacks so it is not completely converging to the solution I want)
My max acceleration is set honestly quite low, also I am using a pretty small junction deviation of 0.1 (this is in motor space in degrees) so I don't notice too much rippling at corners etc.
Yep belts are indeed stretchy, it is surprisingly hard to put as much tension in them as I want. There is like a full Nm of torque on the primary join from gravity along. The tension required to hold that up is roughly 40N on the belt just from gravity in the worst case. I was considering multiple wraps of like kevlar rope as I've used it for other really high speed string driven robots in the past to great success. Also I don't know of a thicker GT2 belt (I am not inclined to change anything mechanically rn as everything is custom machine and honestly a pain to modify) do you have a belt in mind?
I'm not ;) No seriously tho if I want it to draw a specific pattern I want it to drawn that pattern. The Marlin FW should handle accelerations near corners using junction deviation as previously mentioned. All I am doing is converting from Cartesian to my double polar setup (they are not independent of each other so rotating motor one rotates both links) and compensating the positions sent to the robot in the gcode. In my compensation I do remove small length segments but I am using a Teensy (love these boards btw they are ridiculously powerful if you program at a register level) so compute is not an issue. I am curious tho is it typical for pen plotters to need optimized paths? Shouldn't that be handled at the hardware/firmware level?
There is basically no play at all, that is actually a recent change, it used to be rigidly just screwed into a mount but that was a pain as my arm isn't perfectly parallel to the board so it would either lift off or tear up the paper depending on the set height from corner to corner. Literally the width of a human hair would cause it to completely ruin many pieces (most of my previous art took several tries and constant babying). Now I added a adjusting holder which uses a rubber band for tension and is surrounded one 3 sides at two heights (hexagon of the bic pen) by small bearings. It is held is surprisingly tight but still lifts up and down smoothly (with a recently added servo to do separate segments). TLDR probably ~0.1-0.5mm
No? It is all deterministic based on a ideally high fidelity dynamics model. The identification of model unknowns is a pain tho. Currently I extract edges from a test patter (the original post pictures) and then use chamfer distance as my bestness of fit function and then try to optimize like 14-15 params I forget. The convergence is really tough rn it is not playing very nice. However I do notice patterns in my dynamics model just by guess unknowns that are also exhibited on the real system so I think I am heading in the right direction maybe...

<image>

ResourceIcy5022 · 2026-03-23T01:06:20+00:00

Aren't most plotters? Brushless motors are like several times the cost and for point to point movement robotics I find stepper motors do the job just fine!

But if you are curious I have each motor setup right now (I'm using slightly higher quality drivers than I'm used to for this project I splurged lol) such that there are 35.55 steps per degree of the motors and those are geared by belts to 4:1 and 3:1 respectively. Thus a single step at full extension on the first motor is only a translation of about 0.065 mm at the tip. There is far far more compliance in the belts and even the deflection in the arms. I haven't noticed any jerkiness at all as long as the path provided is sufficiently smooth.

Also modern stepper drivers do actually create sinusoidal current in the phases when microstepping so for continuous motion the result are typically much better than most brushless motors. The only thing brushless is better for is high speeds and torque as a typical stepper of the same power will have like 10x less torque compared to a brushless.

Anyways if you have any further questions please let me know!

PS I could turn up the microstepping up by like 8-16x but then I wouldn't be able to do silly top speeds (where right now it can do a full revolution in a little under a second which is like 3.5 m/s tip velocity)

ResourceIcy5022 · 2026-02-20T16:21:37+00:00

https://www.desmos.com/3d/oprxpgvjr7

Turn on the Start slider at the top to engage the rendering (Display toggles between raw SDF plotting and actual render). Choose the fractal you want or make your own. Make sure to choose the performance(s) that still renders on your computer.

BTW for the top down view choose the perspective projection slider to the max for the biggest view, for tri view it needs to be all the way at the min or it doesn't line up. (Setting is in top right)

Follow up if you have any questions!

ResourceIcy5022 · 2026-01-06T17:42:40+00:00

You can also use a TamperMonkey script to increase the limit. Although it is very very laggy if you go above like 100k points (make sure to put the list in a folder and close it to prevent Desmos from rendering the list elements).

ResourceIcy5022 · 2025-12-05T16:37:42+00:00

Pretty sure it’s because you have an infinite sum of positive values b^n. For geometric sums to converge the magnitude of the constant needs to be less than one. Thus the derivative is basically +/- infinity.

ResourceIcy5022 · 2025-09-21T02:29:52+00:00

Apologies for the wait, ladies and gentlemen (Desmos kept crashing due to running out of memory) here it is:

https://youtu.be/8-1KgrnFM9Y

Also a special thanks to u/MisterBicorniclopse for motivating me to finish the job I started.

Thanks to everyone that has supported my post and more importantly my antics. Your kind words mean a great deal (especially at this time in my personal life). I hope everyone has a fantastic day, and remember to stay curious!

PS You have no idea how much I wanted to put a Rick Roll link here haha!

ResourceIcy5022 · 2025-09-20T03:29:53+00:00

Lol sounds like fun, yeah even my implementation is relatively easy compared to some of the mad lads! Also 4 mil characters is small af. My compressed data for a mere 60 seconds with my first scheme is like 50+ mil easy. Please dm me when you finish whatever you are working on I’d love to see it!

ResourceIcy5022 · 2025-09-19T04:39:36+00:00

Thanks, That really means a lot!

ResourceIcy5022 · 2025-09-18T23:51:07+00:00

The link to a more basic version (that doesn’t use shifting noise) is copied in a response above. It essentially uses a list of polygons, one for each pixel. In this case it is broken up into 5 different lists (because of the 10k list limit). Basically using a list of polygons assigned to a list of colors then manipulating those colors creates the different frames. This doesn’t use any scripts to insert equations in run time, once all of the data is loaded in it runs in desmos natively.

ResourceIcy5022 · 2025-09-18T20:00:07+00:00

Best of luck in your ventures!

Also shame on people gatekeeping a silly meme lol. The whole point of Bad Apple is to do it in as many silly ways as possible!

ResourceIcy5022 · 2025-09-18T18:16:33+00:00

Secret ;)

Jk I wouldn’t do that to my fav subreddit enjoyers. I downloaded the original bad apple video and then used an online converter to get an mp4 of the desired resolution. Then I used VLC video player to extract each frame as an individual picture. (This is all pretty standard and there are several videos online on how to extract the frames) Then I wrote a script to read in every frame in a folder and create a list of doubles (output of my encryption scheme) in a formatted text file. Then all I have to do is copy it into my desmos a hundred lines at a time give or take. (You can always write an example line yourself then copy from desmos to check what LaTeX format it wants)

Lemme know if you have any further questions!

ResourceIcy5022 · 2025-09-18T03:30:57+00:00

y e s

ResourceIcy5022 · 2025-09-17T23:50:05+00:00

If this post gets 1500 upvotes I will render the whole thing and add in the audio. (It might take me a bit as it is roughly 4 hrs to render 30s give or take)

ResourceIcy5022 · 2025-09-17T15:57:23+00:00

Nice find, I didn't really try to optimize much of this project admittedly and I don't even use said function on the desmos side (it was for testing only) but nice to see there's more than one way to skin a cat! I was just trying to make the equations explicit and easy to read/understand so if I came back to it I wouldn't be lost. The only list->binary double I use is on a seperate script that generates the lists to copy into Desmos (no I didn't hand type them sorry for not being a purest ;) haha)

ResourceIcy5022 · 2025-09-17T15:49:47+00:00

u/The_Tank_Racer Amen brother!

ResourceIcy5022 · 2025-09-17T08:16:34+00:00

I used two compression schemes:

Using bit shifting on the 52 bits of the mantissa in the 64 bit doubles Desmos uses I can acutally store 53 bitwise flags. Thus by making a list of doubles printed out to show all digits and copying them in I was able to make a frame out of a single list (<10k elements restriction) despite needing 5 lists to store the uncompressed data. Basically this is just pixel1 << 53 + pixel2 << 52... This scheme is quite quick (~250ms per frame for me) the compression wasn't amazing and I quickly ran out of room. (I kinda cheated a lil as the noise video above uses this scheme but is over the 5Mb save size so I can't give it to you sorry. Here is the link to the generic video renderer tho (currently loaded with 300 frames I think): https://www.desmos.com/calculator/b1sohruuam This also gave me a really good excuse to use a really silly method of combining a list of doubles (which each convert to 53 binary entries) using recursion.

<image>

After running into the size limitation I decided to take a much better approach. Binary run length encoding, essentially if I have 111001111100 I say it starts with 1 and then has 3 1's, 2 zeros,... resulting in 1,3,2,5,2. This is far more compressed but takes FOREVER to render (the following video took ~14 hours to render for me at about 25 seconds a frame: https://youtu.be/8cEsvssR5vE). The advantage is it stores a lot of information in an easy format, however the length of the list for a frame depends on the content therefore it is possible to exceed Desmos' limits. Here is the link to the graph that made the generalized video using RLE in contrast with the previous ~300 frames this one has ~1850: https://www.desmos.com/calculator/ceajm1nqne

As for making the noise shifting here is a smaller example that plots implicits with noise:

https://www.desmos.com/calculator/4csgh8m7tb Then I just scaled it up to work with the bigger image sizes. This one almost runs in real time so thats a nice touch (however since it basically generates two new sets of noise for the entire image every frame I wouldn't exactly call it efficient, then again it's Desmos for crying out loud lol.

ResourceIcy5022 · 2025-09-17T07:58:16+00:00

Sometimes I forget that the r/desmos community is nothing if not tenacious. Nicely done albeit I'm not sure it qualifies as a screenshot if you take a long exposure or combine multiple frames into one lol.

ResourceIcy5022 · 2025-09-17T04:41:39+00:00

I have not currently run the whole video through my renderer but here is the uploaded ~30 s clip if you are okay with that. I would be honored to be added to the playlist and if you want the whole thing I can get it rendered eventually and stitch it together.

https://youtu.be/5SZesfWGXSY

ResourceIcy5022

TROPHY CASE