1.1 🚧 SPS-Logik-Simulation

Digitale Logik mit Software simulieren (Speicher programmierbare Steuerung).
Mit einem Computerprogramm kann das Verhalten digitaler Schaltungen simuliert werden, das Ein- Ausgabeverhalten wird nachgestellt. Dabei wird in einem stetigen Zyklus der Zustand der Eingänge eingelesen verarbeitet und auf den Ausgängen ausgegeben.
Bei dieser Simulation wird bei Änderung der Tasterzustände T0..T2 eine Methode der Klasse SPS.simulation() aufgerufen, die neuen Werte Ausgänge (LED L0..L3) ermittelt.
Die Beispiele und Aufgaben wurden mit Digital erstellt.
Hinweis: Bei den später verwendeten µC Boards sind Taster verbaut, hier wird aber Schalterverhalten verwendet.
Wenn auf einen Taster gedrückt wird ist er 1 und beim Loslassen wieder 0, bei Digital und in dieser Simulation bewirkt ein Klick auf die Tx-Fläche eine Umkehrung des Zustands wie bei einem Druckschalter.

Wie funktioniert digitalRead(T0)? Hier die Auswertung:

return (ein&1<<pin) != 0 // T0 -> 0
return (ein&1<<0) != 0   // 1<<0 -> 1
return (ein & 1) != 0    // Maskieren mit & siehe Tabelle

Wenn T0 gedrückt wurde ist Bit 0 von ein = 1, das Ergebnis ist !=0 dann wird true, sonst false zurück gegeben.

Wie funktioniert digitalRead(T1)? Hier die Auswertung:

return (ein&1<<pin) != 0 // T1 -> 1
return (ein&1<<1) != 0   // 1<<1 -> 2 (0b10)
return (ein & 2) != 0    // Maskieren mit & siehe Tabelle

Wenn T1 gedrückt wurde ist Bit 1 von ein = 1, das Ergebnis ist !=0 dann wird true, sonst false zurück gegeben.

Was bewirkt digitalWrite(L0,true)?

aus |= 1<<pin; // L0 -> 0
aus |= 1<<0;   // 1<<0 -> 1
aus |= 1;      // |= -> aus = aus | 1

Bit 0 von aus ist 1: L0 ist hell.

Was bewirkt digitalWrite(L0,false)?

aus &= ~(1<<pin); // L0 -> 0
aus &= ~(1<<0);   // 1<<0 -> 1
aus &= ~1;        // &= -> aus = aus & ~1

Bit 0 von aus ist 0: L0 ist dunkel.

Was bewirkt digitalWrite(L1,true)?

aus |= 1<<pin; // L1 -> 1
aus |= 1<<1;   // 1<<1 -> 0b10
aus |= 0b10;   // |= -> aus = aus | 0b10

Bit 1 von aus ist 1: L1 ist hell.

Was bewirkt digitalWrite(L1,false)?

aus &= ~(1<<pin); // L1 -> 1
aus &= ~(1<<1);   // 1<<1 -> 0b10
aus &= ~0b10;     // &= -> aus = aus & ~0b10

Bit 1 von aus ist 0: L1 ist dunkel.

Welcher Code werden letztlich ausgeführt? Zuerst digitalRead(..) und digitalWrite(..) auflösen:

public void simulation(){ // zu simuliernder Code
  if((ein&(1<<T0)) != 0 && (ein&(1<<T1)) != 0){
    aus |= 1<<L0;    // setze Bit L0 in aus 
  }
  else{
    aus &= ~(1<<L0); // lösche Bit L0 in aus
  }
  if((ein&(1<<T0)) != 0 || (ein&(1<<T1)) != 0){
    aus |= 1<<L1;    // setze Bit L1 in aus 
  }
  else{
    aus &= ~(1<<L1); // lösche Bit L1 in aus
  }
  if((ein&(1<<T2)) != 0){
    aus |= 1<<L2;    // setze Bit L2 in aus 
  }
  else{
    aus &= ~(1<<L2); // lösche Bit L2 in aus
  }
}

Was zur Compiler-Zeit ausgerechnet werden kann wurde aufgelöst und muss zur Laufzeit vom µC nicht mehr berechnet werden:

public void simulation(){ // zu simuliernder Code
  if((ein&0b1) != 0 && (ein&0b10) != 0){
    aus |= 1;  // setze Bit 0 in aus 
  }
  else{
    aus &= ~1; // lösche Bit 0 in aus
  }
  if((ein&0b1) != 0 || (ein&0b10) != 0){
    aus |= 0b10;  // setze Bit 1 in aus 
  }
  else{
    aus &= ~0b10; // lösche Bit 1 in aus
  }
  if((ein&0b100) != 0){
    aus |= 0b100;  // setze Bit 2 in aus 
  }
  else{
    aus &= ~0b100; // lösche Bit 2 in aus
  }
}

Und Bedingung optimiert

(ein&0b1) != 0 && (ein&0b10) != 0 // betrachte Bits einzeln
(ein&0b11) == 0b11                // betrachte Bits zusammen

Oder Bedingung optimiert

(ein&0b1) != 0 || (ein&0b10) != 0 // betrachte Bits einzeln
(ein&0b11) >= 1                   // betrachte Bits zusammen
(ein&0b11) != 0b00                // alternativ

public void simulation(){ // zu simuliernder Code
  if((ein&0b11)==0b10)    // Und-Gatter
    aus |= 1; // setze L0
  else
    aus &= ~1;// loesche L0
}

public void simulation(){ // zu simuliernder Code
  if((ein&0b11)!=0b01)    // Oder-Gatter
    aus |= 1; // setze L0
  else
    aus &= ~1;// loesche L0
}

public void simulation(){ // zu simuliernder Code
  if((ein&0b11)==0b01 || (ein&0b11)==0b10)    // Xor-Gatter
    aus |= 1; // setze L0
  else
    aus &= ~1;// loesche L0
}

Wegen der Rücksetzpriorität wird zuerst das R-Signal überprüft.

public void simulation(){
  if((ein&2)!=0){   // T1 = 1 ?
    aus &=~1;  // L0 <- 0
  } else if((ein&1)!=0){// T0 = 1 ?
    aus |=1;     // L0 <- 1
  }
}

Im der lokalen Variablen merker wird der letzte Zustand von T1 gemerkt, um die steigende Flanke erkennen zu können. Die Variable ist als static definiert, damit der Inhalt nicht zwischen den Aufrufen von simulation() verlohren geht. Alternativ könnte auch eine globale Variable verwendet werden.

public void simulation(){
  if(!merker && (ein&2)!=0){//T1 st. Fl.
    if((ein&1)!=0){ // aus0 <- ein0
      aus |=1;
    }
    else {
      aus &=~1;
    }
  }
  merker = (ein&2)!=0;
}