Gerade od. Ungerade das ist hier die Frage

A

Anonymous

Guest
Zuviel Werbung?
-> Hier kostenlos registrieren
wie kann ich bei einer integer zahl feststellen ob sie gerade od. ungerade ist, ohne den befehl mod_di (fup) zu verwenden. da ich zuerst die zahl in ein md wandeln und anschl. den divisionsrest auswerten müsste. geht dies einfacher. fup lösung wäre mir lieber, wird aber am schnellsten in awl zu lösen sein oder???
315-dp, Simatic-Manager V5.1+SP6
danke im voraus für die mühe
tanja
 
schau dir das rechteste bit an. bei db1.dbw0 wäre es das bit db1.dbx1. 0. wenn dieses high ist, dann ist der integer ungerade, bei low gerade.

viele grüße aus berlin von
lutz
 
Hallo zusammen,

habe da mal ne Frage zur Sicherstellung für mich.
Würde dies auch bei einem MW funktionieren?
Beispiel:
Habe ein MW4 aus einem Zähler. das Wird dann von BCD > INT und ist dann MW 6.
Wenn ich nun M6.0 abfrage und der HIGH ist habe ich dann auch eine ungerade Zahl?

P.S. gleiche CPU wie der Starter.

Vielen Dank schon mal.
 
Habs derweil schon getestet, hat funktioniert.
Ich arbeite lieber mit Merkern, weil DB`s nicht ganz so schnell sind sobald die Funktionen mehr und größer werden.
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Test gerade/ungerade in FUP

Wenn man in FUP sauber symbolisch testen will, ob ein Wert gerade oder ungerade ist, dann maskiert man das niederwertigste Bit (WordVar WAND_W W#16#1) oder schiebt das niederwertigste Bit in das Statusbit A1 (WordVar SHR_W W#16#1 oder IntVar SHR_I W#16#1) und fragt dann das Statusbit A1 ab mit U ==0 (--> gerade) oder U >0 (--> ungerade) (oder U <>0 (--> ungerade) geht auch).

Beispiel FUP via Maskieren:
Code: 
       +---------+
       |  BCD_I  |
  ...--|EN    OUT|--"MW6"      +--------+
       |         |             | WAND_W |
"MW4"--|IN    ENO|-------------|EN      |
       +---------+             |        |
                        "MW4"--|IN1  OUT|--#tempWord
                               |        |
                       W#16#1--|IN2  ENO|--+             +-----+
                               +--------+  |             |  &  |
                                           +-------------|     |
                                           |             |     |   #ungerade
                                           |   +-----+   |     |   +-----+
                                           |   |  >0 |---|     |---|  =  |
                                           |   +-----+   +-----+   +-----+
                                           |
                                           |             +-----+
                                           |             |  &  |
                                           +-------------|     |
                                                         |     |   #gerade
                                               +-----+   |     |   +-----+
                                               | ==0 |---|     |---|  =  |
                                               +-----+   +-----+   +-----+

Beispiel AWL via Schieben:
Code: 
      L     "MW4"
      BTI                   // BCD->INT
      T     "MW6"

//Test gerade/ungerade
      CLR                   // vorherige Verknüpfungen garantiert abschließen

      L     "MW6"
      SRW    1              // niederwertigstes Bit --> A1

      U     >0              // A1 == 1 ?
      =     #ungerade
      U     ==0             // A1 == 0 ?
      =     #gerade

Harald
 
Michakron schrieb:
Ich arbeite lieber mit Merkern, weil DB`s nicht ganz so schnell sind sobald die Funktionen mehr und größer werden.
Zum Vergrößern anklicken....
Die Geschwindigkeit des Zugriffs auf DB hat nichts damit zu tun, wieviele oder wiegroße Funktionen man hat.
Außerdem besteht bei den aktuellen CPU kein Unterschied bei der Zugriffsgeschwindigkeit auf Merker und vollqualifizierter Zugriff auf DB.

Harald
 
kpeter schrieb:
wieso hat integer kein vorzeichen

aber ein word hat dann eins oder was meinst du
Zum Vergrößern anklicken....

Keine Ahnung wie ich die Frage jetzt verstanden habe. Ich hab irgendwie rausgelesen ihr wolltet mit dem Vorzeichen Bit das Vorzeichen wechseln. *argl* Natürlich kann man mit dem höchstwertigsten Bit das Vorzeichen abfragen.
Ich sollte schlafen gehen.

mfG René
 
Zuviel Werbung?
-> Hier kostenlos registrieren
PN/DP schrieb:
Wenn man in FUP sauber symbolisch testen will, ob ein Wert gerade oder ungerade ist, dann maskiert man das niederwertigste Bit (WordVar WAND_W W#16#1) oder schiebt das niederwertigste Bit in das Statusbit A1 (WordVar SHR_W W#16#1 oder IntVar SHR_I W#16#1) und fragt dann das Statusbit A1 ab mit U ==0 (--> gerade) oder U >0 (--> ungerade) (oder U <>0 (--> ungerade) geht auch).

Beispiel FUP via Maskieren:
Code: 
       +---------+
       |  BCD_I  |
  ...--|EN    OUT|--"MW6"      +--------+
       |         |             | WAND_W |
"MW4"--|IN    ENO|-------------|EN      |
       +---------+             |        |
                        "MW[COLOR=#ff0000]6[/COLOR]"--|IN1  OUT|--#tempWord
                               |        |
                       W#16#1--|IN2  ENO|--+             +-----+
                               +--------+  |             |  &  |
                                           +-------------|     |
                                           |             |     |   #ungerade
                                           |   +-----+   |     |   +-----+
                                           |   |  >0 |---|     |---|  =  |
                                           |   +-----+   +-----+   +-----+
                                           |
                                           |             +-----+
                                           |             |  &  |
                                           +-------------|     |
                                                         |     |   #gerade
                                               +-----+   |     |   +-----+
                                               | ==0 |---|     |---|  =  |
                                               +-----+   +-----+   +-----+
Zum Vergrößern anklicken....
Nur der richtigkeit halber.
 
wolder schrieb:
Nur der richtigkeit halber.
Zum Vergrößern anklicken....
Es ist beliebig, ob man den BCD-Wert (MW4) vor oder nach der Wandlung zu INT (MW6) auf gerade/ungerade testet.

Man muß aber für FUP die verlangten Datentypen an den Boxen einhalten:
- MW4 muß ein WORD sein an IN von BCD_I
- MW6 muß ein INT sein am OUT von BCD_I
- WAND_W verlangt ein WORD - MW6 wird abgewiesen, MW4 wird akzeptiert

Harald
 
Ergänzung:
Wenn man unbedingt MW6 testen will, dann könnte man statt WAND_W eine SHR_I-Box benutzen oder MW6 mit MOVE auf eine WORD-Variable kopieren, welche dann an WAND_W verschaltet werden kann.

Harald
 
Zurück
Oben