Während While Schleife ButtonStatus abfragen

Guten Tag zusammen,

Ich möchte mit einen Nano 33 IoT und einem Taster mit 3 LEDs drei Modis an einem externen Gerät steuern.

Die Taster wird gedrückt: blinkt rot und sendet Modi1 an das Gerät, wenn der Modi geschaltet ist, sendet das Gerät eine 1 zurück und die LED leuchtet rot.

Taster wird erneut gedrückt: blinkt grün und sendet Modi2 an das Gerät, wenn der Modi geschaltet ist, sendet das Gerät eine 2 zurück und die LED leuchtet grün.

Taster wird erneut gedrückt: blinkt blau und sendet Modi3 an das Gerät, wenn der Modi geschaltet ist, sendet das Gerät eine 3 zurück und die LED leuchtet blau.

Soweit läuft auch alles, aber...
Möchte ich direkt in Modi 3 schalten, muss ich Modi 1 schalten, warten bis er drin ist, Modi 2 schalten, warten bis er drin ist UND erst jetzt kann ich den Modi 3 schalten.

Dies möchte ich noch gerne noch so abändern, dass der Modi erst nach X Sekunden gesendet wird um das Gerät nicht zu überfordern und dass ich auch während der While Schleife den Taster betätigen kann, bzw das Drücken auch registriert wird.

Anbei mein Code:

const uint16_t onZeit  = 400; //ms
const uint16_t offZeit = 400; //ms
int incomingByte = 0;

int r_pin = 11; // Rote LED Pin
int g_pin = 10; // Grüne LED PIN
int b_pin = 9;  // Blaue LED PIN
int btn_pin = 12; // Pin für den Taster ( modi )
// int btn_onoff_pin = 8; // Pin für Ein/Aus
int isSend = 0;
char *modi[] = {"Modus 1", "Modus 2", "Modus 3"}; // Befehl für Ansteuerung


int ButtonState = 1;
int ButtonCounter = 0;
int ButtonLastState = 0;

void setup() {
  Serial.begin(9600);
  //Serial1.begin(9600);
  pinMode(btn_pin, INPUT_PULLUP);
  pinMode(r_pin, OUTPUT);
  pinMode(g_pin, OUTPUT);
  pinMode(b_pin, OUTPUT);
}

void loop() {
  ButtonState = digitalRead(btn_pin);
  if (ButtonState != ButtonLastState) {
    if (ButtonState == 0)
    {
      digitalWrite(r_pin, HIGH);
      digitalWrite(g_pin, HIGH);
      digitalWrite(b_pin, HIGH);
      ButtonCounter++;
    }
  }
  if (ButtonCounter != 0) {
    switch (ButtonCounter) {
      case 1:
        if (isSend == 0) {
          Serial.println(modi[0]);
          incomingByte = Serial.read();
          //Blinken bis Rückmeldung
          while (incomingByte != 1) {
            digitalWrite(r_pin, (millis() % (onZeit + offZeit)) < onZeit);
            incomingByte = Serial.read();
          }
          digitalWrite(r_pin, LOW);
          isSend = 1;
        }
        break;
      case 2:
        if (isSend == 1) {
          Serial.println(modi[1]);
          incomingByte = Serial.read();
          //Blinken bis Rückmeldung
          while (incomingByte != 2) {
            digitalWrite(g_pin, (millis() % (onZeit + offZeit)) < onZeit);
            incomingByte = Serial.read();
          }
          digitalWrite(g_pin, LOW);
          isSend = 2;
        }
        break;
      case 3:
        if (isSend == 2) {
          Serial.println(modi[2]);
          incomingByte = Serial.read();
          //Blinken bis Rückmeldung
          while (incomingByte != 3) {
            digitalWrite(b_pin, (millis() % (onZeit + offZeit)) < onZeit);
            incomingByte = Serial.read();
          }
          digitalWrite(b_pin, LOW);
          isSend = 3;
        }
        break;
      default:
        ButtonCounter = 0;
        isSend = 0;
    }
  }
  else {
    digitalWrite(r_pin, HIGH);
    digitalWrite(g_pin, HIGH);
    digitalWrite(b_pin, HIGH);
  }
  ButtonLastState = ButtonState;
  delay(10);
}

Ich bedanke mich schonmal im Vorraus und hoffe das ihr mir da helfen könnt. Mir fehlt leider kompett der Ansatz.

