Die RB-500 ist ein 3d Sensor von Keyence f�r Bin-Picking Applikationen. Der Funktionsumfang dieses Kamerasystems ist sehr gro�, weshalb in diesem Beispiel werden nur die rudiment�ren Funktionen beschrieben werden.
1. Einrichtung
Der Sensor kommt mit eigenem Controller (CV-X Series), auf der die Vision Software 3D Vision-Guided Robotcs l�uft. Die Software wird �ber Maus und Bildschirm bedient, die direkt am Contoller eingesteckt werden. Innerhalb der Software wird die Verbindung zum Roboter konfiguriert, die Kalibrierung durchgef�hrt sowie die jeweilige Applikation (KLT, Werkst�ck, Greifer) eingelernt. Optional kann der Contoller auch die komplette Pfadplanung �bernehmen, sofern das jeweilige Roboter System integriert und kinematisiert ist (HORST ist aktuell noch nicht verf�gbar).
1.1. Verbindung herstellen
Eine genaue Beschreibung zum Einrichten des Kamerasystems ist im Anhang (Erkl�rung Inbetriebnahme.pdf) zu finden. Zu Kommunikation via TCP/IP, m�ssen sich HORST und der CV-X Controller im selben Netzwerk befinden. Die IP-Adresse des Controllers kann entweder manuell vergeben, oder via DHCP automatisch bezogen werden. Als Port muss 8500 eingestellt werden, das Trennzeichen (Delimiter) am Ende jedes Strings wird auf CR (Carriage Return) gesetzt.
1.2. Kalibrieren
Im ersten Schritt wird die Grundkalibrierung der Kamera durchgef�hrt. Daf�r wird die mitgelieferte Kalibrierplatte auf die Arbeitsfl�che unter der Kamera gelegt und �ber die Software automatisch erkannt.
Die Hand-Auge-Kalibrierung erfolgt �ber ein Kalibrier-Jigg, das exzentrisch am Roboterflansch befestigt wird.
Mit diesem Jigg wird eine 3x3x3 Kalibrier-Martrix abgefahren, deren Abmessungen frei einstellbar sind. Die Matrix sollte so gew�hlt werden, dass sie ungef�hr dem Arbeitsraum der Applikation entspricht.
Die Matrix wird Punkt f�r Punkt manuell abgefahren, wobei die jeweiligen Jigg-Positionen von der Kamera erkannt und die zugeh�rigen Flansch-Koordinaten des Roboters in der Kamerasoftware eingegeben werden. Abschlie�end wird der Flanschmittelpunkt in Bezug zum Kalibrier-Jigg berechnet. Daf�r wird der Flansch um definierte (einstellbare) Winkel gekippt und von der Kamera erkannt. Durch Abgleich der �bergebenen und erkannten Winkel berechnet die Software die genaue Lage und Orientierung des Flanschmittelpunktes.
2. Anwendung einlernen
Im n�chsten Schritt wird die Applikation definiert. Daf�r m�ssen Werkst�cke, KLT und Greifer entweder optisch oder durch �bergabe von STL-Daten eingelernt werden.
2.1. Search
Die zu erkennenden Werkst�cke k�nnen entweder als STL-File oder optisch eingelernt werden. F�r das optische Einlernen werden die Werkst�cke in verschiedenen Positionen unter die Kamera gelegt und automatisch erkannt.
Anschlie�end wird das KLT eingelernt. Auch dieses wird einfach unter den Sensor gelegt und automatisch erkannt. Die Kistenr�nder k�nnen dann durch setzten von jeweils zwei Punkten manuell angepasst werden.
2.2. Pick
Nachdem Werkst�ck und KLT eingelernt wurden, wird der Greifer �ber eine STL-File in die Software integriert. Hier kann sowohl die Position es Greifers am Roboterflansch (Offset) als auch der TCP eingestellt werden.
Abschlie�end werden die Grippositionen eingelernt. Daf�r wird im Werkst�ck ein Koordinatensysteme eingef�gt, die mit dem Greifer-TCP angefahren werden soll.
3. Kommunikation/Ansteuerung
Die Kommunikation erfolgt �ber Strings, die �ber eine Socketverbindung ausgetauscht werden. Prinzipiell k�nnen diese Strings in der Kamerasoftware frei konfiguriert werden. In diesem Beispiel werden die Vorkonfigurierten TPR-Befehle benutzt.
Zum Triggern der Kamera wird der String "T1;" �ber einen PrintWriter gesendet. Hierbei ist zu beachten, dass am Ende jedes Strings das Trennzeichen (Semikolon) mitgeschickt werden muss.
//neues Bild aufnehmen
schreibeNachricht ("T1;");
function schreibeNachricht(nachricht) {
var printWriter =
new java.io.PrintWriter(
new java.io.OutputStreamWriter(
socket.getOutputStream()));
printWriter.print(nachricht);
printWriter.flush();
}
Anschlie�end wird die Antwort der Kamera aus der Socket �ber einen DataInputStream ausgelesen. Dabei wird die Socket solange ausgelesen, bis das �bergebene Trennzeichen (Carriage Return) erkannt wird (vgl. Sockets).
//Trennzeichen
var delimiter = "\r".charCodeAt(0); //CR Carriage Return, ggf. anpassen
//Socket IP & Port
var socket = new java.net.Socket("192.168.0.11", 8500); //IP-Adresse der Kamera sowie Port ggf. anpassen
//Socket auslesen
leseNachricht(socket, delimiter);
function leseNachricht(socket, msgSeperator)
{
var ByteHelper = Java.type("de.fruitcore.robot.core.util.ByteHelper");
var ByteArray = Java.type("byte[]");
var dIn = new java.io.DataInputStream(socket.getInputStream());
var full_msg = new ByteHelper();
var buffer = new ByteArray(1);
while(1){
dIn.readFully(buffer, 0, buffer.length);
full_msg.putByte(buffer[0]);
if(msgSperator == buffer[0]){
break;
}
}
var nachricht = new java.lang.String(full_msg.toBytes(), java.nio.charset.StandardCharsets.UTF_8);
return nachricht;
}
Nach dem Triggern der Kamera muss die Socket immer einmal zus�tzlich ausgelesen werden, da die Kamera den Triggerbefehl ("T1") immer zur�cksendet.
Als n�chstes schickt die Kamera einen String, der die Anzahl erkannter Objekte enth�lt. Wird kein Objekt erkannt, wird dementsprechend der String "00\r" geschickt. Dieser kann in der Programmsteuerung genutzt werden um ein neues Bild aufzunehmen:
while (true) {
if (leseNachricht(socket, msgSeperator) === "00\r") { //kein Objekt gefunden (ggf Trennzeichen anpassen
triggerCamera("T1;"); //neues Bild aufnehmen
sleep(100);
} else {
//Objekt gefunden, abholen
}
}
Wurde ein Teil erkannt, berechnet der Controller die jeweilige Anfahr- (Approach-) und die Abholposition (Pickposition).
Diese k�nnen �ber die TPR-Befehle wie folgt angefordert/ausgelesen werden:
- Send: "TPR,nnn,a,b,cDelimiter" ? nnn: Tool No., a: Result (0: Approach Position, 1: Grip Position, 2: Place Position), b: Pick No., c: Data Output Format (f�r Horst immer 0), Delimiter: Trennzeichen (Carriage Return \r)
- Receive: "TPR, m,n,h,xxx,yyy,zzz,ppp,qqq,rrrDelimiter" ? m: detected Model No., n: Grip Label No., h: Hand Model No., xxx,yyy,zzz,ppp,qqq,rrr: Objektkoordinaten (kartesische Koordingaten + Eulerwinkel), Delimiter: Trennzeichen (;)
Ausf�hrlichere Dokumentation der TPR-Befehle ist im Anhang (TPR-Befehle.pdf) zu finden.
//Pickposition anfordern
schreibeNachricht("TPR,101,0,0;");
//Pickposition auslesen
cam_resultApp = leseNachricht(socket, msgSeperator);
//Sting aufteilen
splittedApp = cam_resultApp.split(",");
xApp = splittedApp[4] / 1000;
yApp = splittedApp[5] / 1000;
zApp = splittedApp[6] / 1000;
RxApp = splittedApp[7];
RyApp = splittedApp[8];
RzApp = splittedApp[9];
//Approachpos anfordern
schreibeNachricht("TPR,101,1,0;");
//Approachposition auslesen
cam_resultGrip = leseNachricht(socket, msgSeperator);
//String aufteilen
splittedGrip = cam_resultGrip.split(",");
xGrip = splittedApp[4] / 1000;
yGrip = splittedApp[5] / 1000;
zGrip = splittedApp[6] / 1000;
RxGrip = splittedGrip[7];
RyGrip = splittedGrip[8];
RzGrip = splittedGrip[9];
Die �bergebenen Koordinaten k�nnen dann z.B. mittels eines erweiterten move-Befehls (vgl. Textuelles Programmieren) angefahren werden:
// Approachposition
move({
'Coord': 'CARTESIAN_BASIS',
'MoveType': 'JOINT',
'PoseRelation': 'ABSOLUTE',
'anyconfiguration': false,
'blendradius.orient': 180.0,
'blendradius.xyz': 0.03,
'speed.ratio': 1.0,
'targetpose.x': xApp,
'targetpose.y': yApp,
'targetpose.z': zApp,
'targetpose.rx': RxApp,
'targetpose.ry': RyApp,
'targetpose.rz': RzApp,
}, "Approachposition");
// Gripposition
move({
'Coord': 'CARTESIAN_BASIS',
'MoveType': 'LINEAR',
'PoseRelation': 'ABSOLUTE',
'anyconfiguration': false,
'speed.ratio': 0.7,
'targetpose.x': xGrip,
'targetpose.y': yGrip,
'targetpose.z': zGrip,
'targetpose.rx': RxGrip,
'targetpose.ry': RyGrip,
'targetpose.rz': RzGrip,
}, "Gripposition");
Das komplette Beispielprogramm kann ebenfalls im Anhang heruntergeladen werden (Keyence_Horst_Vorlage.js)
4. Anhang
horstFX Beispielprogramm Keyence