Zuviel Werbung? - > Hier kostenlos beim SPS-Forum registrieren

Seite 2 von 2 ErsteErste 12
Ergebnis 11 bis 14 von 14

Thema: Fehlernummer aus mehreren Bytes erstellen

  1. #11
    Registriert seit
    08.02.2007
    Ort
    A-2320
    Beiträge
    2.252
    Danke
    244
    Erhielt 332 Danke für 303 Beiträge

    Standard


    Zuviel Werbung?
    -> Hier kostenlos registrieren
    Ja weil Du vor DTR
    L 0
    schreibst
    Dann steht genau das drinnen was Du nicht möchtest nämlich "0".
    Drehs um:
    L 0
    L LD0
    ==I
    SPB FLTE
    DTR

    abgesehen davon:
    ==D
    muss es heissen!!

  2. #12
    Registriert seit
    08.02.2007
    Ort
    A-2320
    Beiträge
    2.252
    Danke
    244
    Erhielt 332 Danke für 303 Beiträge

    Standard

    Zitat Zitat von Freki Beitrag anzeigen
    Ok, das funktioniert soweit, aber bei 2 Fehlern hat er dann ndoch seine Probleme.
    Werde es nach der anderen vorgeschlagenen Lösungen probieren. Trotzdem schon mal danke für die Hilfe, auf sowas wäre (und werde) ich nie (ge)kommen.
    OK meine Antwort #11 bezog sich auf Dein Originalposting.

    Gut, wenn nun mehrere Bits "1" sein können, was soll denn dann ausgegeben werden?
    Das ist ja eine andere Aufgabe.

    Anleitung: Schleife von 1 bis 32 wo Du vor Beginn der Schleife eine 1 (DINT) in eine Variable lädst und das Fehlerdoppelwort mit UD #Variable ausmaskierst.
    In der Schleife dann SLD 1 #Variable das MaskierBit weiterschieben.
    Du müsstest am Baustein aber dann dementsprechend 32 Ausgangsbytes haben für jeden Fehlerkanal eines.

  3. #13
    Registriert seit
    08.02.2007
    Ort
    A-2320
    Beiträge
    2.252
    Danke
    244
    Erhielt 332 Danke für 303 Beiträge

    Standard

    Aus Spass an der Freud mal ein Baustein:

    Code:
    FUNCTION_BLOCK FB 2
    TITLE =
    VERSION : 0.1
    
    VAR_INPUT
      Fehlerbyte1 : BYTE ; 
      Fehlerbyte2 : BYTE ; 
      Fehlerbyte3 : BYTE ; 
      Fehlerbyte4 : BYTE ; 
      Zeit : TIMER ; 
    END_VAR
    VAR_OUTPUT
      Err_1 : INT ; 
      Err_2 : INT ; 
      Err_3 : INT ; 
      Err_4 : INT ; 
      Err_5 : INT ; 
      Err_6 : INT ; 
      Err_7 : INT ; 
      Err_8 : INT ; 
      Err_9 : INT ; 
      Err_10 : INT ; 
      Err_11 : INT ; 
      Err_12 : INT ; 
      Err_13 : INT ; 
      Err_14 : INT ; 
      Err_15 : INT ; 
      Err_16 : INT ; 
      Err_17 : INT ; 
      Err_18 : INT ; 
      Err_19 : INT ; 
      Err_20 : INT ; 
      Err_21 : INT ; 
      Err_22 : INT ; 
      Err_23 : INT ; 
      Err_24 : INT ; 
      Err_25 : INT ; 
      Err_26 : INT ; 
      Err_27 : INT ; 
      Err_28 : INT ; 
      Err_29 : INT ; 
      Err_30 : INT ; 
      Err_31 : INT ; 
      Err_32 : INT ; 
      Err_Akt : INT ; 
    END_VAR
    VAR
      Schleife : INT ; 
      FehlerDW : DINT ; 
      Fla1 : BOOL ; 
      NeueAnzeige : BOOL ; 
      Fehleranzahl : INT ; 
      AktAnzeige : INT ; 
    END_VAR
    VAR_TEMP
      Maskier : DWORD ; 
      ERG : DWORD ; 
      Null : BOOL ; 
    END_VAR
    BEGIN
    NETWORK
    TITLE =Maskierbit
          L     1; 
          T     #Maskier; 
    
    NETWORK
    TITLE =Fehleranzahl reseten
    //
    //
          L     0; 
          T     #Fehleranzahl; 
    NETWORK
    TITLE =FehlerDoppelwort einlesen
          L     P##Fehlerbyte1; 
          LAR1  ; 
          L     B [AR1,P#3.0]; 
          SLD   24; 
          L     B [AR1,P#2.0]; 
          SLD   16; 
          OD    ; 
          L     B [AR1,P#1.0]; 
          SLD   8; 
          OD    ; 
          L     B [AR1,P#0.0]; 
          OD    ; 
          T     #FehlerDW; 
    NETWORK
    TITLE =Ausgänge ablöschen
          L     P##Err_1; 
          LAR1  ; 
          L     1; 
          T     #Schleife; 
    ABL:  L     0; 
          T     W [AR1,P#0.0]; 
          +AR1  P#2.0; 
          L     #Schleife; 
          INC   1; 
          T     #Schleife; 
          L     33; 
          <>I   ; 
          SPB   ABL; 
     
    NETWORK
    TITLE =Fehlercode generieren
          L     P##Err_1; 
          LAR1  ; 
          L     1; 
          T     #Schleife; 
    NEXT: L     #FehlerDW; 
          L     #Maskier; 
          UD    ; 
          T     #ERG; 
          L     0; 
          ==D   ; 
          =     #Null; 
          L     0; 
          U     #Null; 
          SPB   M1; 
          L     #Schleife; 
    M1:   T     W [AR1,P#0.0]; 
          U     #Null; 
          SPB   M2; 
          +AR1  P#2.0; 
          L     #Fehleranzahl; 
          INC   1; 
          T     #Fehleranzahl; 
    M2:   L     #Maskier; 
          SLD   1; 
          T     #Maskier; 
          L     #Schleife; 
          INC   1; 
          T     #Schleife; 
          L     33; 
          <>I   ; 
          SPB   NEXT; 
     
    NETWORK
    TITLE =Fehlerwert Anzeige umschalten
          L     P##Err_1; 
          LAR1  ; 
          U     #Zeit; 
          FP    #Fla1; 
          =     #NeueAnzeige; 
          L     S5T#3S; 
          UN    #Zeit; 
          SE    #Zeit; 
          UN    #NeueAnzeige; 
          SPB   M3; 
          L     #AktAnzeige; 
          INC   1; 
          T     #AktAnzeige; 
          L     #Fehleranzahl; 
          <I    ; 
          SPB   M3; 
          L     0; 
          T     #AktAnzeige; 
    M3:   L     #AktAnzeige; 
          SLD   4; 
          +AR1  ; 
          L     W [AR1,P#0.0]; 
          T     #Err_Akt; 
     
    END_FUNCTION_BLOCK
    Der gibt in Abhängigkeit der Eingangsbytes 1 bis 4 an den Ausgängen Err_1 bis Err_32 die Fehlercodes der Reihenfolge nach aus.
    Zusätzlich gibt es einen Ausgang Err_Akt der alle anstehenden Alarme alle 3 Sekunden umschaltet.

    Wenn man mehr als 32 Alarme hat könnte man den Baustein noch um einen Offseteingang erweitern.....
    Viel Spass.

  4. #14
    Freki ist offline Neuer Benutzer
    Themenstarter
    Registriert seit
    28.01.2013
    Beiträge
    29
    Danke
    1
    Erhielt 0 Danke für 0 Beiträge

    Beitrag


    Zuviel Werbung?
    -> Hier kostenlos registrieren
    Danke schon mal für den Baustein!!! Ist gut gemacht. Will den nur noch anpassen dass der baustein die Fehler auf einen Trigger Impuls nacheinander ausgibt, so dass man zB das ankündigen einer neuen Fehlerschleife über 5 Blinkimpule zb anzeigen kann. Also 5 Impulse, dann der Fehlerdurchlauf 1x, dann wieder 5 Impulse, Fehler wieder 1x, usw. Wobei der Impuls zum triggern, sowie die anzeige der zahl 88 (= alle 7 Segmente) extern gebildet wird.

    Code:
          L     P##Err_1
          LAR1  
          U     #Anzeigen
          FP    #Fla1
          S     #NeueAnzeige
    
          UN    #NeueAnzeige
          BEB   
    
          L     #Zaehler
          INC   1
          T     #Zaehler
          L     100
          L     #Zaehler
          >I    
          SPB   M3                          //M4
          L     0
          T     #Zaehler
          L     #AktAnzeige
          INC   1
          T     #AktAnzeige
          L     #Fehleranzahl
          <I    
          SPB   M3
          L     #AktAnzeige
          L     #Fehleranzahl
          ==I   
          R     #NeueAnzeige
          L     0
          T     #AktAnzeige
    M3:   L     #AktAnzeige
          SLD   4
          +AR1  
          L     W [AR1,P#0.0]
          T     #Err_Akt
    So habe ich das umgesetzt. Geht bestimmt auch schöner, aber hat so schon ne Weile gedauert.................
    Geändert von Freki (29.01.2013 um 16:13 Uhr)

Ähnliche Themen

  1. Bytes aus DB Laden und vergleichen
    Von bluebird277 im Forum Simatic
    Antworten: 1
    Letzter Beitrag: 30.09.2010, 15:10
  2. Doppelwort aus 4 Bytes erzeugen
    Von selly im Forum Simatic
    Antworten: 2
    Letzter Beitrag: 22.07.2010, 16:49
  3. Struct aus Bytes auf Ausgänge abbilden
    Von Kaffeesüchtig im Forum Simatic
    Antworten: 4
    Letzter Beitrag: 13.01.2010, 16:25
  4. nacheinander bytes aus db in ein merker kopieren
    Von Robert_k im Forum Simatic
    Antworten: 32
    Letzter Beitrag: 09.05.2008, 21:18
  5. Not-Aus über mehreren Schaltschränke verteilt
    Von HDD im Forum Schaltschrankbau
    Antworten: 3
    Letzter Beitrag: 13.06.2007, 13:34

Lesezeichen

Berechtigungen

  • Neue Themen erstellen: Nein
  • Themen beantworten: Nein
  • Anhänge hochladen: Nein
  • Beiträge bearbeiten: Nein
  •