TIA Bitzuweisung

[CDX]

Zuviel Werbung?
-> Hier kostenlos registrieren

Ok. Wie stelle ich dann eine Verbindung zwischen den Bits (1 Bit je LED) und der DWord Variable in welche ich die hex Zahl schreibe her? Die Information dass ein bestimmtes Bit und damit eine bestimmte LED leuchten soll fehlt.

Das mit dem Bitmuster versteh ich schon, ich müsste diese DWord Variable mit den LEDs verbinden.

 

[Credofire]

einfach mit move dein dbWord auf das Ausgangswort, zB DB.D0 auf AD0 mit dem move Befehl, bzw AD0 := DB.D0 in Strukturierten Text.
Wobei ich mit dem D nicht sicher bin für DoubleWord, ich benutze das selten.

p.s. Dein Hexcode ergibt ein bestimmtes Bitmuster. Kannst du dir ja am Windows Taschenrechner mal anzeigen lassen wenn du auf Programmierer stellst

 

[PN/DP]

Zuviel Werbung?
-> Hier kostenlos registrieren

Für ein anschauliches und genaues Programmbeispiel wäre es vorteilhaft, wenn Du uns mal mitteilst, an welchen Ausgängen genau die 20 LED angeschlossen sind.
Und es wäre auch vorteilhaft, wenn Du mal ein paar Deiner "zu vielen Kombinationsmöglichkeiten" genauer erläutern würdest. Wie ist das gemeint mit "welcher Schalter für welche Glühbirne da ist ist frei wählbar"? Wie frei? Und wie soll das ausgewählt werden?
Und es wird nun auf Seite 3 langsam Zeit, daß Du meine Nachfrage beantwortest, welches CPU Du da programmierst. Und welche Programmiersprache für die Lösung zulässig ist, nicht daß sich jemand eine Lösung für Dich ausdenkt und dann kommt "Ätsch, da ist nur FUP zugelassen".

"geht nicht gibt's nicht" - solange eine Aufgabe in widerspruchsfreier Logik formuliert werden kann, dann gibt es auch eine Lösung in SPS.

Harald

 

[RedCali]

ich hätte es so gelöst - siehe Quelle im Anhang

Baustein - FC, aufruf z.B. mit:
IN Byte : %IB0
IN/OUT DWord: %QD0

Das eingangsbyte maskiert und auf integer gemappt
anschließen eine CASE mit 2^3 = 8 fällen
Je Fall ein Const auf ein Temp DWord

Am Ende das Temp DWord mit der maskierten IN/OUT "verodert" und zurück auf die IN/OUT geschrieben
Durch den letzten Schritt erreicht man zum einen das die ausginge auf einen definierten wert gesetzt werden und verhindert das die anderen Bits im IN/OUT überschrieben werden.

Die einzige Einschränkung die ich sehe ist, das ein und Ausgänge beieinander liegen müssen dafür, beginnend bei bit 0
Allerdings sind dafür die Infos nicht gerade ausreichend um das zu entscheiden
Verbesserungsvorschläge werden gerne entgegengenommen

FUNCTION "threeInToTwentyOut" : Void
{ S7_Optimized_Access := 'TRUE' }
VERSION : 0.1
   VAR_INPUT 
      inByte : Byte;   // input byte := IB0
   END_VAR


   VAR_IN_OUT 
      outDWord : DWord;   // output double Word := DWQ0
   END_VAR


   VAR_TEMP 
      tempInByte : Int;   // temp storage for masked input
      tempOutDWord : DWord;   // temp Storage for masked output
   END_VAR


   VAR CONSTANT 
      IN_MASK : Byte := 16#07;   // just the first three from lsb needed
      OUT_MASK : DWord := 16#FFF0_0000;   // just 20 bits from lsb
      CASE_0 : Int := 16#0000;   // nothing to do...... --> output OFF
      CASE_1 : Int := 16#0001;
      CASE_2 : Int := 16#0002;
      CASE_3 : Int := 16#0003;
      CASE_4 : Int := 16#0004;
      CASE_5 : Int := 16#0005;
      CASE_6 : Int := 16#0006;
      CASE_7 : Int := 16#0007;
      OUT_DEFAULT : DWord := 16#0000_0000;   // output OFF
      OUT_0 : DWord := 16#0000_0000;   // output OFF
      OUT_1 : DWord := 16#0000_0001;   // <-- Define your output pattern here.....
      OUT_2 : DWord := 16#0000_0002;
      OUT_3 : DWord := 16#0000_0003;
      OUT_4 : DWord := 16#0000_0004;
      OUT_5 : DWord := 16#0000_0005;
      OUT_6 : DWord := 16#0000_0006;
      OUT_7 : DWord := 16#0000_0007;
   END_VAR




BEGIN
    // mask the input byte
    #tempInByte := #IN_MASK AND #inByte;
    
    // select case of input pattern
    CASE #tempInByte OF
        #CASE_1:  // Statement section case 1
            #tempOutDWord := #OUT_1;
        #CASE_2:  // Statement section case 2
            #tempOutDWord := #OUT_2;
        #CASE_3:  // Statement section case 3
            #tempOutDWord := #OUT_3;
        #CASE_4:  // Statement section case 4
            #tempOutDWord := #OUT_4;
        #CASE_5:  // Statement section case 5
            #tempOutDWord := #OUT_5;
        #CASE_6:  // Statement section case 6
            #tempOutDWord := #OUT_6;
        #CASE_7:  // Statement section case 7
            #tempOutDWord := #OUT_7;
        #CASE_0:  // Statement section case 0
            #tempOutDWord := #OUT_0;
        ELSE  // Statement section ELSE
            #tempOutDWord := #OUT_DEFAULT;
    END_CASE;
    
    // mask IN/OUT to reset previous output, set current output with OR result of case
    #outDWord := (#OUT_MASK AND #outDWord) OR #tempOutDWord;
END_FUNCTION

 

[M-Ott]

Dadurch wird die Sache aber auch nicht viel kürzer und auf keinen Fall übersichtlicher, als mit einfachen Bitzuweisungen.

 

[RedCali]

Zuviel Werbung?
-> Hier kostenlos registrieren

Dadurch wird die Sache aber auch nicht viel kürzer und auf keinen Fall übersichtlicher, als mit einfachen Bitzuweisungen.

OK
noch Kürzer? Da bin ich offen für deine Lösung?

Über die Übersichtlichkeit und das Worting kann man sicher diskutieren, Programmieren hat ja auch was mit Persönlicher Vorliebe und Meinung zu tun.
Die Einschränkung von meinem Entwurf habe ich ja bereits genannt, das man mit den Eingängen und Ausgängen beim Bit null beginnen muss, anderenfalls müsste man die Bitmaske anpassen.

Viele Grüße
RedCali