Debugging and Fixing Is Killing Me and the Mainboard Exploded :(

I have spent SO many hours trying to get this to work. It’s so annoying. This isn’t near how many hours I spent, I’ve been too frustrated to log it.

The case is incredibly annoying. Getting the initial case works fine. Doing all of this stuff makes it complicated and break and jam up.

The RS485 busses just randomly stop working.

The servo output is wiggly and not stable.

A PCB header snapped and I didn’t have replacements so I had to bodge solder it back on.

The mainboard voltage regulator literally exploded. It was a cheap part but yeah that literally just broke stuff.

Fixes to everything. CAD. Firmware. bruh

MG996Rs Finally Working

The servos finally work. I don’t even think this amount of hours logged is equal to how long this took, because I just got tired of it.

I think I printed like 20 new revisions of the case and servo mount. It was just so so annoying. While the general case worked, getting a reliable magnet output shaft was impossible. From tolerances, to my own errors to binding to hot glue getting everywhere, or superglue binding random gears, or my getting my fingers stuck to the actual case from superglue (was not fun and hurt)

The case finally works.

And the prototype code somewhat works too. It basically rotates until the sensor hits zero, it resets the “ticks”. A tick is a raw output from the AS5600. Because this magnet shaft spins faster than the output shaft, like 10x faster, the MCU needs to poll the sensor super quickly, which also needed some optimizations to clear the blocking bus communication wait that would let the magnet skip multiple full turns. The sensor doesn’t internally count turns so we just need to count manually and detect when it jumps from 4096-0 or the other way around.
It then spins around until the sensor is hit AGAIN to calculate tick to degrees, assuming the sensor was zeroed before, and then the current ticks would equal 360 degrees.

Another problem was the servo needs a PWM signal to move. The threshold from stop to go is pretty garbage on these cheap servos, leading it to spin quite fast already when at the lowest PWM value. Instead when far from the value it increases the PWM signal, closer it brings to minimum and starts linearly flickering the PWM signal from 0 to the speed, with the closer it is the more ratio of time stopped to inch it closer to the target.

It actually surprisingly works. It’s very fragile though, any skipped reads, from potentially slow bus transfers would completely throw it off, so all the code running locally on the weak 8 bit MCU needs to be extremely lightweight.

Yeah this was super super painful. I’ve been sitting here redoing superglue and code for hours.

Servo Code

I did some slight refining to the servo case again, making the tolerances tighter to keep the gears from wobbling. It’s still sort of loose, so I need to just keep trying over and over again.

I’m also still writing the servo code. It’s already much more organized than before. I’m also learning Vim keybinds and stuff to try and code faster.

The RS485 bus communication works now, and it’s just sending dummy telemetry data back right now. It can also control the servo fine. I’ve just been doing like the lower level architecting I guess, or not really I’m not sure. Before everything was crammed into a single file and now there’s actually header files and multiple source files and it’s actually somewhat readable. I had an issue with LED control for a second but that’s fixed now :)

V2 Servo Case Working; Servo Code Revamp WIP

After around 10 more revisions, the new servo case is fully working with the magnetic extender. The V2 is significantly better designed and higher efficiency than the last, more guess and check result.

I’ve also started to rewrite the servo code. Right now, its really messy and just kind of snowballed over time as I’ve slapped on patches and features to a fundamentally weak base. I’m in the progress of writing that now, hopefully it will be done soon. It will also include the new auto calibration and encoder usage and PID (and potentially advanced auto tuned curve to combat motor acceleration overshoot and backlash)

Working on IK System & Resoldered Joints Again

Bruh so my robot arm after finally being assembled by the way exceeded it’s limits and tore its wires out. I had to take apart the mainboard assembly again, which just is SO TEDIOUS. I just dumped solder and hot glue again and fixed a short caused from another wire being sheared off.

Also I’m working on the IK system, but it’s not really going well right now. I need to add offsets and config to each of the motors to get them to work correctly. The motors hooked up right now started crashing into my table sadly. Hopefully it will work soon.

