@dhruvtoocool

I spent this session wrapping up the documentation and putting everything together for the repository release. I focused on exporting all the 3D assets, preparing the production files, and setting up the official GitHub repository so the whole project is cleanly tracked>

To allow other peeps to make this asw, I drafted a comprehensive assembly guide that details exactly how the individual 3D-printed parts, carbon fiber rods, and fasteners connect. I also uploaded the finalized KiCad schematics and PCB manufacturing files so the custom electronics shield is fully open-source.

Since this is the Helios MK-II, I also put together a direct breakdown comparing this build to the original MK-I. I highlighted the evolutionary updates, specifically the shift from a basic remote-controlled platform to a fully autonomous system, the massive improvements in structural rigidity through the new carbon fiber suspension joints over the old pcb ones, and the upgraded power management with the custom PCB HAT, a fuse, and hardware kill switch.

Okay, so I know, spending time in Blender doesn’t seem like the most justified use of time. But here’s the thing. When I put something in Blender, I tend to see it in the exact scenario it’s supposed to be used, if you know what I mean. And because of that, I’m able to sort of find these little niche things that I need to fix. And I keep making a note of these little niche niche things in my diary.

1. Added some standoffs for the motor drivers
2. Aura Farmed with blender

I created the bill of materials for the entire robot. While doing so, I noticed small errors in bearing sizes and screw holes, which I corrected. I then searched online, found all the required parts, and compiled them into a list.
Surprisingly, the total is only $144, far below my estimate of $200–$250, which is great.

I ended up spending this session tweaking a bunch of bearing sizes and just refining how everything fits together. I actually noticed a ton of minor misalignments across the chassis that I completely missed the first time around, so I went through and finally squared everything up.

Once the CAD model was actually sorted, I decided to sit down and figure out the logistics of how I’m going to build this thing. I went through the entire design to map out exactly what parts I need and the precise quantities for the build. I even started a master tracking file with direct links and sources for every single component, so I can just click and buy everything when it’s time to start assembling.

I spent this session bringing all the separate components into Fusion 360 to do a complete test fit. I pulled in models for the Raspberry Pi, the battery pack, my custom PCB, the Arduino Mega, and all the smaller hardware bits to see how they actually fit inside the chassis. The great news is that there’s a ton of extra room left inside the rover bed, which is going to make routing the wires incredibly easy.

After locking down the fitment, I moved the entire assembly over to Blender. I honestly just find Blender a lot more comfortable to work with than Fusion 360, and it let me see how the rover looks under different lighting and environments. I ended up spending some time assigning materials and setting up a few really cool teaser renders that I can start sharing. They’re just teasers for now, but I plan on spending more time later creating both high-end graphical shots and proper engineering renders.

I spent this session totally cleaning up the schematics because they were honestly looking extremely dirty, so I got everything organized and looking right.I also learned some pretty interesting stuff about grounding this time. I literally had no idea that all the grounds were supposed to be the same; I kind of figured different parts of the system would have different grounds. After messing around with it for a bit, I realized all the ground planes are the same but they absolutely have to be interconnected, so I went ahead and fixed that whole setup.

Another thing I realized is that I couldn’t find a UBEC that drops 12V down to 6V—they pretty much only come in 12V to 5V steps. Because of that, I had to pivot and shift the entire servo motor system over to run on 5V instead.

I also added some really nice-to-have features, including three indicator LEDs:
One is a fault indicator to show if anything goes wrong in the system.

The second one shows that the digital pins are working and the code is actually running.

The third one signifies that the UBEC power from the main system is coming in cleanly.

Along with those three status LEDs, I added a physical reset button. I had to move a few components around here and there to make space, but it was honestly pretty easy this time because the actual PCB layout was already solid.

The best part is that the only errors popping up on the DRC test are footprint overlaps, which is amazing since those aren’t even true electrical errors. The board is fully sorted, and it looks seriously cool with the new silkscreen graphics on it.

I honestly kind of messed up again with the previous version, even after I thought I had caught all my mistakes. What happened was I was trying to reference this one massive schematic that had both the Raspberry Pi and the Arduino mixed together using all these custom symbols. When I actually went to build the PCB from that schematic, absolutely none of the nets were linking up correctly, which completely broke the DRC test and left me with a total mess of errors.

Since I wanted to actually turn in a clean design with solid test results and not just some broken file, I decided to just scrap the board yet again. Honestly, third time’s the charm because I started fresh, completely rewired the whole thing from the ground up, and got everything routing perfectly. I even added some really sick custom silkscreen graphics to the board to make it look legit. The Arduino Mega shield is finally, officially done, fully sorted, and looking great.

Figured some shit about kicad out

It looks like I didn’t do a ton since the last update, but honestly, a lot of crazy stuff went down. I realized it was actually worth taking the time to learn how to design a proper PCB instead of just winging it and hoping for the best. Finding a decent KiCad tutorial was a nightmare, but I finally found one that clicked.

Right after watching it, I realized my entire board layout was completely wrong. Instead of trying to fix a broken design, I just scrapped everything I had done, started completely from scratch, and actually learned all the useful keyboard shortcuts to speed things up. The new PCB is looking way better and is honestly pretty close to ready. I just need to finish up the silkscreen layer, label all the components, and run the final diagnostics to make sure nothing blows up before I send it off.

Okay so this is my first time making a pcb, really looks like it doesn’t it LMAAOOOO. :)

