the claw crane is still one of the clearest older projects i have because it is pure build-and-debug work. motors, wiring, control logic, measurements, and a lot of small fixes until the thing finally behaves.
it also says something about the kind of work i still enjoy now. not just planning a system on paper, but getting into the ugly middle where mechanics, electronics, and code all start affecting each other and every small mistake suddenly becomes visible.
what was in it
- schematics and test circuits
- component sizing and wiring
- stepper motors and control logic
- arduino work in c++
- lcd handling and signal processing
- troubleshooting and measurements
the project was part of an idpa context, but the useful part was not the school frame around it. it was building something physical that had to take inputs, move in multiple directions, grip reliably enough, and still make sense once the whole thing was assembled.
the machine itself is probably the clearest part of it. it was not just some code on a screen. it had to move, grip, react to inputs, and keep working once everything was mounted together.
the electronics side was the usual mix of controller board, drivers, wiring, and small mistakes that only show up once the real hardware is connected.
what made it hard
- motors and mechanics never fail in clean isolated ways
- wiring mistakes often looked like software mistakes first
- small tolerances started to matter once parts were mounted together
- each fix had to be tested in the real machine, not just assumed
that was probably the most useful part of it. the project kept forcing me back into the full chain: power, signal, control logic, physical movement, user input, and actual behavior.
the schematic still matters because it shows that i was already thinking in terms of the whole system: inputs, outputs, power, control flow, and how each part depends on the others.
why it still matters
it is old, but it still says something accurate about how i work. i like understanding systems, tracing failures back to the source, and pushing a project past the point where it only exists as an idea. even now, a lot of the software and infrastructure work i care about has the same shape: too many moving parts, unclear failures, and the need to understand how the whole thing behaves instead of only one layer of it.