Probleme Vision Sensor VS130-2

magic1979thomas

Level-1
Beiträge
2
Reaktionspunkte
0
Zuviel Werbung?
-> Hier kostenlos registrieren
Hallo Freunde.

Ich habe Probleme beim Ausgeben eines DATAMATRIX-Codes mit dem Vison Sensor VS130-2 von Siemens.

Der Code wird gelesen und auch erkannt. Die Steuerung gibt ihn nur nicht in den Datenbaustein aus.:confused:

Ich verwende das mitgeliferte Beispiel-Programm.

Muss ich der Vision-Steuerung eine bestimmt Job-Nummer schicken. Ich finde nichts konkretes in der Bedienungsanleitung.

Für Eure Hilfe bin ich im Vorfeld schon dankbar..

Gruß Thomas
 
Hallo,
ich hatte mit dem Ding auch schon mal so meine Probleme.
Nachdem ich mich eine Weile mit dem beiliegenden FB herumgeärgert hatte habe ich mir dann einen eigenen erstellt (der auch funktioniert).
Wenn du also mit SCL etwas anfangen kannst so kann ich dir den Code gerne zur Verfügung stellen.

Gruß
Larry
 
OK ... hier kommt der Code :
Code:
FUNCTION_BLOCK FB306 
TITLE   = 'UP Kommunikation mit Siemens-Kamera VS130-2' 
AUTHOR  : 'Larry'
VERSION : '1.1'   //   05.02.2009
 
VAR_INPUT
  PxB_Statusbyte        : INT ;    // Status der Kommunikation mit der Kamera
  PxB_Handshake         : INT ;    // Adresse für den Daten-Handshake mit der Kamera
 
  Kamera_Enable         : BOOL ;   // Bedienhoheit für Kamera an SPS
  Kamera_Reset          : BOOL ;   // Reset Kamera
  Kamera_Trigger        : BOOL ;   // neues Bild aufnehmen und Daten übertragen
 
  VG_lfd_Nummer         : DINT ;   // Vergleichs-Vorgabe : lfd. Nummer von Teil 
  VG_Qualitaet          : INT ;    // Vergleichs-Vorgabe : Code-Qualität [%]
END_VAR
 
VAR_IN_OUT
END_VAR
 
VAR_OUTPUT
   Kamera_bereit            : BOOL ;      // Kamera betriebsbereit
   Kamera_Busy              : BOOL ;      // Kamera betriebsbereit
   Kamera_fertig            : BOOL ;      // Kamera betriebsbereit
 
   Kamera_Daten_ausgewertet : BOOL ;      // neue Kamera-Daten ausgewertet
   Kamera_Teil_erkannt      : BOOL ;      // DM-Code von Kamera erkannt
   Kamera_Code_Match        : BOOL ;      // DM-Code stimmt mit Vorgabe überein
   Kamera_Qualitaet_OK      : BOOL ;      // Qualität entsprciht der Vorgabe
 
   Kamera_lfd_Nummer        : DINT ;      // erkannte lfd. Nummer von Teil
   Kamera_Datum             : STRING[8] ; // erkanntes Datum von Teil
   Kamera_Date              : DATE ;      // erkanntes Datum von Teil
   Kamera_Qualitaet         : INT ;       // erkannte Code-Qualität [%]
END_VAR
 
VAR
   DM_Code              : STRING[40] ;
      a_DM_Code AT DM_Code : STRUCT 
               Total  : BYTE ;
               Length : BYTE ;
               Chars  : ARRAY [1..40] OF BYTE ;
      END_STRUCT ;
   Qualitaet            : ARRAY[0..4] OF INT ;
 
   Laenge_Datensatz     : INT ;
   Laenge_Empfangsdaten : INT ;
 
   TimeOut_Zeit         : SFB4 ;
 
   Ablauf               : ARRAY [0..15] OF BOOL ;  // Schrittkette Ablauf
     wAblauf AT Ablauf  : WORD ;
   Datensatz_Index      : INT ;
   Daten_Puffer_Pointer : INT ;
   Daten_Puffer         : ARRAY [1..256] OF BYTE ;
END_VAR     
 
