Gesicherte Funkbefehle mit 2,4 GHz nRF24L01+ Transceiver bei Übertragung von Schaltbefehlen

>>>>>>>>>> Auch als Library "MySecureSend" zum Testen <<<<<<<<<<

Mit nachfolgendem Beispiel möchte ich für meine Eigenbauprojekte die Funkübertragung von Schaltbefehlen (z.B. von einem Handsender zu einer Alarmanlage oder einer Torsteuerung oder der Steuerung einer Beleuchtungsanlage) sicherer machen. Eine zufällige Funksequenz eines fremden Senders oder eine bewusste, jedoch unbefugte und nicht autorisierte Funksequenz, die durch Ausspionieren von Funksignalen ermittelt wurde, darf unter keinen Umständen zu einem Schaltbefehl (z.B. dem Öffnen eines Tores oder dem Abschalten einer Alarmanlage) führen. Wobei es hier aber nicht um Verschlüsseln von Informationen geht. Es geht vielmehr darum, dass z.B. ein gesendeter Befehl, wie "Alarmanlage AUS" vom Empfänger nur dann angenommen und ausgeführt wird, wenn ein zusätzlich gesendeter Prüfwert, der sowohl im Sender, als auch im Empfänger ermittelt wird, übereinstimmen. Und dieser Prüfwert ist für jede Befehlsausführung unterschiedlich. Also auch jedes Mal beim Senden von z.B. "Anlage AUS", wird immer ein unterschiedlicher Prüfwert ermittelt und gesendet, so dass das "Ausspionieren" von Schaltbefehlen sinnlos ist.


Testaufbau:

Anschlussbelegung des 2,4 GHz nRF24L01+ Transceiver-Moduls:

Zur Verwendung direkt auf einem Steckbrett ist der nRF24L01+ durch seine doppelreihige Anschluss-Stiftleiste nicht geeignet. Also entweder über ein 8-poliges Kabel verbinden oder - wie im nachfolgenden Bild 1 gezeigt - durch Adaptierung auf eine einreihige Stiftleiste z.B. mit Hilfe einer kleinen Streifenrasterplatine.

                                                                fritzing

Bild 1: (li) Anschlussbelegung des nRF24L01+ und (re) mit Adaptierung auf einreihige Stiftleiste


Verbindung mit dem Arduino Nano:

nRF24L01+ PIN         Arduino Nano-Pin

   1   GND          ->       GND

   2   VCC          ->       3,3 V

   3   CE             ->       D9   (im Programm konfigurierbar)

   4   CSN           ->       D10 (im Programm konfigurierbar)

   5   SCK           ->       D13 (nicht konfigurierbar - SPI-Schnittstelle des Arduino)              

   6   MOSI         ->       D11 (nicht konfigurierbar - SPI-Schnittstelle des Arduino)   

   7   MISO         ->       D12 (nicht konfigurierbar - SPI-Schnittstelle des Arduino)   

   8   IRQ           ->        im Testaufbau nicht benutzt


Hinweis: Obwohl die Versorgungsspannung des Moduls mit 1,9 - 3,3 V angeben ist, sind laut Datenblatt des nRF24L01+ Chip die Pins der SPI-Schnittstelle 5V-tolerant. Dadurch ist die Verwendung von Logic-Level-Convertern nicht erforderlich!

Datenblatt siehe unter: www.sparkfun.com/datasheets/Components/SMD/nRF24L01Pluss_Preliminary_Product_Specification_v1_0.pdf