eigentlich hast eh fast alles, du musst das nur ein wenig auftrennen.

wähle mit Tastendruck deinen NextModus.
Erst wenn du z.B. 5 Sekunden keine Taste mehr gedrückt hast, schickst du den NextModus wirklich los.
Wenn das Gerät bestätigt hat, schaltest du das blinken ab.

Eigentlich eine State Machine mit 6 Status:

Modus1Blinken
Modus1
Modus2Blinken
Modus2
Modus3Blinken
Modus3

reicht das als Ansatz oder brauchst mehr?

1 Like

Danke für deinen Ansatz,
ich überlege mir gerade die Umsetzung. Habe mein Arduino erst seit Freitag. State Machine ist mir aber aus VHDL bekannt.

Ich frage mich, wofür du die while-Schleife benötigst.
Aus meiner sich ist das sehr blockierend und nicht zielführend. Zumal du mehrfach die Serielle abfragst, was normal besser direkt in der loop passieren sollte.
Wenn du mal eine gute Beschreibung zu deinem Sketch abgeben könntest, würde ich es evtl. auch verstehen.

das geht, aber das Bedienkonzept ist nicht optimal.
man kann zwar die Modus um 1, 2 oder 3 weiterschalten, aber man merkt es erst nach 3 Sekunden ob man "oft genug" gedrückt hat, weil erst dann das geblinke losgeht.
auch nicht gut.
Vieleicht bei der Vorauswahl die Vorauswahl mittels PWM schon auf 50% setzen?

Das ist mein Test:

Achtung, ich verwende andere Buttons und eine schnellere Serielle.
Wirft zwar ein Warning wegen dem Switch, aber das ist nicht all zu böse.

/*
  1 Buttons - 3 LED

  The circuit:
  - pushbuttons attached from pin to GND
  - LED attached from GPIO to ground

  https://forum.arduino.cc/t/wahrend-while-schleife-buttonstatus-abfragen/891593

  by noiasca

  2021-08-02
*/

// constants won't change. They're used here to set pin numbers
const byte button1Pin = A1;
const byte led1Pin = 2;
const byte led2Pin = 3;
const byte led3Pin = 4;

class Button                   // eine Klasse für Buttons
{
    const byte buttonPin;
    const byte debounceDelay = 50;    // the debounce time; increase if the output flickers
    bool lastButtonState = HIGH;      // the previous reading from the input pin
    uint32_t lastDebounceTime = 0;        // the last time the output pin was toggled - we check only ONE byte
    uint32_t lastPress = 0;

  public:
    Button(byte buttonPin) : buttonPin(buttonPin) {}

    void begin() {
      pinMode(buttonPin, INPUT_PULLUP);
    }

    uint32_t getLastPress()
    {
      return lastPress;
    }

    // returns HIGH if button was clicked since last call - debounce
    bool wasPressed() {
      bool buttonState = LOW;                  // the current reading from the input pin
      byte reading = LOW;
      if (digitalRead(buttonPin) == LOW) reading = HIGH;              // if we are using INPUT_PULLUP we are checking invers to LOW Pin
      if (millis() - lastDebounceTime > debounceDelay)           // If the switch changed, AFTER any pressing or noise
      {
        if (reading != lastButtonState && lastButtonState == LOW)     // If there was a change and and last state was LOW
        {
          buttonState = HIGH;
          //Serial.print(F("D52 pressed pin")); Serial.println(buttonPin);
          lastPress = millis();
        }
        lastDebounceTime = millis();
        lastButtonState = reading;
      }
      return buttonState;
    }
};

class LED                   // eine Klasse für LEDs
{
    const byte ledPin;
    byte lastButtonState = 0;           // the previous reading from the input pin
    uint32_t previousMillis = 0;        // the last time the output pin was toggled - we check only ONE byte
    enum State {OFF, ON, BLINK} state;

  public:
    LED(byte ledPin) : ledPin(ledPin) {}

    void begin()
    {
      pinMode(ledPin, OUTPUT);
    }

    void blink()
    {
      state = BLINK;
    }

    void on()
    {
      state = ON;
      digitalWrite(ledPin, HIGH);
    }

    void off()
    {
      state = OFF;
      digitalWrite(ledPin, LOW);
    }

