I expect to see a second robot soon with significant changes based on the lessons learned.

(I too just picked up a Bambu A1 printer after deciding to dive a little more into 3D printing. I can confirm it is amazing compared to the Ender-3 I had only dabbled with a bit before.)

This is my first printer so I don't have anything to compare it to, but to me it seems to "just work"

Bambu printers are much more polished in terms of hardware and software, making 3D printing more accessible. Their software is more of a closed source thing, but also a lot more polished.

I think a big part of this can be attributed to the 3D printing scene maturing a bit, but a lot is also specific to Bambu Labs

I had mine set up in local mode for awhile but the mobile app is useful for people in my life that don't care about learning how to work a slicer, so we use cloud mode.

This project seemed to go as well as my side projects, but when I run into a hiccup, I wait a month for a part on AliExpress, or wander around at Home Depot looking for something that I don't know what it is yet.

Kudos to you for surrounding yourself with great people. Thanks for the write up.

We are lucky to have him around too.

Demonstration of the arm: https://x.com/ChrisMGreer/status/1867278261631561996

[1]https://github.com/TheRobotStudio/SO-ARM100

[2]https://github.com/huggingface/lerobot

> I went into "screw with it until it works" mode. I took it apart, re-applied the magnet, swapped wires around, did all kinds of stuff. After a while of this, the error finally went away! No idea why though.

[0] https://github.com/madl3x/x-scara

Instead of inventing your own, you could have used Gcode as the protocol language.

Using Gcode is a good idea, though it does seem a bit overkill for this simple application

o1 = atan(y/x) - acos((x^2 + y^2 + L1^2 - L2^2) / (2 * L1 * sqrt(x^2 + y^2)))

o2 = acos((x^2+y^2-L1^2-L2^2)/(2L1L2))

I do remember being frustrated by the endless papers on SCARA and the importance of the inverse kinematics but no mention of what they actually were. So here they are. (I just checked now, and there seem to be at least a few papers online with the derivation. Times have changed)

I also have this:

  def do(self, (x, y), (dx, dy)):
        """ Calculate o derivative (do1, do2) given position (x, y) and desired movement derivative (dx, dy)
        """
        xy2 = x**2 + y**2
        ll2 = self.L1**2 + self.L2**2
        lld2 = self.L1**2 - self.L2**2
        # do1
        N = x*dy - y*dx
        M = xy2
        P1 = x**4 + 2 * x**2 * (y**2 - ll2) + y**4
        P2 = -2 * ll2 * y**2 + lld2**2
        P = P1 + P2
        Q = xy2
        PQ = math.sqrt(-P/Q) 
        R = (xy2 - lld2) * (x*dx + y*dy)
        S1 = math.sqrt(xy2)
        S2 = P
        S = S1*S2
        # do2        
        T = 2 * (x * dx + y * dy)
        U1 = (2*self.L1*self.L2)**2 - (x**2 + y**2 - ll2)**2
        U = math.sqrt(U1)
        return -(PQ*R)/S + N/M, -T/U

BTW if memory serves, parsing basic SVG is pretty easy. Though, these days it may be more useful to implement a gcode parser as there are so many freely available gcode generation tools.

The fastest way I have right now is a large look-up table (ie. precompute angles for each point of a canvas with a sufficient precision, then use the table to do fast searches for the nearest point).

https://github.com/AnykeyNL/Quincy/blob/master/coordcalc.py#...

There is a loop in a loop that goes through all the possible values of x and y to find the correct ones. No wonder it's so slow!

The scipy solver - inspired by the original article, I used https://docs.scipy.org/doc/scipy/reference/generated/scipy.o... - isn't much faster though (from reading the docs, it's just a smarter random search).

I guess it's time to learn some linear algebra (again!) and create a custom algorithm.

Also, you can probably get much faster results if you obtain the gradient of the forward kinematics.

I am trying multiple optimizations right now, mostly centered around reducing the amount of lookups required.

If you feel pulled at all, just dig in right now.

Even if you never make the leap professionally, and it's just a few hobby projects, it'll 10x your regular SWE work while also broadening and deepening your understanding of the increasingly digitally controlled world around you.

JST-EH is my preferred connector for most through hole type stuff. That shit really stays in place after it's plugged in.

Drives me bonkers.

https://www.mattmillman.com/info/crimpconnectors/common-jst-...

JST-EH has a 2.5 mm pitch, plus housing, plus orientation. I cannot see where that shall be any smaller than the omnipresent, universal Dupont connectors. Maybe you mean something different with "DuPont".

By the way, strictly for home breadboard uses only, when I need a bit more resistance than bare DuPont I wrap it in double sided tape and let the header poke through it. Kind of works.

Unfortunately the market has decided that unless it serves ads in billions of eyeballs it does not matter.

If it's useful for you to learn, then it matters, right?

There are also endless applications for hardware, but I guess to make a viable product you probably need a sizeable team of people.

I learned a lot of computer vision skills from that job, and it turns out this kind of computer vision is directly applicable to robotics as well.

So, I applied for a role as a vision engineer at my current job, and got the role :) This is where I work now: https://www.monumental.co/

Apart from my vision skills though, I was also just generally a good fit - I had a lot of startup/small company experience, I'm a pretty good software engineer apart from the computer vision, and the culture fit was there as well. I feel very lucky that the stars all aligned for me to be here.