But seriously learned a lot, prolly gonna re-do a lot of these connections. So far i basically did the motor drivers as well as a couple of sensors.

The purpose of this board is basically like one of those connectivity shields to sort of make cable managing the rover easy and unifying those similar systems together.

(P.s. Lookout ain’t at the same level of reliability as lapses yet. Like this 1hr 36min recording should have been more like 2hrs smth mins long. )

I spent this session building out the complete schematic in KiCad, focusing on component integration and system protection. I laid out the Arduino Mega, mapped out all the pin configurations, and wired up the core sensor suite, which includes the GPS and compass module, the LiDAR, and the CSI camera. I also integrated the RC receiver circuit so the rover can be fully operated via a remote control system.

With the main schematic finalized, I started designing a custom PCB HAT that will sit directly on top of the Arduino. This will keep the wire management incredibly clean and prevent any loose cables from disconnecting while the rover is moving. To protect the electronics, I also integrated a physical kill switch and a fuse into the power lines so nothing gets fried when the entire system is powered up.

I ended up diving deep into motor dynamics this time, specifically trying to figure out how torque and stall current actually interact. I learned that when a motor faces too much resistance and completely stalls, it basically stops acting like a motor and starts behaving like a giant resistor, which causes the current to absolutely spike. That made me realize how critical the motor driver is for handling those sudden surges. If the motor stalls, a low-quality driver just won’t be able to deliver that massive current and will probably fry, so I had to pivot and choose a much more capable driver. I spent the rest of my time in KiCad designing a much better electronics layout to handle those loads, using ChatGPT to do a lot of the heavy research and figure out the exact specs I needed.

Started work on KiCad.

I spent this session restructuring the sensor payload layout and resolving a few assembly conflicts.

The original LiDAR and camera mount was inspired by my drone design, but I realized the constraints are completely different for this rover. I initially attempted an in-canopy placement but decided against it, choosing instead to design a completely new forward-facing enclosure that mounts both the LiDAR and camera right at the front of the vehicle.

While finalizing the chassis, I caught a few Fusion 360 assembly constraints that weren’t aligning correctly and repaired the model hierarchy. With the assembly fixed, I added the proper hardware mounting points and bolting interfaces to the rear wing so it securely fastens to the base plate. Finally, I routed dedicated wire-management channels through the main chassis floor, ensuring all power and data lines can cleanly pass in and out of the electronics bay without getting pinched.

It finally looks like a production-ready build! I spent this session organizing the entire project hierarchy, making sure every part is properly named and structured into clean sub-assemblies.

Mechanically, I added locking points for the structural frame. I designed connector holes across the differential and motor housings so that screws can pass directly through the 3D-printed parts and secure the carbon fiber rods, locking everything firmly into place.I also finalized the roof panels for the chassis. To keep them easily removable, I planned out recessed channels for small magnetic strips, allowing the panels to snap effortlessly onto the main body.

For the payload, I designed a dedicated, integrated housing to mount the LiDAR unit and the CSI camera together. Finally, I threw a custom rear wing onto the back of the chassis, mostly for aesthetics, but if the print budget and print bed space allow for it, it is definitely staying on the final build!

It finally looks amazing! I spent this session cleaning up a lot of joint and assembly errors, separating the individual components, and modeling the main chassis body. The differential now successfully hooks directly into the chassis. I also added a prominent geometric structure to the rear, which will serve as a heavy-duty mounting rig for sensors and lights to give it true off-road capabilities.

Moving to the front end, I finalized the forward chassis design and locked in the support blocks that stabilize the primary body. I also planned out a small, magnetic-latch hatch on the top deck for quick access to the internal sensor array.

If there are any pauses in the screen recording where nothing is moving, that’s just me stepping away with a measuring tape to double-check dimensions against my physical hardware. Fortunately, I already own the most expensive pieces for the build including the Raspberry Pi, LiDAR unit, and camera module. To get this fully operational, I realistically just need to source the drive motors, motor drivers, an Arduino, the wheels, and the steering servos.

The project is finally starting to look like an actual rover. I mirrored the suspension geometry over to the other side and designed the central differential that links both sides together, optimizing the entire setup for 3D printing. After tweaking a few bearing sizes here and there for a better fit, I ran some motion simulations in Blender to test how the suspension responds.

The physical simulation tests went really well. However, I ended up hitting a wall trying to configure the Inverse and Forward Kinematics (IK/FK) rigging in Blender, so I’ve sidelined that part for now to keep moving forward.

I spent most of my time designing the front wheel assembly and the section of the chassis that handles steering. To give the rover directional control, I placed a servo motor right above the front motor. Designing and iterating on this steering mechanism took up a significant chunk of time.

First, I modeled the main motor assembly that integrates into the front end. From there, I focused on refining the pendulum suspension system, tweaking several parts that weren’t fitting or looking exactly how I wanted. I also created the small connector joint that links the pendulum to the main control arm, which will eventually balance both sides of the suspension. I haven’t mirrored the geometry to the opposite side yet, but that’s the immediate next step.

Once the CAD is finalized, the next phase is importing the model into Blender to rig it and simulate the exact mechanical movement using Forward and Inverse Kinematics (FK/IK).

Okay so this one was good.

I basically added the housing for the motors themselves also added the cage that the front servos will sit on to control the front wheels.

Also the rear bogie angles were off, so I reset those to something that will be able to climb more terrains a lot more easily.