    void run()
    {
      if (state == BLINK)
      {
        if (millis() - previousMillis > 500)
        {
          previousMillis = millis();
          if (digitalRead(ledPin) == LOW)
            digitalWrite(ledPin, HIGH);
          else
            digitalWrite(ledPin, LOW);
        }
      }
    }
};

enum class State {MODE1BLINK, MODE1, MODE2BLINK, MODE2, MODE3BLINK, MODE3} state, nextState;

const char *modi[] = {"Modus 1", "Modus 2", "Modus 3"}; // Befehl für Ansteuerung

Button button1{button1Pin};
LED led1{led1Pin};
LED led2{led2Pin};
LED led3{led3Pin};

void action()    // Vorauswahl
{
  switch (nextState)
  {
    case State::MODE1 :
    case State::MODE1BLINK :
      nextState = State::MODE2BLINK;
      //Serial.println("D2 Vorauswahl");
      break;
    case State::MODE2 :
    case State::MODE2BLINK :
      nextState = State::MODE3BLINK;
      //Serial.println("D3 Vorauswahl");
      break;
    case State::MODE3 :
    case State::MODE3BLINK :
      nextState = State::MODE1BLINK;
      //Serial.println("D1 Vorauswahl");
      break;
  }
}

void runFSM()
{
  if (state != nextState && millis() - button1.getLastPress() > 3000)  // wenn der letzte Tastendruck lang genug zurück liegt
  {
    state = nextState;
    switch (state)
    {
      case State::MODE1BLINK :
        led1.blink();
        led2.off();
        led3.off();
        Serial.print(modi[0]);
        break;
      case State::MODE2BLINK :
        led1.off();
        led2.blink();
        led3.off();
        Serial.print(modi[1]);
        break;
      case State::MODE3BLINK :
        led1.off();
        led2.off();
        led3.blink();
        Serial.print(modi[2]);
        break;
    }
  }
  if (state == State::MODE1BLINK || state == State::MODE2BLINK || state == State::MODE3BLINK)
  {
    if (Serial.available())
    {
      char c = Serial.read();
      switch (c)
      {
        case '1' :
          //Serial.println(F("bestätigt 1"));
          led1.on();
          led2.off();
          led3.off();
          state = State::MODE1;
          break;
        case '2' :
          //Serial.println(F("bestätigt 2"));
          led1.off();
          led2.on();
          led3.off();
          state = State::MODE2;
          break;
        case '3' :
          //Serial.println(F("bestätigt 3"));
          led1.off();
          led2.off();
          led3.on();
          state = State::MODE3;
          break;
      }
      nextState = state;
    }
  }
}

void setup() {
  Serial.begin(115200);
  //Serial.println(F("1 Button - 3 LED"));
  button1.begin();
  led1.begin();
  led2.begin();
  led3.begin();

  // initialwerte setzen damit am Anfang irgendwas aktiv wird?
  led1.blink();
  Serial.print(modi[0]);
  state = State::MODE1BLINK;
  nextState = state;
}

void loop() {
  if (button1.wasPressed()) action();
  led1.run();
  led2.run();
  led3.run();
  runFSM();
}

Paar Worte zur Erklärung:
eine Klasse für den Button,
eine Klasse für die 3 LEDs
eine Funktion für die FSM
eine Funktion für die Vorauswahl

könnte man natürlich in ein Struct-Array auch zusammenkürzen, aber ich hab mir gedacht so ist es leichter lesbar...

ps. noch etwas

wenn da wirklich ein 0x01 und kein ASCII 1 vom Device zurück kommt, dann müsstest du den Switch Case bei mir anpassen und statt '1' halt auf 1 abfragen - aber sonst habe ich das auf die Schnelle mit dem Seriellen Monitor nicht testen können...

jetzt habe ich eine Idee, man könnte den Vorgewählten Modus kurz aufleuchten lassen (FLASH), damit der Anwender weis wie offt er gedrückt hat.
Eigentlich nur eine Kleinigkeit: ein weiterer LED Status, eine neue member Function zum Aufrufen das wars:

/*
  1 Buttons - 3 LED

  The circuit:
  - pushbuttons attached from pin to GND
  - LED attached from GPIO to ground

  https://forum.arduino.cc/t/wahrend-while-schleife-buttonstatus-abfragen/891593

  by noiasca

  2021-08-02
*/