Verwendete Bauteile je für Sender und Empfänger:

  • 1 Arudino Nano
  • 1 nRF24L01+ (2,4 GHz Transceiver Modul)
  • 1 EEPROM 24LC512 (512 kBit, I2C-Schnittstelle)
  • 2 Widerstände 10 kOhm
  • 1 Elko 10 uF
  • 1 LED
  • 1 Widerstand 470 Ohm

  •   Aufbau zweimal:

    Sender und Empfänger bestehen im Wesentlichen je aus einem Arduino Nano, einem 2.4 GHz Transceiver Modul und einem 512 kBit (= 64 kByte) EEPROM mit I2C-Schnittstelle (I2C-Adresse verdrahtet auf 0x50). Beide sind zusätzlich noch mit einer LED ausgestattet, die beim Empfänger mit dem Testprogramm über Funk ein- und ausgeschaltet werden soll und beim Sender anzeigt, ob ein gesendeter Befehl vom Empfänger bestätigt wurde (2 Sekunden Dauerleuchten) oder ein Übertragungsfehler vorliegt (2 Sekunden blinken). Die EEPROMS des Senders und Empfängers sind identisch und sind beide mit je 65.536 Zufallszahlen, wobei jede Zufallszahl zwischen 1 und 255 betragen kann, programmiert.

    Die Programmierung der EEPROMs mit Zufallszahlen kann mit meinem EEPROM-Monitor, mit den Funktionen "Schreibe Zufallszahlen oder -zeichen auf EEPROM" und "Kopiere EEPROM auf EEPROM" erfolgen. Um sicher zu gehen, dass die Inhalte der beiden EEPROMs wirklich identisch sind, kann das mit der Funktion "Vergleiche EEPROMs" überprüft werden. Natürlich können zum Testen auch EEPROMs mit weniger Speicherplatz verwendet werden, die Speichergröße ist dann nur jeweils im Sender- und Empfängertestprogramm anzupassen.


    Beschreibung des Testprogramms:

    Wie man ein Sende-Telegramm aufbauen kann, um z.B. unterschiedliche Funktionen, wie z.B. "Motor1 EIN" oder "Servo2 Stellung x", dem Empfänger mitzuteilen, habe ich bei meiner Funkfernsteuerung unter Telegrammaufbau bereits gezeigt. Deshalb beschränke ich mich im nachfolgenden Beispiel auf das EIN- und AUS-Schalten einer LED. Dabei sendet der Sender für einen "EIN"-Befehl ein "E" und für einen "AUS"-Befehl ein "A" (Eingabe erfolgt über den Seriellen Monitor) an den Empfänger.

    Kommt der Befehl beim Empfänger an, werden über einen Zufallszahlengenerator 6 EEPROM-Adressen A1-A6 zwischen 0 und 65.535 (bei Verwendung eines 512kBit EEPROMs) ermittelt und an den Sender zurückgesendet. Sowohl der Sender, als auch der Empfänger lesen anschließend aus den jeweiligen EEPROMs die Inhalte der Adressen A1-A6 aus (die ja bei beiden EEPROMs identisch sein müssen) und erhalten so jeweils 6 Werte D1-D6, die zwischen 1 und 255 betragen. Sender und Empfänger errechnen nun jeweils z.B. aus 4 der 6 Werte D1-D6 einen Prüfwert1, der Sender den Prüfwert PW1S und der Empfänger den Prüfwert PW1E. Die Berechnungsformel ist für Sender und Empfänger natürlich gleich, wobei die die einzelnen Werte miteinander addiert und multipliziert werden, also z.B. Prüfwert1 = (D1+D2)*(D1+D3)*(D3+D4). Wichtig bei der Erstellung der Formel ist, dass das größtmöglicher Ergebnis der Formel (wenn jeder einzelne Wert gleich 255 ist) den Wertebereich einer "unsigned long"-Variable nicht überschreitet, also kleiner 4.294.967.296 (= 2^32) ist.

    Der Sender sendet nun den Prüfwert PW1S an den Empfänger, dieser vergleicht die Prüfwerte PW1S und PW1E. Sind die Prüfwerte identisch, wird der Schaltbefehl (im Beispiel EIN oder AUS) durchgeführt, bei Ungleichheit wird der Schaltbefehl ignoriert. Um nun dem Sender zurück zu melden, dass der Schaltbefehl angekommen und ausgeführt wurde, oder eben nicht, wird im Fall der Gleichheit der Prüfsummen1 eine weitere Prüfsumme2, also von Empfänger die Prüfsumme PW2E, und vom Sender die Prüfsumme PW2S ermittelt. Diese werden wiederum jeweils aus z.B. 4 der 6 Werte D1-D6 gebildet, z.B. Prüfwert2 = (D3+D4)*(D3+D5)*(D5+D6). Die vom Empfänger berechnete Prüfsumme PW2E wird nun an Sender gesendet und dieser vergleicht nun die beiden Prüfsummen PW2E und PW2S. Konnte der Schaltbefehl wegen Ungleichheit der Prüfsummen1 nicht ausgeführt werden, wird als Prüfsumme2 die Zahl "0" vom Empfänger an den Sender gesendet. Sind die Prüfsummen PWE2 und PWS2 vom Sender als gleich erkannt, zeigt er das durch Leuchten der LED an, wenn nicht, blinkt die LED des Senders.

    Im nachfolgenden Bild 2 ist der Ablauf des Programms noch einmal graphisch dargestellt:

     

    Bild 2: Graphische Darstellung des Programmablaufs

    Und wie schon vorhergehend gesagt: Der Vorteil dieses Verfahrens ist aus meiner Sicht, dass ein Ausspionieren eines Funkbefehles praktisch sinnlos ist, weil durch das Zufallszahlenprinzip bei jedem gesendeten Befehl, immer andere Prüfwerte gebildet werden. Und da auch nur die Speicheradressen A1-A6 und die berechneten Prüfwerte am Funkweg übertragen werden und niemals die Speicherinhalte D1- D6 und auch die Formeln zur Prüfwertbildung einem Dritten nicht bekannt sind, so gehe ich davon aus, ist es praktisch fast nicht möglich, den Inhalt der EEPROMs nachzuvollziehen. Gerne lasse ich mich aber vom Gegenteil überzeugen.

    Testprogramme:

    Nachfolgend nun die beiden Testprogramme für Sender und Empfänger.

    Funktionen:

    Über den Seriellen Monitor (Einstellung 115200 Baud, "Kein Zeilenende") des Senders können die Befehle

    • "E" für EIN und
    • "A" für AUS

    vorgegeben werden und bei funktionierender Kommunikation mit dem Empfänger erhält man nachfolgendes Ablaufprotokoll:

    Bild 3: Serieller Monitor des Senders


    Läuft die Kommunikation zwischen Sender und Empfänger problemlos, erhält man auch beim Seriellen Monitor des Empfängers (Einstellung ebenfalls 115200 Baud, "Kein Zeilenende") das nachfolgende Protokoll und die LED am Empfänger-Testaufbau wird ein- bzw. ausgeschaltet:

    Bild 4: Serieller Monitor des Empfängers


    Verwendete Libraries:

    Neben der Standard-Library SPI werden noch folgende Libraries benötigt:

    • RF24: Zur Steuerung der nRF24L01+ Transceiver-Module. Einen Link zu RF24-Library und zu ihrer Beschreibung findet ihr hier: Fremd-Libraries
    • MyEEPROM_I2C: Zur Kommunikation mit den EEPROMs. Meine Library kann hier heruntergeladen werden: I2C-EEPROM


    EEPROM-Größe:

    Wird ein EEPROM mit weniger Speicherplatz als 512 kByte verwendet, ist dies sowohl beim Sender, als auch beim Empfänger jeweils in der Befehlszeile

    #define eepromGroesse 512 //EEPROM-Groesse in kBit

    anzupassen.

    Achtung: EEPROMs mit mehr als 512 kBit (= 64 kByte) werden von der Library MyEEPROM_I2C nicht unterstützt!


    Sendeleistung:

    Die Sendeleistung wird in beiden Programmen jeweils mit der Befehlszeile

    Radio.setPALevel(RF24_PA_MIN); //Sendeleistung auf minimale Stufe

    auf minimale Leistung begrenzt. Der Grund ist, dass die Transceiver-Module über die Arduino Nanos mit Spannung (3,3 V) versorgt werden und daher nur begrenzt Leistung dafür zur Verfügung steht. Bei Versorgung mit einer externen 3,3 V-Spannung kann die Sendeleistung zur Erhöhung der Reichweite durch Änderung des Übergabeparameters für niedrige bis maximale Leistung mit "RF24_PA_LOW", "RF24_PA_MED" oder "RF24_PA_HIGH" geändert werden.


    Testprogramm Sender:

    //Testprogramm RF24-Sender
    //Code fuer Arduino
    //Author Retian
    //Version 2.2


    #include <MyEEPROM_I2C.h>
    #include <SPI.h>
    #include <RF24.h>


    RF24 Radio(9, 10); //9...CE-Pin, 10...CSN-Pin
    MyEEPROM_I2C MyEEPROM;


    //Prototypen
    unsigned long rechnePruefSumme(byte*, byte);


    #define eepromGroesse 512 //EEPROM-Groesse in kBit
    #define ledPin 4 //LED auf Pin4


    byte eeprWert[6];
    long eeprAdresse[6];
    byte incomingByte;
    unsigned long pruefSumme1;
    unsigned long pruefSumme2;
    unsigned long pruefSumme2Empfangen; //Pruefsumme2 vom Empfaenger
    unsigned long startWartezeit;
    bool timeout; //Ueberwachungszeitmerker
    bool pruefSummeFehler;


    void setup() {
      Serial.begin(115200);
      pinMode(ledPin, OUTPUT);
      digitalWrite(ledPin, LOW);
      Radio.begin();
      Radio.setPALevel(RF24_PA_MIN); //Sendeleistung auf minimale Stufe
      Radio.setPayloadSize(24); //Anzahl der gesendeten Bytes pro Telegramm
      Radio.openReadingPipe(1, 0xFEFEF0F0LL); //Oeffnen eines Empfangskanal
      Radio.openWritingPipe(0xFEFEF0F1LL); //Oeffnen eines Sendekanals

      MyEEPROM.init(0x50); //EEPROM I2C-Adresse = 0x50
      MyEEPROM.setSize(eepromGroesse); //Setzen der EEPROM-Groesse
    }

    void loop() {
      timeout = false;
      pruefSummeFehler = false;
      Serial.println("\n*************** Sender **************");
     
      //Warte auf Befehlseingabe vom Seriellen Monitor
      Serial.println("Warte auf Eingabe ...");
      while (!Serial.available());
      incomingByte = Serial.read();
      Serial.print("Eingabe erhalten: ");
      Serial.println((char)incomingByte);

      //Wenn Befehlseingabe ok, dann sende Anweisung
      Radio.stopListening();
      if (incomingByte != 'E' && incomingByte != 'A')
      Serial.println("Falsche Befehlseingabe!");
      else
      {
        Serial.println("Sende Anweisung ...");
        Radio.write(&incomingByte, 1);
        incomingByte = ' '; //Loesche incomingByte


        //Warte auf Antwort vom Empfaenger
        startWartezeit = millis(); //Startzeitpunt Ueberwachungszeit
        Radio.startListening();
        Serial.println("Warte auf EEPROM-Adressen ...");
        while (!Radio.available() && !timeout)
        {
          //Teste auf Zeitueberschreitung
          if (millis() - startWartezeit > 300)
          {
            timeout = true;
            Serial.println("Zeitueberschreitung!");
          }
        }
        //Wenn keine Zeitueberschreitung
        if (timeout == false)
        {
          //Empfange EEPROM-Adressen
          Radio.read(&eeprAdresse, sizeof(eeprAdresse));
          Serial.println("EEPROM-Adressen empfangen:");
          for (byte i = 0; i < 6; i++) Serial.println(eeprAdresse[i]);
          //Ermittle EEPROM-Werte
          Serial.println("Ermittle EEPROM-Werte ...");
          for (byte i = 0; i < 6; i++)
          {
            Serial.print(eeprAdresse[i]);
            Serial.print(": ");
            eeprWert[i] = MyEEPROM.readByte(eeprAdresse[i]);
            Serial.println(eeprWert[i]);
          }
          Radio.stopListening();
         
          //Ermittle Pruefsumme1
          Serial.println("Ermittle Pruefsumme1 ...");
          pruefSumme1 = rechnePruefSumme(eeprWert, 1);
          Serial.print("Pruesumme1: ");
          Serial.println(pruefSumme1);
          Serial.println("Sende Pruefsumme1 ...");
         
          //Sende Pruefsumme an den Empfaenger
          Radio.write(&pruefSumme1, sizeof(pruefSumme1));
         
          //Warte auf Pruefsumme2 vom Empfaenger
          Radio.startListening();
          Serial.println("Warte auf Pruefsumme2 von Empfaenger ...");
          startWartezeit = millis(); //Startzeitpunt Ueberwachungszeit
          while (!Radio.available() && !timeout)
          {
            //Teste auf Zeitueberschreitung
            if (millis() - startWartezeit > 300)
            {
              timeout = true;
              Serial.println("Zeitueberschreitung!");
            }
          }
         
          //Wenn keine Zeitueberschreitung
          if (timeout == false)
          {
            //Empfange Pruefsumme2 vom Empfaenger
            Radio.read(&pruefSumme2Empfangen, sizeof(pruefSumme2Empfangen));
            Radio.stopListening();
           
            //Ermittle Pruefsumme2
            Serial.println("Ermittle Pruefsumme2 ...");
            pruefSumme2 = rechnePruefSumme(eeprWert, 2);
            Serial.print("Pruefsumme2 gerechnet: ");
            Serial.println(pruefSumme2);
            Serial.print("Pruefsumme2 empfangen: ");
            Serial.println(pruefSumme2Empfangen);
            Serial.println("Vergleiche Pruefsummen ...");
           
            //Vergleiche Pruefsummen
            if (pruefSumme2Empfangen == pruefSumme2)
            {
              Serial.println("Pruefsummen2 ok!");
              //LED fuer 2 Sekunden einschalten
              unsigned long ledStartTime = millis();
              while (millis() - ledStartTime < 2000)
              {
                digitalWrite(ledPin, HIGH);
              }
              digitalWrite(ledPin, LOW);
            }
            else
            {
              pruefSummeFehler = true;
              Serial.println("Pruefsummenfehler!");
            }
          }
        }


        //Wenn Zeitueberschreitung oder Pruefsummenfehler
        //LED 2 Sekunden blinken mit 20 Hz
        if (timeout || pruefSummeFehler)
        {
          unsigned long ledStartTime = millis();
          while (millis() - ledStartTime < 2000)
          {
            digitalWrite(ledPin, !digitalRead(ledPin));
            delay(50);
          }
          digitalWrite(ledPin, LOW);
        }
      }
    }

    //Pruefsummenberechnung
    unsigned long rechnePruefSumme(byte* eeWert, byte auswahl)
    {
      unsigned long sum1;
      unsigned long sum2;
      unsigned long sum3;
      unsigned long pruefSumme;


      //Pruefsumme1
      if (auswahl == 1)
      {
        sum1 = eeWert[0] + eeWert[1];
        sum2 = eeWert[1] + eeWert[2];
        sum3 = eeWert[2] + eeWert[3];
        pruefSumme = (unsigned long)(sum1 * sum2);
        pruefSumme = pruefSumme * sum3;
      }
      
      //Pruefsumme2
      else if (auswahl == 2)
      {
        sum1 = eeWert[0] + eeWert[3];
        sum2 = eeWert[1] + eeWert[4];
        sum3 = eeWert[2] + eeWert[5];
        pruefSumme = (unsigned long)(sum1 * sum3);
        pruefSumme = pruefSumme * sum2;
      }

      return pruefSumme;
    }   


    Testprogramm Empfänger:

    //Testprogramm RF24-Empfaenger
    //Code fuer Arduino
    //Author Retian
    //Version 2.2


    #include <MyEEPROM_I2C.h>
    #include <SPI.h>
    #include <RF24.h>


    RF24 Radio(9, 10); //9...CE-Pin, 10...CSN-Pin
    MyEEPROM_I2C MyEEPROM;


    #define eepromGroesse 512 //EEPROM-Groesse in kBit
    #define ledPin 4 //LED auf Pin4


    byte eeprWert[6];
    long eeprAdresse[6];
    byte anweisung;
    unsigned long pruefSumme1;
    unsigned long pruefSumme2;
    unsigned long pruefSumme1Empfangen; //Pruefsumme1 vom Sender
    bool timeout; //Ueberwachungszeitmerker
    bool pruefSummeFehler;


    void setup() {
      Serial.begin(115200);
      pinMode(ledPin, OUTPUT);
      digitalWrite(ledPin, 0);
      Radio.begin();
      Radio.setPALevel(RF24_PA_MIN); //Sendeleistung auf minimale Stufe
      Radio.setPayloadSize(24); //Anzahl der gesendeten Bytes pro Telegramm
      Radio.openWritingPipe(0xFEFEF0F0LL); //Oeffnen eines Sendekanals
      Radio.openReadingPipe(1, 0xFEFEF0F1LL); //Oeffnen eines Empfangskanal
      randomSeed(analogRead(0));

      MyEEPROM.init(0x50); //EEPROM I2C-Adresse = 0x50
      MyEEPROM.setSize(eepromGroesse); //Setzen der EEPROM-Groesse
    }


    void loop() {
      timeout = false;
      pruefSummeFehler = false;
      Serial.println("\n************* Empfaenger *************");


      //Warte auf Anweisung vom Sender
      Serial.println("Warte auf Anweisung ...");
      Radio.startListening();
      do {}
      while (!Radio.available());
      Radio.read(&anweisung, 1);
      Serial.print("Anweisung empfangen: ");
      Serial.println((char)anweisung);
      Radio.stopListening();


      //Wenn Anweisung ok, ermittle Zufalls-EEPROM-Adressen
      if (anweisung == 'E' || anweisung == 'A')
      {
        Serial.println("Ermittle Zufalls-EEPROM-Adressen:");
        for (byte i = 0; i < 6; i++)
        {
          eeprAdresse[i] = random(0, MyEEPROM.eepromSizeBit / 8);
          Serial.println(eeprAdresse[i]);
        }


        //Sende EEPROM-Adressen an Sender
        Serial.println("Sende EEPROM-Adressen ...");
        Radio.write(&eeprAdresse, sizeof(eeprAdresse));
        //Ermittle EEPROM-Werte
        Serial.println("Ermittle EEPROM-Werte ...");
        for (byte i = 0; i < 6; i++)
        {
          eeprWert[i] = MyEEPROM.readByte(eeprAdresse[i]);
          Serial.print(eeprAdresse[i]);
          Serial.print(": ");
          Serial.println(eeprWert[i]);
        }


        //Ermittle Pruefsumme1
        Serial.println("Ermittle Pruefsumme1 ...");
        pruefSumme1 = rechnePruefSumme(eeprWert, 1);


        //Warte auf Pruefsumme1 vom Sender
        unsigned long startWartezeit = millis(); //Startzeitpunt Ueberwachungszeit
        Radio.startListening();
        Serial.println("Warte auf Pruefsumme1 von Sender ...");
        while (!Radio.available() && !timeout)
        {
          //Teste auf Zeitueberschreitung
          if (millis() - startWartezeit > 300)
          {
            timeout = true;
            Serial.println("Zeitueberschreitung!");
          }
        }
        Radio.stopListening();


        //Wenn keine Zeitueberschreitung
        if (timeout == false)
        {
          Radio.read(&pruefSumme1Empfangen, sizeof(pruefSumme1Empfangen));
          Serial.print("Pruefsumme1 gerechnet: ");
          Serial.println(pruefSumme1);
          Serial.print("Pruefsumme1 empfangen: ");
          Serial.println(pruefSumme1Empfangen);
          Serial.println("Vergleiche Pruefsummen ...");
         
          //Wenn Pruefsummen identisch, fuehre Anweisung aus
          if (pruefSumme1Empfangen == pruefSumme1)
          {
            Serial.println("Pruefsummen ok!");
            if (anweisung == 'E')
            {
              digitalWrite(ledPin, 1);
              Serial.println("Befehl EIN");
            }
            else if (anweisung == 'A')
            {
              digitalWrite(ledPin, 0);
              Serial.println("Befehl AUS");
            }


            //Ermittle Pruefsumme2
            Serial.println("Ermittle Pruefsumme2 ...");
            pruefSumme2 = rechnePruefSumme(eeprWert, 2);
            Serial.print("Pruefsumme2: ");
            Serial.println(pruefSumme2);
            Serial.println("Sende Pruefsumme2 ...");


            //Sende Pruefsumme2 an Sender
            Radio.write(&pruefSumme2, sizeof(pruefSumme2));
          }
          else
          {
            pruefSummeFehler = true;
            Serial.println("Pruefsummenfehler!");
          }
        }


        //Wenn Zeitueberschreitung oder Pruefsummenfehler
        //Sende "0" als Pruefsumme
        if (timeout || pruefSummeFehler)
        {
          pruefSumme2 = 0;
          Serial.print("Pruefsumme2: ");
          Serial.println(pruefSumme2);
          Serial.println("Sende Pruefsumme2 ...");
          Radio.write(&pruefSumme2, sizeof(pruefSumme2));
          Serial.println("gesendet!");
        }
      }
    }


    //Pruefsummenberechnung
    unsigned long rechnePruefSumme(byte* eeWert, byte auswahl)
    {
      unsigned long sum1;
      unsigned long sum2;
      unsigned long sum3;
      unsigned long pruefSumme;


      //Pruefsumme1
      if (auswahl == 1)
      {
        sum1 = eeWert[0] + eeWert[1];
        sum2 = eeWert[1] + eeWert[2];
        sum3 = eeWert[2] + eeWert[3];
        pruefSumme = (unsigned long)(sum1 * sum2);
        pruefSumme = pruefSumme * sum3;
      }


      //Pruefsumme2
      else if (auswahl == 2)
      {
        sum1 = eeWert[0] + eeWert[3];
        sum2 = eeWert[1] + eeWert[4];
        sum3 = eeWert[2] + eeWert[5];
        pruefSumme = (unsigned long)(sum1 * sum3);
        pruefSumme = pruefSumme * sum2;
      }

      return pruefSumme;
    }