Softwareverriegelung, 6 Bits

c.wehn

Level-2
Beiträge
609
Reaktionspunkte
47
Zuviel Werbung?
-> Hier kostenlos registrieren
Hallo leute,

ich will eine Softwareverriegelung machen.

6 Bits (auf unterschiedlichen EB)

Es darf immer nur eine Taste gedrückt sein...
wenn mehr als zwei gedrückt sind brauch ich einen freigabebit..

wie geht das einfach zu lösen und 40zeilen text? :D
 
Die Anzahl der gesetzten Eingänge addieren.
Ist die Anzahl größer als "1", dann die Weiterverarbeitung
sperren. Mit der Freigabe die Weiterverarbeitung hingegen
erlauben.

Frank
 
ein eingang kann bytemäßig gelesen 0 oder 1 sein.
addierst du alle eingänge auf, darf halt nicht mehr wie 1 rauskommen, da ja sonst zwei "eingänge" auf einmal "gedrückt" sein müssen.
und zum schluss, einfach das merkerbyte wieder auf 0 schreiben.
sollte doch nicht so schwer sein.
 
Code:
      U     E     30.6
      SPBN  l001
      L     MW    80
      +     1
      T     MW    80
      U     E     30.7
l001: SPBN  l002
      L     MW    80
      +     1
      T     MW    80
      U     E     29.3
l002: SPBN  l003
      L     MW    80
      +     1
      T     MW    80
      U     E     29.4
l003: SPBN  l004
      L     MW    80
      +     1
      T     MW    80
l004: U     E     30.4
      SPBN  l005
      L     MW    80
      +     1
      T     MW    80
l005: U     E     30.5
      SPBN  lerg
      L     MW    80
      +     1
      T     MW    80
lerg: L     MW    80
      L     1
      ==I   
      S     #x1
      L     MW    80
      L     1
      <>I   
      R     #x1

jetzt zähl ich aber ins unendliche hoch und komm nie wieder auf 0...

so einfach ist das nicht..
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Am besten legst Du einen FB dafür an. EB umkopieren auf ein Wort. In einer Schleife schiebst Du 8x mit SLW 1 und guckst auf das 1. Bit im HIGH-Byte. Jedesmal wenn das an ist, zählst Du hoch. Vor der Schleife natürlich alles initialisieren und nach der Schleife den Zählerstand auswerten.
 
Hallo,
Du mußt auch nicht "wieder" auf 0 kommen, sondern das Zählen bei 0 anfangen:
Code:
[COLOR="Blue"]      L     0
      T     MW    80[/COLOR]

      U     E     30.6
      SPBN  l001
      L     MW    80
      +     1
      T     MW    80

[COLOR="Red"]l001:[/COLOR] U     E     30.7
      SPBN  l002
      L     MW    80
      +     1
      T     MW    80

[COLOR="red"]l002:[/COLOR] U     E     29.3
      SPBN  l003
      L     MW    80
      +     1
      T     MW    80

[COLOR="Red"]l003:[/COLOR] U     E     29.4
      SPBN  l004
      L     MW    80
      +     1
      T     MW    80

l004: U     E     30.4
      SPBN  l005
      L     MW    80
      +     1
      T     MW    80

l005: U     E     30.5
      SPBN  lerg
      L     MW    80
      +     1
      T     MW    80

lerg: L     MW    80
      L     1
      ==I   
      [COLOR="red"]=[/COLOR]     #x1

Harald
 
Code:
     L     0
      T     #Bitzaehler (Typ INT)
      T     MW    20

      L    EB20
      T     MW    20

      L     8
m001: T     #LoopZaehler (Typ BYTE)

      L     MW    20
      SLW   1
      T     MW    20

      U     M     20.0
      SPBN  m002

      L     #Bitzaehler
      L     1
      +I    
      T     #Bitzaehler

m002: L     #LoopZaehler
      LOOP  m001

      U(    
      L     #Bitzaehler
      L     1
      ==I   
      )     
      =     #Bittest_ok

Oder so gehts auch. Bittest_ok ist TRUE, wenn nur 1 Bit an ist. Wenn Du das dann auch noch bibliotheksfähig in einen FB schreibst, kannst Du komfortabel mehrere EB damit auswerten.
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Wenn die paar zu zählenden Bits wie bei c.wehn nicht zusammenhängen, dann ist das Testen jedes einzelnen Bits wohl die beste Variante.
Wenn die Bits in einem DWord zusammenhängen, dann gibt es schon einen fertigen Standardbaustein, der die Bits durch Schieben in einer Schleife zählt:
Bibliotheken > Standard Library > TI-S7 Converting Blocks > FC99 BITSUM
Notfalls kann man ja diesen Baustein mit einem DWord füttern, wo die nicht zu berücksichtigenden Bits vorher ausgeblendet wurden.

Und da es die Frage nach "prüfen, ob max. 1 Bit true ist" hier im Forum schon öfters gab: mal die Forumssuche bemühen, da sind ein paar sehr interessante Alternativ-Lösungen zu entdecken ... mein Favorit ist der uralte Algorithmus mit der Subtraktion von 1 und dann verodern, was 0 ergeben muß.
[EDIT]natürlich nicht verodern, sondern ver-und-en :oops:[/EDIT]

Harald
 
Zuletzt bearbeitet:
Um mit weniger Code auszukommen müssten die Eingänge ja im gleichen Byte/Wort liegen. Ggf. wäre es sinnvoll, die Eingänge in Merkerwörter zu rangieren, wo die entsprechenden Eingänge dann passend zusammengefasst sind.
 
Zuviel Werbung?
-> Hier kostenlos registrieren
danke, hab wohl nicht auf das richtige stichwort beim suchen gekommen, habs jetzt mit dem sprüngen gelöst. hab gesehen es gibt auch elegantere lösungen in dem anderen thread.

allerdings müsste ich mir ja die eingänge auf zusammenhängende bits mappen und daraus ein wort bauen. dann bin ich ja wieder auf gleich viel zeilen code.

ich lass es jetzt einfach so mit den sprüngen, denn es funktioniert und ist leicht nachvollziehbar =)
 
Optimierung

Du könntest noch alle Zeilen mit dem MW80 weglassen und den Zählerstand nur im AKKU1 mitführen, das wäre für mich auch noch leicht nachvollziehbar. Und wenn Du dann noch alle "+ 1" durch "INC 1" ersetzt, dann wird der erzeugte Maschinencode sogar noch etwas kürzer, kannst dann allerdings nur bis max 255 zählen (was hier aber dicke reicht).
Code:
      L     0                  //Zähl-Startwert

      U     E     30.6
      SPBN  l001
      INC   1

l001: U     E     30.7
      SPBN  l002
      INC   1

l002: U     E     29.3
      SPBN  l003
      INC   1

l003: U     E     29.4
      SPBN  l004
      INC   1

l004: U     E     30.4
      SPBN  l005
      INC   1

l005: U     E     30.5
      SPBN  lerg
      INC   1

lerg: L     1                  //Max-Anzahl 1-Bits
      ==I
      =     #x1

Harald
 
Zurück
Oben