// constants won't change. They're used here to set pin numbers
const byte button1Pin = A1;
const byte led1Pin = 3;        // UNO PWM Pins are 3, 5, 6, 9, 10, 11
const byte led2Pin = 5;
const byte led3Pin = 6;

class Button                   // eine Klasse für Buttons
{
    const byte buttonPin;
    const byte debounceDelay = 50;    // the debounce time; increase if the output flickers
    bool lastButtonState = HIGH;      // the previous reading from the input pin
    uint32_t lastDebounceTime = 0;    // the last time the output pin was toggled - we check only ONE byte
    uint32_t lastPress = 0;           // wenn was the button pressed the last time

  public:
    Button(byte buttonPin) : buttonPin(buttonPin) {}

    void begin() {
      pinMode(buttonPin, INPUT_PULLUP);
    }

    uint32_t getLastPress()
    {
      return lastPress;
    }

    // returns HIGH if button was clicked since last call - debounce
    bool wasPressed() {
      bool buttonState = LOW;                  // the current reading from the input pin
      byte reading = LOW;
      if (digitalRead(buttonPin) == LOW) reading = HIGH;              // if we are using INPUT_PULLUP we are checking invers to LOW Pin
      if (millis() - lastDebounceTime > debounceDelay)           // If the switch changed, AFTER any pressing or noise
      {
        if (reading != lastButtonState && lastButtonState == LOW)     // If there was a change and and last state was LOW
        {
          buttonState = HIGH;
          //Serial.print(F("D52 pressed pin")); Serial.println(buttonPin);
          lastPress = millis();
        }
        lastDebounceTime = millis();
        lastButtonState = reading;
      }
      return buttonState;
    }
};

class LED                   // eine Klasse für LEDs
{
    const byte ledPin;
    byte lastButtonState = 0;           // the previous reading from the input pin
    uint32_t previousMillis = 0;        // the last time the output pin was toggled - we check only ONE byte
    enum State {OFF, ON, BLINK, FLASH} state;  // this LED can be off, on or blink

  public:
    LED(byte ledPin) : ledPin(ledPin) {}

    void begin()
    {
      pinMode(ledPin, OUTPUT);
    }

    void blink()
    {
      state = BLINK;
    }

    void on()
    {
      state = ON;
      digitalWrite(ledPin, HIGH);
    }

    void off()
    {
      state = OFF;
      digitalWrite(ledPin, LOW);
    }

    void flash()
    {
      if (state == OFF)
      {
        state = FLASH;
        digitalWrite(ledPin, HIGH);
        previousMillis = millis();
      }
    }

    void run()
    {
      if (state == BLINK)
      {
        if (millis() - previousMillis > 500)
        {
          previousMillis = millis();
          if (digitalRead(ledPin) == LOW)
            digitalWrite(ledPin, HIGH);
          else
            digitalWrite(ledPin, LOW);
        }
      }
      if (state == FLASH)
      {
        if (millis() - previousMillis > 200)
        {
          digitalWrite(ledPin, LOW);
          state = OFF;
        }
      }
    }
};

enum class State {MODE1BLINK, MODE1, MODE2BLINK, MODE2, MODE3BLINK, MODE3} state, nextState;

const char *modi[] = {"Modus 1", "Modus 2", "Modus 3"}; // Befehl für Ansteuerung

Button button1{button1Pin};
LED led1{led1Pin};
LED led2{led2Pin};
LED led3{led3Pin};

void action()    // Vorauswahl
{
  switch (nextState)
  {
    case State::MODE1 :
    case State::MODE1BLINK :
      nextState = State::MODE2BLINK;
      led2.flash();
      //Serial.println("D2 Vorauswahl");
      break;
    case State::MODE2 :
    case State::MODE2BLINK :
      nextState = State::MODE3BLINK;
      led3.flash();
      //Serial.println("D3 Vorauswahl");
      break;
    case State::MODE3 :
    case State::MODE3BLINK :
      nextState = State::MODE1BLINK;
      led1.flash();
      //Serial.println("D1 Vorauswahl");
      break;
  }
}