VAR_TEMP
   Kamera_IN : STRUCT
        DISABLE   :  BOOL ;   // manuelle Steuerung der Kamera sperren
        SEL0      :  BOOL ;   // Code-Auswahl-Bit 0
        SEL1      :  BOOL ;   // Code-Auswahl-Bit 1 (IF TRAIN=0) / train Code (IF TRAIN=1)
        SEL2      :  BOOL ;   // Code-Auswahl-Bit 2
        SEL3      :  BOOL ;   // Code-Auswahl-Bit 3
        TRAIN     :  BOOL ;   // neue Code einlernen
        TRIGGER   :  BOOL ;   // neue Auswertung starten / Bild einlesen
        RESET     :  BOOL ;   // Fehler löschen
   END_STRUCT ;
   b_Kamera_IN AT Kamera_IN : BYTE ;     
 
   Kamera_OUT : STRUCT
        IN_OP    :  BOOL ;   // bereit // keine Fehler
        TRAINED  :  BOOL ;   // angewählter Code wurde eingelernt
        READY    :  BOOL ;   // Kamera ist im RUN-Mode
        READ     :  BOOL ;   // Ergebnis des Einlesens: Code gefunden und übersetzt
        MATCH    :  BOOL ;   // Ergebnis des Einlesens: Code stimmt mit eingelernten Code überein
        N_OK     :  BOOL ;   // Ergebnis des Einlesens: Code nicht erkannt
        Res_1    :  BOOL ;   // reserviert
        Res_2    :  BOOL ;   // reserviert
   END_STRUCT ;
   b_Kamera_OUT AT Kamera_OUT : BYTE ;   
 
   i , j : INT ;  
 
   d_Lfd_Nummer : DINT ; 
   s_Lfd_Nummer : STRING [8] ;
 
   s_Datum1     : STRING [8] ;
      a_Datum1 AT s_Datum1 : STRUCT 
               Total  : BYTE ;
               Length : BYTE ;
               Chars  : ARRAY [1..8] OF BYTE ;
      END_STRUCT ;
 
   s_Datum2     : STRING [8] ;
      a_Datum2 AT s_Datum2 : STRUCT 
               Total  : BYTE ;
               Length : BYTE ;
               Chars  : ARRAY [1..8] OF BYTE ;
      END_STRUCT ;
 
   Datum_TT , Datum_MM , Datum_JJ , Datum_SJ : INT ;
   Datum_DINT                                : DINT ;
 
   Kommando : WORD ;
 
   Code_zulaessig : BOOL ;
END_VAR
... Fortsetzung ...
 
Code:
//    Programm-Ablauf  
 
BEGIN 
b_Kamera_IN  := 0 ; 
b_Kamera_OUT := PEB[PxB_Statusbyte] ; 
IF Kamera_Enable AND NOT Ablauf[0] THEN  
   wAblauf := 0 ;
   Ablauf[1] := true ;
END_IF ;
Ablauf[0] := Kamera_Enable ;
Kamera_IN.DISABLE := Kamera_Enable ;
Kamera_IN.RESET   := Kamera_Reset ;
Kamera_IN.TRIGGER := Kamera_Busy AND NOT Kamera_Daten_ausgewertet ;
IF NOT Kamera_Enable THEN PAB[PxB_Handshake+4] := 0 ; ELSE PAB[PxB_Handshake+4] := b#16#81 ; END_IF ;
PAB[PxB_Statusbyte] := b_Kamera_IN ; 
 
Kamera_bereit := Kamera_OUT.IN_OP AND Kamera_OUT.READY AND Ablauf[0] ;
TimeOut_Zeit (IN := false // Kamera_Busy
             ,PT := t#3s
             ) ; 
 
//    Schrittkette  
 
IF Ablauf[1] AND Kamera_Trigger THEN 
   Kamera_Busy := true ; 
   Datensatz_Index      := 0 ;
   Daten_Puffer_Pointer := 0 ;
   Laenge_Datensatz     := 0 ;
   Laenge_Empfangsdaten := 0 ;
 
   Kamera_lfd_Nummer := 0 ;
   Kamera_Datum      := '' ;
   Kamera_Qualitaet  := 0 ;
 
   Ablauf[1] := false ;
   Ablauf[2] := true ;
