# URcap Capabilities Question for Solder Robot

Hi all, our company is internally developing a automated solder robot for electronics assembly that we’ve implemented on our UR5.

As we’re going to be using this process often in our company I wanted to explore creating a URcap that would automate programming the actions involved with soldering a single through hole join on a circuit board.

I think I have a pretty good idea of what I’d like the URcap to do conceptually in terms of pseudocode, but as I am a beginner in the development of URcaps, I’m beginning to wonder if what I’m imagining is going to be possible.

In short, what I would like to present to the end-user is the ability to insert a single program node that the user can interact with and pass properties to (based on the physical characteristics of the solder joint):

• A single Waypoint, (joint location)
• Solder amount (joint size)
• Dwell Time (joint size)
• Clearance Height (local component heights)

Past that, the URcap and URscripts would handle the robot approaching the joint with the soldering iron, extruding, dwelling, and clearing the solder tip to the height specified before moving on the the next program node/solder joint.

I’ve done all of this in practice by hard coding it with program nodes. but it is very tedious to do, and some circuit boards can have 10-20 solder joints!

I’ve attached a pseudocode overview in the form that I know best (Python function with arguments)

``````SolderJoint(JointLocationPose, ExtrudeAmount, DwellTime, ClearanceHeight):
Approach_Pose = JointLocationPose - (0, 0, 5mm, 0, 0, 0) //Z-axis being parallel to the axis of the soldering Iron
Clearance_Pose = Approach_Pose + (0, 0, ClearanceHeight, 0, 0 ,0) //Z-axis being parallel with the Base Z-axis

moveL(Clearance_Pose) //move high above the solder joint
moveL(Approach_Pose) //move down to just 5mm away from the solder join
moveL(JointLocationPose) //move in the direction of the axis of the soldering iron to the joint

wait(DwellTime)
For(ExtrudeAmount):
ExtrudeSolder() //this is a pseudo Stand-in for a function that pulses the extrusion stepper motor
wait(DwellTime)

movel(Approach_Pose) //back up 5mm
moveL(Clearance_Pose) //move up to high above the circuit board again

``````

I don’t mean to ask for anyone to develop this for me, but rather if anyone has any insight on whether or not these ideas are even feasible in the framework of URcaps/URscript, or if I might be wasting my time attempting to learn it and should go a different route.

-Matt

Matt,

This is entirely feasible, and sounds like a perfect application for a CAP! Their main benefit is removing complexity/tediousness from the operator/robot programmer at the cost of some up-front software development. We produce a welding CAP (which is the same thing in principle) and we do pretty much exactly what you’re describing.

There’s a pretty big learning curve to developing a CAP, but in my opinion it’s fun and worth it. I’m going to mention this now, just so you’ve heard it, and might remember it if/when you get to that point:

When saving a robot position using the getRobotMovementCallback(), be sure to store both the Pose variable AND the JointPositions variable, as this is not something you can retroactively obtain if you were to save a program and then update the CAP to include it.

That probably doesn’t make sense right now, but it will when you start storing positions.

Also, just food for thought, it may be possible to somehow export the circuit board itself as some kind of G-Code to generate the robot path, and then write a post-processor to insert the commands for actually soldering , etc. You could possibly go straight from the PCB file to a robot program. The CAP is a happy medium between tedious manual programming, and generated path data.

Eric,

Thank you for the reply, I appreciate the feedback and heads up on position storing! I’ll keep at it then and continue along the Cap development path!