void runFSM()                                                          // the finite state machine
{
  if (state != nextState && millis() - button1.getLastPress() > 3000)  // we have a new nextState an enouh time has passed
  {
    state = nextState;
    switch (state)
    {
      case State::MODE1BLINK :
        led1.blink();
        led2.off();
        led3.off();
        Serial.print(modi[0]);
        break;
      case State::MODE2BLINK :
        led1.off();
        led2.blink();
        led3.off();
        Serial.print(modi[1]);
        break;
      case State::MODE3BLINK :
        led1.off();
        led2.off();
        led3.blink();
        Serial.print(modi[2]);
        break;
      // there is nothing to do in the following States
      // therefore we list them explicit, otherwise GCC will throw a warning.
      case State::MODE1 :
      case State::MODE2 :
      case State::MODE3 :
        break;
    }
  }
  if (state == State::MODE1BLINK || state == State::MODE2BLINK || state == State::MODE3BLINK)
  {
    if (Serial.available())
    {
      char c = Serial.read();
      switch (c)
      {
        case '1' :
          //Serial.println(F("bestätigt 1"));
          led1.on();
          led2.off();
          led3.off();
          state = State::MODE1;
          break;
        case '2' :
          //Serial.println(F("bestätigt 2"));
          led1.off();
          led2.on();
          led3.off();
          state = State::MODE2;
          break;
        case '3' :
          //Serial.println(F("bestätigt 3"));
          led1.off();
          led2.off();
          led3.on();
          state = State::MODE3;
          break;
      }
      nextState = state;
    }
  }
}

void setup() {
  Serial.begin(115200);
  //Serial.println(F("1 Button - 3 LED"));
  button1.begin();
  led1.begin();
  led2.begin();
  led3.begin();

  // initialwerte setzen damit am Anfang irgendwas aktiv wird?
  led1.blink();
  Serial.print(modi[0]);
  state = State::MODE1BLINK;
  nextState = state;
}

void loop() {
  if (button1.wasPressed()) action();
  led1.run();
  led2.run();
  led3.run();
  runFSM();
}

p.s. und das Warning ist auch weg.

Die class für die Buttons ist natürlich Klasse, aber bedenkt, der TO hat seinen Arduino erst seit wenigen Tagen.

wenn jemand in der Lage ist sowas hinzuschreiben,

digitalWrite(g_pin, (millis() % (onZeit + offZeit)) < onZeit);

dann gibts keine Schonfrist mehr :wink:

Übrigens ist die Button Klasse nur ein umgesetztes "Debounce" Beispiel aus der IDE.

Das ist echt etwas viel für mich :smiley: aber durch dein Code kann ich glaube viel lernen.
Vielen Dank dafür.
Ich habe dein Code mal hochgeladen, Pins natürlich durch meine ersetzt, und sobald das Hochladen beendet ist, fangen die LEDs des Buttons wild an zu blinken.

Aber ich bin echt begeistert was so alles Möglich ist mit diesen kleinen Gerät, kenne Klassen aus PHP und C

C hat sowas nicht.
Du meinst sicherlich C++.
Arduino ist in erster Line C++11.

Ja genau, C++. Ist schon mindestens 5 Jahre her, dann darf man sich vertun.

Ja, dann ist doch hier eine gute Gelegenheit, für noch eine Runde C++.

1 Like

also eigentlich soll nur eine Blinken, nämlich jene die im Setup auf blink gesetzt wird.
Sobald dann der Partner auf der Serial was passendes zurückschickt, soll EINE LED leuchten.

wildes Geblinke soll eigentlich nicht entstehen.

fang mit der FSM an ... versuche den Ablauf zu verstehen. Wenn du Fragen hast - frag.

1 Like

Werde ich auf jeden Fall machen.
Ich habe gestern noch an meinem Code weitergemacht, allerdings habe ich aktuell immer Fehler beim einlesen. Ich sende eine "1" über den Seriellen Monitor und er ließt komischerweise kurz eine 49 ein und dann 10.

12:53:03.839 -> 49
12:53:03.839 -> 10
12:53:03.872 -> 10
12:53:03.872 -> 10

Merkwürdig ist, ich gebe eine 1 ein bekomme 49
2 -> 50
3 -> 51

und danach ist in incomingByte (int) eine 10 gespeichert

const uint16_t onZeit  = 400; //ms
const uint16_t offZeit = 400; //ms
int incomingByte = 0;

int r_pin = 11; // Rote LED Pin
int g_pin = 10; // Grüne LED PIN
int b_pin = 9;  // Blaue LED PIN
int btn_pin = A1; // Pin für den Taster ( modi )
// int btn_onoff_pin = 8; // Pin für Ein/Aus
int nextMod = 1;
char *modi[] = {"Modus 1", "Modus 2", "Modus 3"}; // Befehl für Ansteuerung