ELSIF Ablauf[2] THEN  
   IF (PEB[PxB_Handshake+1] <> 0) THEN
      Ablauf[2] := false ;
      Ablauf[3] := true ;
   ELSIF (PEB[PxB_Handshake+1] = b#16#FF) OR TimeOut_Zeit.Q THEN
      Ablauf[2] := false ;
      Ablauf[5] := true ;
   END_IF ;       
ELSIF Ablauf[3] THEN  
   IF (BYTE_TO_INT(PEB[PxB_Handshake+1]) > Datensatz_Index) THEN
      Ablauf[3] := false ;
      Ablauf[4] := true ;
   ELSIF (PEB[PxB_Handshake+1] = 0) THEN
      Ablauf[6] := true ;
      Ablauf[3] := false ;
   ELSIF (PEB[PxB_Handshake+1] = b#16#FF) OR TimeOut_Zeit.Q THEN
      Ablauf[3] := false ;
      Ablauf[5] := true ;
   END_IF ;       
ELSIF Ablauf[4] THEN  
   IF (Datensatz_Index = 0) THEN 
      Laenge_Empfangsdaten := WORD_TO_INT(PEW[PxB_Handshake+2]) ;
      IF Laenge_Empfangsdaten > 27 THEN Laenge_Datensatz := 27 ;
                                   ELSE Laenge_Datensatz := Laenge_Empfangsdaten ; END_IF ;
   ELSE 
      Laenge_Datensatz := BYTE_TO_INT(PEB[PxB_Handshake+2]) ;
   END_IF ;
 
   FOR i := 1 TO 27 BY 1 DO 
      Daten_Puffer[Daten_Puffer_Pointer+i] := PEB[PxB_Handshake+4+i] ;
   END_FOR ;   
 
   Daten_Puffer_Pointer := Daten_Puffer_Pointer + 27 ;
   Datensatz_Index := Datensatz_Index + 1 ;
   PAB[PxB_Handshake+1] := INT_TO_BYTE(Datensatz_Index) ;
   Ablauf[4] := false ;
   Ablauf[3] := true ;
ELSIF Ablauf[5] THEN  
   PAB[PxB_Handshake+1] := 0 ;
   Kamera_Busy   := false ; 
   Kamera_fertig := true ; 
 
   IF NOT Kamera_Trigger THEN 
      Ablauf[5] := false ;
      Ablauf[8] := true ;
   END_IF ;   
ELSIF Ablauf[6] THEN  
   PAB[PxB_Handshake+1] := 0 ;
   Kamera_Busy   := false ; 
   Kamera_fertig := true ; 
   Code_zulaessig := (Daten_Puffer[04] = b#16#1e) AND (Daten_Puffer[11] = b#16#1d) 
                 AND (Daten_Puffer[17] = b#16#1d) AND (Daten_Puffer[24] = b#16#1d) 
                 AND (Laenge_Empfangsdaten > 40) ;
   IF Code_zulaessig THEN Kamera_Teil_erkannt := true ; END_IF ;
   Ablauf[6] := false ;
   Ablauf[7] := true ;
ELSIF Ablauf[7] THEN  
   IF Kamera_Teil_erkannt AND NOT Kamera_Daten_ausgewertet THEN    // 
      a_DM_Code.Total  := 40 ; 
      a_DM_Code.Length := 40 ; 
      FOR i:= 1 TO 40 BY 1 DO 
         a_DM_Code.Chars[i] := Daten_Puffer[i] ;
      END_FOR ;  
 
      s_Datum1 := '' ; 
      s_Datum2 := '' ;
      s_Datum1 := MID(IN:= DM_Code , L:=6 , P:=5) ;
      a_Datum2.Total  := 8 ; 
      a_Datum2.Length := 8 ; 
      a_Datum2.Chars[1] := a_Datum1.Chars[1] ;
      a_Datum2.Chars[2] := a_Datum1.Chars[2] ;
      a_Datum2.Chars[3] := CHAR_TO_BYTE('.') ;
      a_Datum2.Chars[4] := a_Datum1.Chars[3] ;
      a_Datum2.Chars[5] := a_Datum1.Chars[4] ;
      a_Datum2.Chars[6] := CHAR_TO_BYTE('.') ;
      a_Datum2.Chars[7] := a_Datum1.Chars[5] ;
      a_Datum2.Chars[8] := a_Datum1.Chars[6] ; 
 
      Kamera_Datum := s_Datum2 ;
 
      Datum_TT := (BYTE_TO_INT(a_Datum1.Chars[1]) -48) * 10 + BYTE_TO_INT(a_Datum1.Chars[2]) -48 ;
      Datum_MM := (BYTE_TO_INT(a_Datum1.Chars[3]) -48) * 10 + BYTE_TO_INT(a_Datum1.Chars[4]) -48 ;
      Datum_JJ := (BYTE_TO_INT(a_Datum1.Chars[5]) -48) * 10 + BYTE_TO_INT(a_Datum1.Chars[6]) -48 ;
 
      IF (Datum_JJ < 90) THEN Datum_JJ := Datum_JJ + 2000 ; ELSE Datum_JJ := Datum_JJ + 1990 ; END_IF ;
      IF ((Datum_JJ MOD 4) = 0) THEN Datum_SJ := 1 ; ELSE Datum_SJ := 0 ; END_IF ;
      IF Datum_MM >  1 THEN Datum_TT := Datum_TT + 31 ; END_IF ;
      IF Datum_MM >  2 THEN Datum_TT := Datum_TT + 28 + Datum_SJ ; END_IF ;
      IF Datum_MM >  3 THEN Datum_TT := Datum_TT + 31 ; END_IF ;
      IF Datum_MM >  4 THEN Datum_TT := Datum_TT + 30 ; END_IF ;
      IF Datum_MM >  5 THEN Datum_TT := Datum_TT + 31 ; END_IF ;
      IF Datum_MM >  6 THEN Datum_TT := Datum_TT + 30 ; END_IF ;
      IF Datum_MM >  7 THEN Datum_TT := Datum_TT + 31 ; END_IF ;
      IF Datum_MM >  8 THEN Datum_TT := Datum_TT + 31 ; END_IF ;
      IF Datum_MM >  9 THEN Datum_TT := Datum_TT + 30 ; END_IF ;
      IF Datum_MM > 10 THEN Datum_TT := Datum_TT + 31 ; END_IF ;
      IF Datum_MM > 11 THEN Datum_TT := Datum_TT + 30 ; END_IF ;
      //            Jahres-Tage                              Schaltjahr-Tage                        akt. Tag vom lfd. Jahr
      Datum_DINT := ((INT_TO_DINT(Datum_JJ) - 1990) * 365) + ((INT_TO_DINT(Datum_JJ) - 1992) / 4) + INT_TO_DINT(Datum_TT) ;
      Kamera_DATE := DINT_TO_DATE(Datum_DINT) ;
 
      s_Lfd_Nummer := '' ;
      s_Lfd_Nummer := MID(IN:= DM_Code , L:=6 , P:=18) ;
      d_Lfd_Nummer := STRING_TO_DINT(s_Lfd_Nummer) ;
 
      Kamera_lfd_Nummer := d_Lfd_Nummer ;     
      Kamera_Code_Match := (d_Lfd_Nummer = VG_lfd_Nummer) ;
 
      Qualitaet[0] := 0 ;
      FOR i:= 1 TO 4 BY 1 DO 
         Qualitaet[i] := REAL_TO_INT((INT_TO_REAL(71 - BYTE_TO_INT(Daten_Puffer[i+41])) * 100.0 / 6.0) + 0.5) ;
         Qualitaet[0] := Qualitaet[0] + Qualitaet[i] ;
      END_FOR ;  
      Qualitaet[0] := Qualitaet[0] / 4 ;
 
      Kamera_Qualitaet := Qualitaet[0] ; 
      Kamera_Qualitaet_OK := (Kamera_Qualitaet >= VG_Qualitaet) ; 
   END_IF ;  
   Kamera_Daten_ausgewertet := true ; 
   IF NOT Kamera_Trigger THEN 
      Ablauf[7] := false ;
      Ablauf[8] := true ;
   END_IF ;   
ELSIF Ablauf[8] OR Kamera_Reset OR NOT Kamera_Enable THEN  
   Kamera_Busy   := false ; 
   Kamera_fertig := false ; 
   Kamera_Teil_erkannt := false ; 
   Kamera_Daten_ausgewertet := false ; 
   Kamera_Code_Match   := false ;
   Kamera_Qualitaet_OK := false ; 
 
   Ablauf[8] := false ;
   Ablauf[1] := true ;
END_IF ;
 
END_FUNCTION_BLOCK

... du wirst feststellen, dass der FB auch Überprüfungen des Inhalts vornimmt. Ich nehme aber mal an, dass du die nicht benötigten Sequenzen selbst ausbauen kannst ... ;)

Gruß
Larry
 
Zurück
Oben