Bit in Word setzen bzw rücksetzen

Zuviel Werbung?
-> Hier kostenlos registrieren
@Dalbi

Code:
      L     #NR; 
     [COLOR=Red] L     P#0.1; 
      *D    ; 
      L     P#0.1; 
      -D    ; [/COLOR]
      L     D [AR1,P#6.0]; // AR1 auf Anfangsadresse
      +D    ; 
      LAR1  ;
Den Sinn der rot markierten Befehle erklärst du uns sicher auch noch. :ROFLMAO:

Klar, das es bei 1 los geht. ;) 1 = Bit 0.0

Gruss Daniel
 
Zuletzt bearbeitet:
Zuviel Werbung?
-> Hier kostenlos registrieren
Klar, das es bei 1 los geht. ;) 1 = Bit 0.0

Gruss Daniel

Ähm ok, akzeptiert, aber wozu

Code:
 L     P#0.1; 
      *D    ;
Was also soll das eigentlich genau bewirken?

Achtung noch, bei Angabe von 0 und Werten >= 17 werden "benachbarte" Bits übrigens gesetzt/rückgesetzt. Z.bsp. MW10 per Zeiger adressiert, dann wird MW8 bzw. MW12 usw. manipuliert. Von daher macht es Sinn die Werte von Nummer auf 1-16 zu begrenzen.
 
Hi,

oh stimmt. :)

Code:
      L     #NR; 
[COLOR=Black]      L     P#0.1; 
      -D    ; 
[/COLOR]      L     D [AR1,P#6.0]; // AR1 auf Anfangsadresse
      +D    ; 
      LAR1  ;

so würde es auf das selbe heraus kommen.

Gruss Daniel
 
Hi,

oh stimmt. :)

Code:
      L     #NR; 
[COLOR=Black]      L     P#0.1; 
      -D    ; 
[/COLOR]      L     D [AR1,P#6.0]; // AR1 auf Anfangsadresse
      +D    ; 
      LAR1  ;
so würde es auf das selbe heraus kommen.

Gruss Daniel

Und ich dachte schon, du willst uns wieder mal mit Trick17 überraschen. :ROFLMAO: Aber das ist ja nicht weiter schlimm, die Multiplikation beeinflußt das Ergebnis ja nicht.
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Hi,

zu meiner Verteidigung hab ich das ganze mal noch ein wenig angepasst. ;)
Die Länge des angegebenen ANYs wird überprüft und begrenzt. Signalisierung erfolgt über das BIE-Bit (ENO).

Code:
FUNCTION FC 103 : VOID
TITLE = 
//Diese Funktion steuert in abhängigkeit der Eingänge "S" (setzen) und "R" 
//(rücksetzen) ein Bit (Nr) im Any-Pointer (Bitfeld).
//
//- Zulässige Parameter für den Any-Pointer sind:
//    BIT, BYTE, WORD u. DWORD
//- Folgende Fehler (Fehler) werden ausgewertet: 
//    Parametrierung, Nr größer Bitanzahl u. Nr kleiner 0
//    Fehler wird im BIE-Bit signalisiert.
//    Parametrierung Fehlerfrei BIE = TRUE
//     "     "    "  Fehler     BIE = FALSE
AUTHOR : dalbi
VERSION : 1.0


VAR_INPUT
  S : BOOL ;    //Bit setzen
  R : BOOL ;    //Bit rücksetzen
  NR : INT ;    //Nummer
END_VAR
VAR_IN_OUT
  ZEIGER : ANY ;    //Zeiger Bitfeld
END_VAR
VAR_TEMP
  tSaveAR1 : DWORD ;    //Speicher Adressregister 1
  tSaveAR2 : DWORD ;    //Speicher Adressregister 2
  tDBNr : WORD ;    //Datenbausteinnummer
  tLaenge : INT ;    
