Skip to content

Mit KI weiterarbeiten

Mit KI weiterarbeiten

Keyence RB-500 ​

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).

Abbildung: 1 Einrichtung

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.

Abbildung: 1.1. Verbindung herstellen

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.

Abbildung: 1.2. Kalibrieren

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.

Abbildung: 1.2. Kalibrieren

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.

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.

Abbildung: 2.1. SearchAbbildung: 2.1. Search

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.

Abbildung: 2.1. Search

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.

Abbildung: 2.2. Pick

Abschließend werden die Grippositionen eingelernt. Dafür wird im Werkstück ein Koordinatensysteme eingefügt, die mit dem Greifer-TCP angefahren werden soll.

Abbildung: 2.2. Pick

Abbildung: 2.2. Pick

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 ​

Erklärung Inbetriebnahme

TPR-Befehle

horstFX Beispielprogramm Keyence