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

Seite 1 von 2 12 LetzteLetzte
Ergebnis 1 bis 10 von 17

Thema: Abfrage ob Eingänge 1 oder 0 sind

  1. #1
    Registriert seit
    31.05.2010
    Beiträge
    411
    Danke
    37
    Erhielt 10 Danke für 9 Beiträge

    Standard


    Zuviel Werbung?
    -> Hier kostenlos registrieren
    Hallo Leute,

    Ich will eine Einfache Abfrage machen ob ein Eingang 1 oder 0 ist. Dies soll dann mit mehreren Eingängen gemacht werden. Hierbei steht jeder Eingang für eine Maschine. Ich wollte es erst mit einem Und und Negierungen machen aber das funktioniert leider nicht wirklich. Da ich ja sicherstellen muss das auch erfasst wird wenn Maschine 4 läuft und nicht Maschine 1. Hat da einer ne Idee wie ich das einfach machen kann?
    Es gibt ja dann die unterschiedlichen Zustände z.b Maschine 1 und Maschine 4 oder Maschine 3 Maschine 2 und Maschine 1 an. Das will ich einfach erfassen weil mit dieser Entscheidungsmatrix entschieden werden soll wie schnell eine Pumpe läuft.

    Ich hoffe ihr könnt mir weiterhelfen
    Geändert von 4nD1 (04.02.2016 um 15:50 Uhr)
    Zitieren Zitieren Abfrage ob mehrere Eingänge 1 oder 0 sind  

  2. #2
    Registriert seit
    12.04.2005
    Ort
    Black Forest
    Beiträge
    1.336
    Danke
    27
    Erhielt 130 Danke für 117 Beiträge

    Standard

    Da hatte einer mal hier einen kleinen Baustein vorgestellt, welcher als Output die Anzahl der "1" Bits ausgibt ...
    Mir fällt gerade nur nicht ein welcher Thread dies war !

    „Eine Frage raubt mir den Verstand bin ich verrückt oder sind es die Anderen ?“

    Albert Einstein

  3. #3
    Avatar von 4nD1
    4nD1 ist offline Erfahrener Benutzer
    Themenstarter
    Registriert seit
    31.05.2010
    Beiträge
    411
    Danke
    37
    Erhielt 10 Danke für 9 Beiträge

    Standard

    Ja sowas wäre mega gut.
    Hoffe jemand kann sich an den Thread erinnern.

  4. #4
    Registriert seit
    29.03.2004
    Beiträge
    5.735
    Danke
    143
    Erhielt 1.685 Danke für 1.225 Beiträge

    Standard

    In SCL:
    AnzahlMaschinen := BOOL_TO_INT("Maschine 1 Betrieb") + BOOL_TO_INT("Maschine 2 Betrieb") + BOOL_TO_INT("Maschine 3 Betrieb") + BOOL_TO_INT("Maschine 4 Betrieb");
    Die Genialität einer Konstruktion liegt in ihrer Einfachheit – Kompliziert bauen kann jeder.

    (Sergei Pawlowitsch Koroljow, sowjetischer Konstrukteur von Raketen und Weltraumpionier)

  5. #5
    Registriert seit
    12.12.2013
    Ort
    Kaiserslautern
    Beiträge
    1.337
    Danke
    386
    Erhielt 218 Danke für 173 Beiträge

    Standard

    Ich kann mir an den Tread errinneren.
    Es geht um diese Baustein.

    Code:
     FUNCTION_BLOCK "Bitsumme"
    { S7_Optimized_Access := 'FALSE' }
    VERSION : 0.1
       VAR_INPUT 
          DBNR : Int;
       END_VAR
       VAR_OUTPUT 
          Anzahl_Bits : DInt;
       END_VAR
       VAR_TEMP 
          DBNR_t : Int;
          Pointer_daten_bit_t : DWord;
          SchleifenZaehler_T : DInt;
          Bitzaehler_t : DInt;
       END_VAR
    
    BEGIN
    NETWORK
    TITLE = 
          L #DBNR                     ;//Indirektes Öffenen des Datenbausteines über In Parameter
          T #DBNR_t;
          AUF DB[ #DBNR_t];
    //******************************************************************************** ***********
          LAR1 P#0.0                     ;//Initialisierung des Datenbitpointers 
    //******************************************************************************** ***********
          L DINT#0                       ;//Initialisierung des Bitzaehlers
          T #Bitzaehler_t;
    //******************************************************************************** ***********
          L DBLG                      ;//auslesen der Datenbausteinlänge in Byte
          L DINT#8                       ;//multiplikationfaktor Byte nach Bit 
          *D;
    next:      T #SchleifenZaehler_T       ;//Vorspannen des Schleifenzaehlers in DINT,da die Schleife grösser als 32767 sein Könnte
          CLR                             ;//Erzwingen VKE=0 
          U DBX[ AR1, P#0.0];
          SPBN m001                      ;//wenn Bit=0 Springe
          L DINT#1                       ;//Zaehlen wenn ein Bit=1
          L #Bitzaehler_t;
          +D;
          T #Bitzaehler_t;
    m001:      +AR1 P#0.1                     ;//Pointererhöhung für nächsten Schleifendurchlau
          L #SchleifenZaehler_T       ;//dekrementierung SchleifenZaehler_T um 1
          L DINT#1;
          -D;
          L DINT#1;
          >=D;
          SPB nex2                      ;// Rücksprung in Schleife wenn noch nicht alle Bits des DB auf 1 Geprüft
          SPA m002;
    nex2:      TAK;
          SPA next;
    m002:      NOP 0;
    //******************************************************************************** ***********
          L #Bitzaehler_t             ;// Übergabe der Temporär gezaehlten 1=Bit an Output
          T #Anzahl_Bits;
    
    END_FUNCTION_BLOCK
    Bram
    Wenn es nicht auf STRAVA ist, ist es nicht passiert !!

  6. #6
    Registriert seit
    06.10.2003
    Beiträge
    3.411
    Danke
    451
    Erhielt 504 Danke für 407 Beiträge

    Standard

    Wenn es nur wenige Maschinen sind oder wenn man den Maschinen unterschiedliche Gewichtungen zuordnen muss, kann man es auch ganz einfach wie folgt umsetzen.

    Code:
    FUNCTION FC 3 : REAL
    TITLE =
    VERSION : 0.1
    
    
    VAR_INPUT
      MASCHINE_1_BM : BOOL ;    //Betriebsmeldung Maschine
      MASCHINE_2_BM : BOOL ;    //Betriebsmeldung Maschine
      MASCHINE_3_BM : BOOL ;    //Betriebsmeldung Maschine
      MASCHINE_4_BM : BOOL ;    //Betriebsmeldung Maschine
    END_VAR
    VAR_TEMP
      Y : REAL ;    //Stellgrad [0..100%]
    END_VAR
    BEGIN
    NETWORK
    TITLE =
    
    
    //*** Initialisierung
          L     0.000000e+000; 
          T     #Y; 
    
    //*** Maschine 1
          U     #MASCHINE_1_BM; 
          SPBN  M001; 
          L     #Y; 
          L     2.000000e+001; // 20%
          +R    ; 
          T     #Y; 
    M001: NOP   0; 
    
    //*** Maschine 2
          U     #MASCHINE_2_BM; 
          SPBN  M002; 
          L     #Y; 
          L     3.000000e+001; // 30%
          +R    ; 
          T     #Y; 
    M002: NOP   0; 
    
    //*** Maschine 3
          U     #MASCHINE_3_BM; 
          SPBN  M003; 
          L     #Y; 
          L     2.500000e+001; // 25%
          +R    ; 
          T     #Y; 
    M003: NOP   0; 
    
    //*** Maschine 4
          U     #MASCHINE_4_BM; 
          SPBN  M004; 
          L     #Y; 
          L     2.500000e+001; // 25%
          +R    ; 
          T     #Y; 
    M004: NOP   0; 
    
    //*** Stellgrad ausgeben
          L     #Y; 
          T     #RET_VAL; // 0..100%
    
    
    END_FUNCTION
    Es gibt viel mehr Leute, die freiwillig aufgeben, als solche, die echt scheitern.
    Henry Ford

  7. #7
    Registriert seit
    22.06.2009
    Ort
    Sassnitz
    Beiträge
    11.186
    Danke
    923
    Erhielt 3.291 Danke für 2.660 Beiträge

    Standard

    Zitat Zitat von Onkel Dagobert Beitrag anzeigen
    Wenn es nur wenige Maschinen sind oder wenn man den Maschinen unterschiedliche Gewichtungen zuordnen muss, kann man es auch ganz einfach wie folgt umsetzen.
    Yepp, das wäre auch mein Favorit.

    Wenn es nur ein paar Maschinen sind würde ich nicht zusammengepackte Bits zählen sondern sequentiell die bedingten Additionen ausprogrammieren. Das wird übersichtlich und schafft eine einfache Möglichkeit, die Maschinen unterschiedlich gewichtet in die Berechnung eingehen zu lassen.
    Code:
    Summe := 0 ;
    IF "Maschine 1 Betrieb" THEN Summe := Summe + 1; END_IF;
    IF "Maschine 2 Betrieb" THEN Summe := Summe + 2; END_IF; //Maschine 2 hat mehr Bedarf
    IF "Maschine 3 Betrieb" THEN Summe := Summe + 1; END_IF;
    ...
    IF "Maschine n Betrieb" THEN Summe := Summe + 1; END_IF;
    Noch viele weitere Programmvarianten zum Bits zählen und davon abhängig gestaffelte Sollwerte, auch für TIA, findet man mit der Forumsuche nach BITSUM.

    Harald
    Es ist immer wieder überraschend, wie etwas plötzlich funktioniert, sobald man alles richtig macht.

    FAQ: Linkliste SIMATIC-Kommunikation über Ethernet

  8. #8
    Registriert seit
    16.03.2014
    Beiträge
    359
    Danke
    74
    Erhielt 45 Danke für 38 Beiträge

    Standard

    Hi,
    ich würde es auch mit ein paar ausprogrammierten Zeilen machen:


    Summe :=0;
    summe := summe + bool_to_int(maschine1);
    summe := summe + bool_to_int(maschine2);
    summe := summe + bool_to_int(maschine3);
    summe := summe + bool_to_int(maschine4);

    Ist ggf. übersichtlicher aber eine Einzelbewertung minimal aufwendiger (bool_to_int(machinex) * Faktor

    LG
    Shrimps

  9. #9
    Avatar von 4nD1
    4nD1 ist offline Erfahrener Benutzer
    Themenstarter
    Registriert seit
    31.05.2010
    Beiträge
    411
    Danke
    37
    Erhielt 10 Danke für 9 Beiträge

    Standard

    Zitat Zitat von de vliegende hollander Beitrag anzeigen
    Ich kann mir an den Tread errinneren.
    Es geht um diese Baustein.

    Code:
     FUNCTION_BLOCK "Bitsumme"
    { S7_Optimized_Access := 'FALSE' }
    VERSION : 0.1
       VAR_INPUT 
          DBNR : Int;
       END_VAR
       VAR_OUTPUT 
          Anzahl_Bits : DInt;
       END_VAR
       VAR_TEMP 
          DBNR_t : Int;
          Pointer_daten_bit_t : DWord;
          SchleifenZaehler_T : DInt;
          Bitzaehler_t : DInt;
       END_VAR
    
    BEGIN
    NETWORK
    TITLE = 
          L #DBNR                     ;//Indirektes Öffenen des Datenbausteines über In Parameter
          T #DBNR_t;
          AUF DB[ #DBNR_t];
    //******************************************************************************** ***********
          LAR1 P#0.0                     ;//Initialisierung des Datenbitpointers 
    //******************************************************************************** ***********
          L DINT#0                       ;//Initialisierung des Bitzaehlers
          T #Bitzaehler_t;
    //******************************************************************************** ***********
          L DBLG                      ;//auslesen der Datenbausteinlänge in Byte
          L DINT#8                       ;//multiplikationfaktor Byte nach Bit 
          *D;
    next:      T #SchleifenZaehler_T       ;//Vorspannen des Schleifenzaehlers in DINT,da die Schleife grösser als 32767 sein Könnte
          CLR                             ;//Erzwingen VKE=0 
          U DBX[ AR1, P#0.0];
          SPBN m001                      ;//wenn Bit=0 Springe
          L DINT#1                       ;//Zaehlen wenn ein Bit=1
          L #Bitzaehler_t;
          +D;
          T #Bitzaehler_t;
    m001:      +AR1 P#0.1                     ;//Pointererhöhung für nächsten Schleifendurchlau
          L #SchleifenZaehler_T       ;//dekrementierung SchleifenZaehler_T um 1
          L DINT#1;
          -D;
          L DINT#1;
          >=D;
          SPB nex2                      ;// Rücksprung in Schleife wenn noch nicht alle Bits des DB auf 1 Geprüft
          SPA m002;
    nex2:      TAK;
          SPA next;
    m002:      NOP 0;
    //******************************************************************************** ***********
          L #Bitzaehler_t             ;// Übergabe der Temporär gezaehlten 1=Bit an Output
          T #Anzahl_Bits;
    
    END_FUNCTION_BLOCK
    Bram
    Zitat Zitat von Onkel Dagobert Beitrag anzeigen
    Wenn es nur wenige Maschinen sind oder wenn man den Maschinen unterschiedliche Gewichtungen zuordnen muss, kann man es auch ganz einfach wie folgt umsetzen.

    Code:
    FUNCTION FC 3 : REAL
    TITLE =
    VERSION : 0.1
    
    
    VAR_INPUT
      MASCHINE_1_BM : BOOL ;    //Betriebsmeldung Maschine
      MASCHINE_2_BM : BOOL ;    //Betriebsmeldung Maschine
      MASCHINE_3_BM : BOOL ;    //Betriebsmeldung Maschine
      MASCHINE_4_BM : BOOL ;    //Betriebsmeldung Maschine
    END_VAR
    VAR_TEMP
      Y : REAL ;    //Stellgrad [0..100%]
    END_VAR
    BEGIN
    NETWORK
    TITLE =
    
    
    //*** Initialisierung
          L     0.000000e+000; 
          T     #Y; 
    
    //*** Maschine 1
          U     #MASCHINE_1_BM; 
          SPBN  M001; 
          L     #Y; 
          L     2.000000e+001; // 20%
          +R    ; 
          T     #Y; 
    M001: NOP   0; 
    
    //*** Maschine 2
          U     #MASCHINE_2_BM; 
          SPBN  M002; 
          L     #Y; 
          L     3.000000e+001; // 30%
          +R    ; 
          T     #Y; 
    M002: NOP   0; 
    
    //*** Maschine 3
          U     #MASCHINE_3_BM; 
          SPBN  M003; 
          L     #Y; 
          L     2.500000e+001; // 25%
          +R    ; 
          T     #Y; 
    M003: NOP   0; 
    
    //*** Maschine 4
          U     #MASCHINE_4_BM; 
          SPBN  M004; 
          L     #Y; 
          L     2.500000e+001; // 25%
          +R    ; 
          T     #Y; 
    M004: NOP   0; 
    
    //*** Stellgrad ausgeben
          L     #Y; 
          T     #RET_VAL; // 0..100%
    
    
    END_FUNCTION

    Super danke für die Ansätze.

    Nun frage ich ich mich wie bekomme ich das nun in TIA als Baustein und in meine S7-1200?

  10. #10
    Registriert seit
    26.11.2015
    Beiträge
    7
    Danke
    0
    Erhielt 0 Danke für 0 Beiträge

    Standard


    Zuviel Werbung?
    -> Hier kostenlos registrieren
    garnicht, die 1200er kann kein awl. musst du wohl einen der scl ansätze nehmen

Ähnliche Themen

  1. AI 750-468 zeigt Werte an, obwohl keine Eingänge dran sind, defekt?
    Von Thomasheins11 im Forum CODESYS und IEC61131
    Antworten: 2
    Letzter Beitrag: 13.04.2014, 15:12
  2. Antworten: 27
    Letzter Beitrag: 07.03.2011, 12:53
  3. Antworten: 8
    Letzter Beitrag: 30.05.2010, 23:21
  4. einmalige abfrage der eingänge
    Von MarcusS81 im Forum Simatic
    Antworten: 10
    Letzter Beitrag: 01.09.2008, 15:36
  5. Antworten: 5
    Letzter Beitrag: 16.02.2004, 16:57

Lesezeichen

Berechtigungen

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