END_VAR
BEGIN
NETWORK
TITLE =Prüfen

      TAR1  #tSaveAR1; // Adressregister sichern
      TAR2  #tSaveAR2; 

      L     P##ZEIGER; // AR1 auf Bitfeld
      LAR1  ; 

      L     W [AR1,P#4.0]; // DB-Nummer
      T     #tDBNr; 

      L     B [AR1,P#1.0]; // Datentyp
      L     B#16#1; // BIT
      ==I   ; 
      SPB   bit; 

      TAK   ; 
      L     B#16#2; // BYTE
      ==I   ; 
      SPB   byte; 

      TAK   ; 
      L     B#16#4; // WORD
      ==I   ; 
      SPB   word; 

      TAK   ; 
      L     B#16#6; // DWORD
      ==I   ; 
      SPB   dw; 

      SPA   err; // Fehler, wenn kein Typ

bit:  L     1; // BIT
      SPA   set; 
byte: L     8; // BYTE
      SPA   set; 
word: L     16; // WORD
      SPA   set; 
dw:   L     32; // DWORD
set:  L     W [AR1,P#2.0]; // Wiederholfaktor für Typ
      *I    ; 
      T     #tLaenge; // Länge in Bit

      L     #NR; 
      L     1; 
      <I    ; 
      SPB   err; 

      L     #NR; 
      L     #tLaenge; // Wiederholfaktor für Typ
      >I    ; 
      SPB   err; 

NETWORK
TITLE = 

      AUF   DB [#tDBNr]; // DB aufschlagen

      L     #NR; 
      L     P#0.1; 
      -D    ; 
      L     D [AR1,P#6.0]; // AR1 auf Anfangsadresse
      +D    ; 
      LAR1  ; 

NETWORK
TITLE =Logik

      U     #S; 
      S      [AR1,P#0.0]; 
      U     #R; 
      R      [AR1,P#0.0]; 

NETWORK
TITLE =Auswertung BIE-Bit

      SET   ; // IO
      SPA   io; // BIE-Bit auf 1 setzen
err:  NOP   0; // Bei Fehler
      CLR   ; // BIE-Bit auf 0 setzen
io:   SAVE  ; // BIE-Bit sichern

      LAR1  #tSaveAR1; // Adressregister 1 rückschreiben
      LAR2  #tSaveAR2; // Adressregister 2 rückschreiben

END_FUNCTION

Gruss Daniel
 

Anhänge

  • Nr_Bit_Steuern.zip
    34,1 KB · Aufrufe: 5
Schieben kommt nicht in Frage weil alle anderen Bits in dem Word an der alten stelle erhalten bleiben müssen.
Wie kommst Du auf Schieben? Kein Programmbeispiel in diesem Thread schiebt Dein Datenword.

und wenn die Pallette dann belegt wurde wollte ich mit einer eleganten lösung das bit für z.B. #Pal_1 in dem Datenword setzen und bei entnahme rücksetzen.
Also für elegante Lösungen ist die Grundvoraussetzung, daß man zuerst mal versteht, was man überhaupt tut.
Ein Monsterbaustein mit vielen P# und ARx und unangemessenem Ressourcenverbrauch sieht zwar für Laien
hinreichend kompliziert aus, ist aber von Eleganz ganz weit weg.

Und noch ein Tip -
kläre und prüfe für Dich folgende Fragen, bevor in einer späteren Visualisierung das große Erwachen kommt:
Wie nummerierst Du die Bits in Deinem Datenword? Von 0 bis 15 oder von 1 bis 16?
Welches Bit ist Deinem Willen nach das erste (niedrigste?) Bit in Deinem Datenword?

Harald
 
Ich grab den thread noch einmal aus, weil ich aktuell die gleiche Problemstellung lösen will.

Für Störmeldungen am HMI sollen Bits in einem WORD gesetzt werden. Das niedrigste Bit soll bei 1, das höchste Bit bei 16 gesetzt werden. Das Störmeldewort soll dabei nicht mit 0 initialisiert werden, da ich ggf. nacheinander mehrere Bits gesetzt werden sollen. Es soll also durch eine INT-Variable bestimmt werden, welche Bitposition gesetzt wird. Ich habe das jetzt wie folgt gelöst. Die Lösung funktioniert in PLCSIM. Da ich aber nicht so oft mit Pointern hantiere, würde mich interessieren, ob da irgendeine "Krücke" verbaut ist:

Code:
// Störmeldewort rangieren
      L     #Stoermeldewort
[COLOR=#ff0000]  //     TAW   [/COLOR]
      T     #Meldewort
      LAR1  P##Meldewort

// Grenzen prüfen (1..16)
      U(    
      L     #Stoerungsnummer
      L     0
      >I    
      )     
      U(    
      L     #Stoerungsnummer
      L     16
      <=I   
      )     
      SPBN  ende

// Initialisieren. (Schleife beginnt bei 1)
      L     1
      T     #Nummer

// Wenn Schleifenzähler = Störungsnummer -> Bit setzen
m001: L     #Nummer
      L     #Stoerungsnummer
      ==I   
      SPB   m002

// Schleifenzähler + AR1 incrementieren (bis 16)
      L     #Nummer
      INC   1
      T     #Nummer
      L     P#0.1
      +AR1  

      L     #Nummer
      L     16
      <I    
      SPB   m001

// Bit gemäß AR1 setzen + zurückrangieren
m002: SET   
      S     L [AR1,P#0.0]
      L     #Meldewort
[COLOR=#ff0000]  //    TAW   [/COLOR]
      T     #Stoermeldewort

ende: NOP   0

Edit: Gerade noch gesehen. Das TAW war falsch.
 
Zuletzt bearbeitet:
Zurück
Oben