I also continued working on the servo case. I still haven’t added the code to calibrate and get closed loop control on the MG996R servos. The DS5180 encoders should be easier though.

Reprinted Arm Segments; Added Segment Cover; Servo Mount Working; Working on Web UI

I reprinted the arm segments, hopefully for one of the last times, I’ve went through so much filament already. It now allows the mainboard to be neatly packed inside, hiding most of it while still allowing wires to come out. Due to the design of the mainboard, the wires do have to stick out the front like that sadly.

To avoid crushing wires, the servo mount has been expanded to allow more clearance for wires and general electronics.

The servo mount works now with a new design. I remeasured and adjusted the sketches and added proper hole sizes and a little chamfer to allow the insert to slot in before using a soldering iron to melt it in to help align much better than before.

The web UI now shows a representation of the arm. It’s not tuned yet, so the angles are wrong but I’ll fix it soon. I had to move everything from Fusion to Onshape to create the assemblies, and then use a Python library to convert the Onshape assembly into a URDF file that can be rendered with the correct joints inside ThreeJS.

Next, I’ll be adding IK and general arm control.

Heatset Inserts Working; Fixing Faulty Motor Power Connections; Internal Fan Power Connectors

I verified that the servo cover works, and it’s much much better than the last version. The tolerances are much better this time, leading to less stress on the gears. The same amount of turning uses around 100mA compared to 300mA before, almost reaching it’s limit without any load.

Some motor power connectors disconnected, so I found it with a multimeter and added hot glue to some connectors to secure them.

I soldered the fan power things inside the PCB, but realized that the JST connectors I’m using are different from the fans. I might have to make a sort of adapter or something by crimping more wires.

And the heatset inserts finally work after some tweaking, before the inserts would get misaligned when put in, now with a aligning lip thing it can be slotted in and melted in more accurately.

New Mainboard Cover, Wiring, Bearing Revamp, Heatset Inserts, Servo Cover

I added space for the mainboard segment, now it has clearance to actually fit, I redid the cover for this segment, and now it can allow the wires to come out

The servo mount now has heatset inserts, because the previous screw in print kept slipping out, but this time the screws just would not go into the inserts through the mount for some reason? The screws went in normally, but with the tolerances, when multiple screws go in they just fight and push against the edge of the insert instead of going in.

The MG996R servo housing now has been redesigned, based off of picture references and calipers to attempt to be more accurate than the last one to try and reduce the amount of bad tolerances affecting the gears and making them misaligned, reducing torque output.

And just general wiring and CAD work.

Assembled Basic Arm Parts and Packaged Main Board Assembly; Reprogrammed servo MCUs & worked on web UI

I redid some soldering on the mainboard PCB, secured connections, and secured everything with tape for now. I’ll likely have to reprint the first arm segment to fit everything in flush because as you can see there are wires and things bulging out of the segment itself right now.

I also redesigned the CAD to include heat set inserts.