int ButtonState = 1;
int ButtonCounter = 0;
int ButtonLastState = 0;

void setup() {
  Serial.begin(9600);
  pinMode(btn_pin, INPUT_PULLUP);
  pinMode(r_pin, OUTPUT);
  pinMode(g_pin, OUTPUT);
  pinMode(b_pin, OUTPUT);
}

void loop() {
  if(nextMod == 1){
    ButtonState = digitalRead(btn_pin);
  }
  if (ButtonState != ButtonLastState) {
    if (ButtonState == 0)
    {
      digitalWrite(r_pin, HIGH);
      digitalWrite(g_pin, HIGH);
      digitalWrite(b_pin, HIGH);
      ButtonCounter++;
    }
  }
  if (ButtonCounter != 0) {
    if (Serial.available() > 0) {
      incomingByte = Serial.read();
    }
    switch (ButtonCounter) {
      case 1:
          if(incomingByte != 1){
            digitalWrite(r_pin, (millis() % (onZeit + offZeit)) < onZeit);
          }
          else{
            digitalWrite(r_pin, LOW);
            nextMod = 1;
          }
          
        break;
      case 2:
          //Serial.println(modi[1]);
          if(incomingByte != 2){
            digitalWrite(g_pin, (millis() % (onZeit + offZeit)) < onZeit);
          }
          else{
            digitalWrite(g_pin, LOW);
          }
        break;
      case 3:
          //Serial.println(modi[2]);
          if(incomingByte != 3){
            digitalWrite(b_pin, (millis() % (onZeit + offZeit)) < onZeit);
          }
          else{
            digitalWrite(b_pin, LOW);
          }
        break;
      default:
        ButtonCounter = 0;
        nextMod = 1;
    }

    if(incomingByte != 0){
      Serial.println(incomingByte);
    }
    
  }
  else {
    digitalWrite(r_pin, HIGH);
    digitalWrite(g_pin, HIGH);
    digitalWrite(b_pin, HIGH);
  }
  ButtonLastState = ButtonState;
  delay(10);
}

Ich habe es jetzt soweit, dass die While Schleife rausgeflogen ist und ich auch während des Blinkens weiter Schalten kann. Jetzt wollte ich es so machen, dass nach 5000ms das Signal gesendet wird und NextMod auf 0 gesetzt wird. Wenn dann das Signal zurück kommt, dass der Modus geschaltet wurde, wird NextMod wieder auf 1 gesetzt.

Du solltest Dir mal eine ASCII-Tabelle anschauen.
49 dezimal ist der Code des Zeichens '1' und 10 der vom LineFeed.

Gruß Tommy

Statt die ASCII - Tabelle zu lernen, reicht es zu wissen, was man bei Serial.read() zu erwarten hat, und dass man das Eingelesene besser mit '1' statt mit 1 vergleichen sollte, und sich des Unterschieds der beiden bewusst zu sein. Und dass evtl. auch andere Zeichen (z.B. NeueZeile = '\n'), aber selten normalerweise keine 0 gelesen wird.

Verwechselst Du ansehen mit lernen?

Gruß Tommy

Zumindest Teile sollte man aus dem EffEff zitieren können!
Also lernen, auswendig lernen.

Eigentlich braucht man sich ja für den Hauptteil Ziffern (0x30) und Buchstaben (0x41 und 0x61) nur die Anfänge zu merken und evtl. ein paar Sonderzeichen. Wobei ich CR und LF gern verwechsle :wink:

Gruß Tommy

Auswendig lernen braucht man nicht: wenn man sich damit beschäftigt (@Tommy56's "Ansehen")
merkt man, und wird kaum wieder vergessen,

  • dass '0' .. '9' aufeinanderfolgen,
  • dass die deutschen Umlaute gar nicht drin vorkommen,
  • dass A..Z und a..z in der gleichen (und üblichen Sortier-) Reihenfolge aufeinanderfolgen
    (und sich nur um 1 bit unterscheiden).

Zum eigenen einfacheren Code-Verständnis sollte man statt des Dezimal- oder Hex-Codes immer die Literal-Schreibweise verwenden ( Also 'A' statt 65 oder 0x41 )