I did programming and a bunch of bug testing and fixing too. An hour of time was lost because Lapse errored out :((((( very sad about that :(

I also had an issue with data corruption on the RS485 bus but that is fixed now, and it works like it should.

Mainboard Stack Redo & Firmware Updates and Test Web UI

I had to take the electronics out, and redo some of the wiring. The screw terminals are pretty cheap and suck, which makes it incredibly annoying to use as it’s impossible to fit these thicker AWG wires in and they sometimes slide out of the terminals. When I’m done I’m probably going to hot glue the wires. The incredibly fragile flexible extension jumpers for data transfer between the stack is also super fragile, and especially doesn’t grip. Sometimes the data wires just slip out.

I took apart the arm, as during testing the motor stripped some screws. I’ve ordered some heat set inserts to prevent that from happening again, which will require me to reprint all the arm segments again.

I also added a simple web UI for moving the joints. There is an empty ThreeJS sidebar and the right has some graphs (real data) from the mainboard sensors. The smaller MG996R servos haven’t been mounted yet due to a power delivery issue from the mainboard but hopefully that will be fixed soon.

Test assembly and fitting of robot arm

I am mostly done with the core functionality of the mainboard, so i packed everything together and double checked eerything works including power
Then I started assembling most of the servos

The smaller servo casing doesn’t fit very well, and the transparent window doesn’t fit either

But the magnetic cover for the arm segments works great :)

It was a lot of fitting, screwing, testing with multimeter, etc

Finalizing hardware

I crimped and soldered almost the remaining wires, I’ve made some last redesigns to the arm CAD and I’m now fitting everything into the new prints and assembling.

I’ve also had a ton of trouble with my servo PCBs lately, but I found out a lot of the issue was my programmer is actually fried somehow, so I’m now using an old RPi Pico to act as a UPDI adapter so PlatformIO can now successfully program the ATtinys much better now.

A lot of the CAD was slightly tweaked so that everything fits better

Servo firmware almost done

The servo firmware now (with the mainboard) sends validation data back and forth so both the servo and mainboard can verify that the data was sent successfully and can ignore corrupted packets because my wiring can be flaky sometimes

The firmware now sends real data again and is much more robust, with a proper stateful LED that shows useful information, like offline, online and driving motor, homing, error (fast flashing of LED as red), and the error state is also triggered in the case of corrupted packets (I tried it and it works :))

I’m also still printing out the pieces to assemble the arm.

I actually have more hours working on it, I just forgot to log :(((((((

Rewrote all firmware; Fixing Servo Cover and a ton of other CAD; Almost fried everything

For the CAD, it doesn’t look like much changed, but I’ve basically redesigned a bunch of things and fixed tolerances and now it should move really smoothly. With the bearings added, everything moves incredibly smoothly now

Especially the servo cover was annoying. I needed to attach a magnet to the shaft which was really annoying.

I haven’t logged that well, I’ve done more like 15 hours of work instead of just 5 but whatever

Most of those hours was the painful debugging. RS-485 busses, JSON not communcating with the PC, dropped connections, corrupted data, disconnected jumpers, FTDI programmer becoming flaky for some reason

It’s just been pain :(((

Now the PC (screenshot) recieves all the data and sends all the data
You can see a lot (not all) of the telemetry being received. Ignore the volts though my math is wrong. Realtime connecting now works smoothly, as you can see the other RS485 servos are offline.

Bidirectional Communication To PC/RPi 5 with LeRobot & More CAD changes

I setup a basic class for my robot in LeRobot (which was a little confusing) and then I also got communication between the Pico and my PC working. Originally I have SPI pins exposed on my mainboard PCB to connect to the RPi 5’s GPIO pins, but for some reason after lots of debugging, even running it at super low speeds it just would not work. So I switched to just using serial over USB, and using the SerialTransfer library to send data more reliably.

The script on the PC now can send target joint angles, and receive a lot of data back, like if the joint is online, temp, current, angle, homing sensor, home status, LED, firmware version, voltage, etc

I also iterated on the CAD for everything, and it should be done soon. It’s just a bunch of tolerance fixes to make everything fit at this point and some new things like mounts for encoders and DC buck modules and fixing the CAD for the custom MG996R case.

Mainboard and other CAD

I got the mainboard to stack on top of each other with a weird jumper and two piece jumper holder and some screws setup which required some revisions and trying to get everything to fit. I’ve squeezed one of the DC buck modules into between the mainboard, and the second arm segment will hold the two remaining DC buck modules. The bottom mainboard PCB also has 2 smaller buck modules. There’s a lot of things going on with the voltages in this project due to the servos peak current draw being so large.

I also refined the arm segment CAD by some reprints and made the DS5180 servo fit better. I’ve also made one of the buck module mounts for the second arm segment to fit more cleanly.

Servo Control Working, More CAD and 3D Printing

I got the mainboard to be able to control the servo on the servo PCBs. I also tested a bunch of the functions, like the magnetic sensor, neopixel LED, etc
The communication now sends the PCB ID, and the target speed and the servo PCB echos it back and moves the servo.

I also worked on the CAD (and refined) for the mainboard connector that will make connecting the two mainboards not a total pain.

I also soldered the connectors on the mainboard PCBs for them to connect to each other.

Servo PCB Daisy Chaining Working

I plugged in the JST VH and JST 1.25mm wires into the PCBs, and they seem to work!

I adjusted the message struct to hold a desired PCB sort of address or ID. When the MCU detects that the ID matches the PCB (by using the solder jumpers at the bottom of each PCB to program the PCB ID), only then it lights up the LED and replies to the main board.

The mainboard now loops through IDs and sends a message and waits for a response.

I’m very very happy this worked without any really big problems.

Crimped JST VH wires, Connected JST 1.25mm wires, Soldered more PCB connectors

Crimping JST VH wires is a ton easier than JST 1.25mm, and after a bunch of failed attempts still, I got some okay crimps that work finally. It took me a long time because I didn’t know that I had to rotate the wire for the hook on the terminal to go into the housing hole, and then also that the box shape part on the terminal actually has to stick out of the crimper or the crimper will crush the whole terminal into bits

Finished Soldering all Smaller PCBs & Got RS-485 communication

working from main board to servo PCBs

First, I finished soldering the PCBs. I added the connectors for power
and the small data connectors. I also finished the servo expansion
boards that hold the magnetic encoder and sensor. I also finished
soldering the joint encoder PCBs that will track shoulder and elbow lift
servo positions.

I also got the bus communication to work. It was really really painful
and I was really scared it wouldn’t work.

First, the PCBs wouldn’t communicate at all. But eventually, I realized
that it was because I wasn’t supplying 3.3V to the main board. This is
when I realized that I haven’t adjusted the buck converters on the main
board to supply the correct voltage, so I was about to unsolder the buck
converter when I realized that I could just set the power supply to 5V
(which the ICs on the mainboard can handle luckily), and then adjust the
voltage down to 3.3V.
But after a really long time of debugging, it still wasn’t working. The
connection would sometimes work but was really flaky.

Eventually, I soldered on the RPi Pico 2 onto the board completely and
then found out the reason, it was because the ATtiny3216 was set to
clock at a slow speed that would mess with the communication. I made
them use the SerialTransfer library to send data more reliably and it now can communicate properly :)

Done Soldering Most PCBs, Crimped JST wires kind of

I’m pretty much done soldering, I just have like 3 more tiny PCBs and I should be done. The big main board PCBs are pretty much done, I just need to make some botched tall headers since the clearance of regular headers are too small, and the servo PCBs are almost done, with just some connectors left to solder.

Soldering JST 1.25mm wires ARE THE WORST EVER THING TO EVER EXIST

I spent 2 hours crimping terminals on multiple wires and its so so so annoying. I can barely hold the terminal itself and they are so easy to bend. I couldn’t afford the real tool to crimp them, so I have cheap crimpers that are the wrong size and can’t technically crimp these. If crimping the metal things wasn’t bad enough, inserting the terminals into the housing was even worse. The housing would bend, or I would accidentally somehow insert it where it shorts the pin next to it???

Also while soldering a JST 1.25mm connector on a PCB, I ripped the pads clean off the PCB. I guess that one just will be missing the daisy chain feature because it only has one connector for data now and all the components and MCU are already soldered on, which really sucks.

The rest of the servo PCB (4 in total for now) went fine though, and I’m getting faster at it.

Worked on firmware & CAD & Soldered Second PCB

I got the PCB and ATtiny3216 to power a servo. I soldered on the remaining components on it, like the custom LED (which just turns on when the motor is spinning for now) and the 100uF capacitor and also the RS485 bus IC.

I also changed the CAD of the arm to use a bearing and changed the servo horn to fit inside of the bearing. I’ve ordered right angle headers and the bearing and metal servo horn already. I also added some transparent parts to the arm design to make it look more interesting hopefully.

I also am almost done soldering the second servo PCB. Now that I have all the parts ready and I actually got better at soldering ICs I can do it faster now.

Finally got ATtiny3216 on PCB Working

This took so so long. Basically, I spent hours trying to get it to work. First, the 3.3V rail wasn’t getting power and the LED wasn’t lighting so I had to resolder the voltage regulator and then both green LEDs lit up, meaning everything was working.

Then I got my FTDI programmer, and plugged it into my PCB. Because I have a FTDI programmer and the ATtiny3216 has a UPDI programming interface, there is a resistor on the board to combine the two pins into one.

Even just getting megaTinyCore installed in Arduino IDE was a pain. The website that hosted the package info was down again, with an expired certificate. Apparently, this happens very often with it but I found an alternative mirror.

Then I tried flashing code, and it didn’t work. Then I realized that the board type I was using was the Optiboot version, and I couldn’t find the non Optiboot version so I had to flash Optiboot onto the MCU. I did not realize that doing this would cause problems later on. I also had to switch the programmer from the one that programs Arduinos to the UPDI programmer. But I STILL couldn’t get any GPIO to work.

I just tried things for hours. I switched to PlatformIO. I tried switching from C to Arduino in PlatformIO. I tried unplugging the programmer because I saw some voltage leaking from it. I tried emptying the caps and trying again. I probed every single pin to see if I wrote the wrong pin.

Then after all of that, when I switched to non Optiboot (having to find online that I have to downgrade megaTinyCore), and flashing that, it works. I think it was because flashing a bootloader burns some fuses to expect a bootloader, but when I flash my code it actually overwrites the bootloader code because I don’t have access to the TX and RX pins typically used to flash when Optiboot is installed, and that just caused the code to not run.

Soldered Smaller PCBs, Ordered Missing Parts, Continued CAD work

I soldered most of the small PCBs, but now I need to order the parts I missed from the first order I placed. I’m also running out of 0.1uF caps, which sucks.

I added a spot and holes for a fan on the camera mount and also some arm segment CAD improvements and back plating to hold the metal rods in. I printed out a test and it works fine.

As for the PCBs, I’m still waiting for a few parts.

Continued Soldering PCB (Diodes/LEDs, power circuitry, etc) and worked on arm CAD.

For the PCB, after some time, I got the power switching circuit to output power. It’s a collection of things that I hope will make it safer, with a some diodes and a fuse, some MOSFETs, so the main MCU can command to send power, and also another stage that requires the E-STOP to not be pressed to actually be able to send power through with two MOSFETs (one main power, another switch the main MOSFET).

I added a fan to the global shutter main wrist camera since it gets hot, and added a new “head” to the arm segment CAD (the heads are swappable depending on what you need to print) for the smaller motor for the last DOFs in the arm. It fits my custom daisy chaining two part PCB hat for the MG996R to give it current, temp, power sensing, and daisy chaining power and data via a RS485 bus with an onboard MCU to provide communication and control. I added some holes for airflow for this PCB. I also added some screw holes to actually connect the halves of the arm together.

Continued Soldering and Working on CAD

I snapped some headers and soldered on some more ICs on the PCBs. I did also mess up and ordered a wrong footprint for a part, so now I have to delay that too. It’s so tiny I can barely see the pins.

I also worked on the CAD, where I designed the stereo camera holder, added a spot for the RPi 5 to go on top, and maybe a display. I also made a V2 of my grabber since the old one didn’t work well.

It also seems that Stardance isn’t syncing my time properly, and it’s missing a few hours so that’s annoying :(

I soldered some parts on the PCB, and worked on the CAD files some more

I did realize that I forgot some parts, so I ordered them on DigiKey. I’ll continue soldering the rest tomorrow. One of the parts was the LDO, which I only found out because I soldered the parts and realized that the voltage being put on the 3.3V rail is 5V

My project needs both versions of the same LDO and I only bought the 5V one
I also bought the wrong resistors. I’ve ordered them and they should arrive in a week or so.

My design of stacking the PCBs and then adding the buck modules in the middle might be very challenging, and I might need to stack multiple headers on top of each other to fit the modules inside. Hopefully it will still fit inside my arm segment and not short anything. There also needs to be sufficient airflow, which is def a challenge

Added Bottom Reinforcements with holes for magnets and wiring

Added Fans and airflow holes

And just fixed and refined the CAD, like adding spots for magnetic attached front and back plates and more