Millis in while-Schleife

#include <MD5.h>

#include <SPI.h>

#include <Ethernet.h>

#include <EthernetUdp.h>

#define UDP_TX_PACKET_MAX_SIZE 200

//########################################################################################################################################################################

// Pins definieren ohne Variablendeklaration spart Ressourcen.

#define  pinnull   9

#define  pineins   8

#define  pinzwei   7

#define  pindrei   6

#define  pinvier   5

#define  pinfuenf  4

#define  resetpin  3

#define  absendepin 2

#define  ledgruen  20

#define  ledrot    21

#define  hubmagnet 51

/*#######################################################*/

/*                                                       */

/**/  byte Code[6] = {1, 2, 3, 4, 5, 6}; /* Hier Code Eingeben */

/*                                                       */

/*#######################################################*/

byte Codeeingabe[6]; //Arrays

byte NeuerCode[6];

byte NeuerCode2[6];

//Tasterdeklaration

byte Taster0 = 0; //Die Taster werden mit int definiert da Minuszahlen vorkommen.

byte Taster1 = 0;

byte Taster2 = 0;

byte Taster3 = 0;

byte Taster4 = 0;

byte Taster5 = 0;

byte Taster6 = 0;

byte Taster7 = 0;

byte Taster8 = 0;

byte Taster9 = 0;

byte resetpinstatus = 0;

//Passwort überprüfen

byte rightcode = 0;

byte rightcode3 = 0;

byte absenden = 0;

byte schrittzaehler4 = 0;

byte schrittzaehler3 = 0;

byte schrittzaehler2 = 0;

byte schrittzaehler = 0;

//Neu Programmieren

byte arrayvoll = 0;

byte arrayvoll2 = 0;

byte newcode = 0;

byte schleifenexit1 = 0;

byte schleifenexit2 = 0;

byte rightcode2 = 0;

unsigned long schleifenstartzeit = 0;

unsigned long schleifenendzeit = 0;

unsigned long schleifenbreak = 30000;

//Blinken im Programmiermodus

unsigned long BlinkStarttimer = 0;

unsigned long BlinkEndtimer = 0;

byte ledState = LOW;

//Keypad

#include <Keypad.h>

const byte ROWS = 4; // Vier Reihen

const byte COLS = 3; // Drei Spalten

//Tastenfeld wird definiert

char singlekeys[ROWS][COLS] = {

  {'1', '2', '3'},

  {'4', '5', '6'},

  {'7', '8', '9'},

  {'*', '0', '#'}

};

//Hier werden die einzelnen Reihen mit dem Arduino verbunden. (4)

byte rowPins[ROWS] = { 28, 29, 30, 31 }; //Orange

//Hier werden die einzelnen Spalten mit dem Arduino verbunden. (3)

byte colPins[COLS] = { 22, 23, 24 };  //Grün

// Erstelle das Tasterfeld

Keypad  tasterpad = Keypad( makeKeymap(singlekeys), rowPins, colPins, ROWS, COLS );

#include <EEPROM.h> //Array in Flash speichern

byte EEsize = 6; //Größe des SPeicherbereiches

//########################################################################################################################################################################

//Networking

int udppacket = 0;

int arraygroesse = 0;

char recieveddata[100];

//########################################################################################################################################################################

//Polls

//Servervariablen/Arrays

byte serverpollzeitsize;

char serverpollzeithashbuffer[100];

//Clientvariablen/Arrays

char clienthasharray[100]; //Ein MD5 Hash hat 32 Zeichen, hier von 0-31, die Zeichen 32-34 dient zur Zuordnung des Hashes, die restlichen fuer die Clientzeit

char clientzeitbuffer[100];

boolean pollidstate1 = 0;

boolean pollidstate2 = 0;

boolean pollidstate3 = 0;

//########################################################################################################################################################################

//Verschlüsselung

/*#################################################################*/

/*                                                                 */

/**/  char keyphrase[4] = {'4', '6', '1', '6'}; /* Hier Code Eingeben */

/*                                                                 */

/*#################################################################*/

//########################################################################################################################################################################

//Nicht zugeordnet

byte hashzaehler = 0;

unsigned long clientzeit = 0;

//########################################################################################################################################################################

//Statusupdates

byte openstatus = 0;

byte closestatus = 0;

byte neuprogrammierstatus = 0;

//########################################################################################################################################################################

//Lokale Adresse:

byte clientmac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xEB };

IPAddress clientip(192, 168, 3, 2);

IPAddress clientsubnet(255, 255, 255, 0);

IPAddress gateway(192, 168, 3, 1);

int clientport = 8002; //Lokaler Port

//Serveradresse:

IPAddress serverip(192, 168, 3, 1); //Address to send UDP packe to

IPAddress servergateway(292, 168, 3, 1);

int serverport = 8001;

char packetbuffer[UDP_TX_PACKET_MAX_SIZE]; //Bufferspeicher um Empfangene Pakete bis zur Bearbeitung zu speichern.

EthernetUDP Udp; //Beginnt eine UDP-Instanz

//########################################################################################################################################################################

void setup() {

  Ethernet.begin(clientmac, clientip, clientsubnet, gateway);

  Udp.begin(clientport);

  //Codeeingabe

  pinMode(absendepin, INPUT_PULLUP);

  pinMode(pinnull, INPUT_PULLUP);

  pinMode(pineins, INPUT_PULLUP);

  pinMode(pinzwei, INPUT_PULLUP);

  pinMode(pindrei, INPUT_PULLUP);

  pinMode(pinvier, INPUT_PULLUP);

  pinMode(pinfuenf, INPUT_PULLUP);

  pinMode(resetpin, INPUT_PULLUP);

  pinMode(ledrot, OUTPUT);

  pinMode(ledgruen, OUTPUT);

  pinMode(hubmagnet, OUTPUT);

  Serial.begin(115200);

}

//########################################################################################################################################################################

void loop() {

  udppacket = Udp.parsePacket();

  if (udppacket) {

    Serial.println("Paketgroesse");

    Serial.println(udppacket);

    Udp.read(packetbuffer, udppacket);

    //Speichert die Empfangenen Daten in ein char Array

    for (int i = 0; i < udppacket; i++) {

      recieveddata[i] = packetbuffer[i];

    }

    Serial.println("Empfangene Daten:");

    Serial.println(recieveddata);

    //Ermittelt die tatsächliche größe des Arrays

    arraygroesse = (unsigned)strlen(recieveddata);

    Serial.println("Arraygroesse ");

    Serial.println(arraygroesse);

    //  arraygroees2=arraygroesse; /

  }

  //########################################################################################################################################################################

  //Pollteil

  if (arraygroesse) { //<10 da die maximale Zeit vor überlaufen der unsigned long Variable 10 Stellen hat.

    arraygroesse = arraygroesse - 1;

    if (recieveddata[arraygroesse] == '3') {

      arraygroesse = arraygroesse - 1;

      if (recieveddata[arraygroesse] == '2') {

        arraygroesse = arraygroesse - 1;

        if (recieveddata[arraygroesse] == '1') {

          Serial.println("Pollanfrage eingegangen!");

          for (int i = 0; i < arraygroesse; i++) {

            serverpollzeithashbuffer[i] = recieveddata[i];

          }

          Serial.println("Empfangene Serverzeit im Array");

          Serial.println(serverpollzeithashbuffer);

          //Hier wird der PIN-Code an die Serverzeit gehängt

          serverpollzeitsize = (unsigned)strlen(serverpollzeithashbuffer);

          Serial.println("Empfangene Serverzeit-Stellen");

          Serial.println(serverpollzeitsize);

          //Das Serverzeitidsize Array ist Zero indexed während die serverzeitid Ausabe bei 1 zu zählen beginnt, somit muss hier nur 2x addiert werden für 3 ID-Stellen

          serverpollzeithashbuffer[serverpollzeitsize] = keyphrase[0];

          serverpollzeitsize = serverpollzeitsize + 1;

          serverpollzeithashbuffer[serverpollzeitsize] = keyphrase[1];

          serverpollzeitsize = serverpollzeitsize + 1;

          serverpollzeithashbuffer[serverpollzeitsize] = keyphrase[2];

          serverpollzeitsize = serverpollzeitsize + 1;

          serverpollzeithashbuffer[serverpollzeitsize] = keyphrase[3];

          Serial.println("Empfangene Serverzeit+PIN");

          Serial.println(serverpollzeithashbuffer);

          Serial.println("HASH fuer Server erstellen");

          unsigned char* hash = MD5::make_hash(serverpollzeithashbuffer);

          char *md5str = MD5::make_digest(hash, 16);

          free(hash);

          for (int i = 0; i < 32; i++) {

            clienthasharray[i] = md5str[i];

          }

          free(md5str);

          //Hängt an den Hash eine ID-an um Server Polls von Befehlen zu unterscheiden.

          clienthasharray[32] = '1';

          clienthasharray[33] = '2';

          clienthasharray[34] = '3';

          Serial.println("Clienthash+ID");

          Serial.println(clienthasharray);

          //Versendet den generierten Hash

          Serial.println("Versende ClientHash+ID");

          Udp.beginPacket(serverip, serverport);

          Udp.print(clienthasharray);

          Udp.endPacket();

          Serial.println("Clienthash versendet");

          memset(recieveddata, 0, sizeof(recieveddata));

          memset(serverpollzeithashbuffer, 0, sizeof(serverpollzeithashbuffer));

          arraygroesse = 0;

          memset(clientzeitbuffer, 0, sizeof(clientzeitbuffer));

          memset(clienthasharray, 0, sizeof(clienthasharray));

          pollidstate1 = 0;

          pollidstate2 = 0;

          pollidstate3 = 0;

        } //IF3

      } //IF2

    } //IF1

  } //Arraygroesse

  //########################################################################################################################################################################

  //Codeeingabeteil

  for (int a = 0; a < EEsize; a++) //Falls der Code vergessen wurde, hier Code[a] = EEPROM.read(a); auskommentieren und denn Standardcode 123456 verwenden, danach den Arduinio einen neuen Code programmieren und diese Zeile wieder wirkbar machen.

  {

    Code[a] = EEPROM.read(a); //Liest das Array aus dem EEPROM in das Code Array ein

    //Serial.print("EEPROM position: ");

    //Serial.print(a);

    //Serial.print(" contains ");

    //Serial.println(Code[a]);

  }

  schleifenexit1 = 0; //Die Bedingungen um den Pin-Code einzutippen werden ungültig

  schleifenexit2 = 0;

  //Eingabe

  tastereingabe();

  //Entprellen: Der Code bis zur Einschreiben im Array befindet sich in dem Millis-IF-Statement. Danach gibt die Variable Schritt zur Gleichheitsprüfung weiter.

  if (Taster0 == 1 || Taster1 == 1 || Taster2 == 1 || Taster3 == 1 || Taster4 == 1 || Taster5 == 1 || Taster6 == 1 || Taster7 == 1 || Taster8 == 1 || Taster9 == 1 || resetpinstatus == 1 || absenden == 1) {

    if (Taster0 == 1) {

      Codeeingabe[schrittzaehler] = 0;

      Serial.println("Im Array:");

      Serial.println(Codeeingabe[schrittzaehler]); /*Serial.println("Schrittzaehler:"); Serial.println(schrittzaehler);*/ schrittzaehler++;

    }

    if (Taster1 == 1) {

      Codeeingabe[schrittzaehler] = 1;

      Serial.println("Im Array:");

      Serial.println(Codeeingabe[schrittzaehler]); /*Serial.println("Schrittzaehler:"); Serial.println(schrittzaehler);*/ schrittzaehler++;

    }

    if (Taster2 == 1) {

      Codeeingabe[schrittzaehler] = 2;

      Serial.println("Im Array:");

      Serial.println(Codeeingabe[schrittzaehler]); /*Serial.println("Schrittzaehler:"); Serial.println(schrittzaehler);*/ schrittzaehler++;

    }

    if (Taster3 == 1) {

      Codeeingabe[schrittzaehler] = 3;

      Serial.println("Im Array:");

      Serial.println(Codeeingabe[schrittzaehler]); /*Serial.println("Schrittzaehler:"); Serial.println(schrittzaehler);*/ schrittzaehler++;

    }

    if (Taster4 == 1) {

      Codeeingabe[schrittzaehler] = 4;

      Serial.println("Im Array:");

      Serial.println(Codeeingabe[schrittzaehler]); /*Serial.println("Schrittzaehler:"); Serial.println(schrittzaehler);*/ schrittzaehler++;

    }

    if (Taster5 == 1) {

      Codeeingabe[schrittzaehler] = 5;

      Serial.println("Im Array:");

      Serial.println(Codeeingabe[schrittzaehler]); /*Serial.println("Schrittzaehler:"); Serial.println(schrittzaehler);*/ schrittzaehler++;

    }

    if (Taster6 == 1) {

      Codeeingabe[schrittzaehler] = 6;

      Serial.println("Im Array:");

      Serial.println(Codeeingabe[schrittzaehler]); /*Serial.println("Schrittzaehler:"); Serial.println(schrittzaehler);*/ schrittzaehler++;

    }

    if (Taster7 == 1) {

      Codeeingabe[schrittzaehler] = 7;

      Serial.println("Im Array:");

      Serial.println(Codeeingabe[schrittzaehler]); /*Serial.println("Schrittzaehler:"); Serial.println(schrittzaehler);*/ schrittzaehler++;

    }

    if (Taster8 == 1) {

      Codeeingabe[schrittzaehler] = 8;

      Serial.println("Im Array:");

      Serial.println(Codeeingabe[schrittzaehler]); /*Serial.println("Schrittzaehler:"); Serial.println(schrittzaehler);*/ schrittzaehler++;

    }

    if (Taster9 == 1) {

      Codeeingabe[schrittzaehler] = 9;

      Serial.println("Im Array:");

      Serial.println(Codeeingabe[schrittzaehler]); /*Serial.println("Schrittzaehler:"); Serial.println(schrittzaehler);*/ schrittzaehler++;

    }

    if (resetpinstatus == 1) {

      schrittzaehler = 0;

      schrittzaehler2 = 0;

      rightcode = 0;

      arrayreset();

      Serial.println("Array gelöscht!");

      newcode = 0;

    }

    if (schrittzaehler > 5) schrittzaehler = 0; //Es dürfen nur sechs Stellen Code eingegeben werden, 0-5 z.B. wenn 456789123456 eingegeben wird, zählen nur die letzten sechs stellen also 123456

    if (absenden == 1) { //Zweimal Raute drücken um in den Programmiermodus zu kommen, jedoch muss der Zähler dreimal Zählen da beim absenden des Codes um das Schließfach zu öffnen ebenfalls die #-Taste benutzt wird.

      newcode++;

      Serial.println("Schleife-Betreten bei 3x# gedrueckt");

      Serial.println(newcode);

    }

    if (newcode > 3) { //Wenn die #-Taste öfter gedrückt wird z.B. vor der ersten Codeeingabe zum Öffnen des Schließfaches würde setzt diese Funktion den Wert zurück.

      newcode = 3;

      Serial.println("Newcode-Begrenzung");

      Serial.println(newcode);

    }

  }

  if (absenden == 1) { //Hier wird der eingebene Pin auf Gleichheit mit dem gespeicherten PIN überprüft

    Serial.println("Absendebutton funktioniert, Code wird nun uberprüft"); //Absendebutton funktioniert

    for (schrittzaehler2 = 0; schrittzaehler2 < 6; schrittzaehler2++) {

      if (Codeeingabe[schrittzaehler2] == Code[schrittzaehler2]) {

        Serial.println("Schleife funktioniert"); //Schleife funktioniert

        rightcode++;

        Serial.println("Rightcode");

        Serial.println(rightcode);

      }

      else {

        Serial.println("Rightcode Reset");

        rightcode = 0;

        schrittzaehler2 = 0;

        arrayreset();

      }

    }

  }

  if (rightcode > 6) rightcode = 6; //Wenn die Absendetaste versehentlich 2x oder öfter gedrückt wurde, setzt diese IF-Abfrage den Wert wieder auf 6 zurück.

  if (rightcode == 6) {

    //Serial.println("Rightcode Zahl");

    //Serial.println(rightcode);

    digitalWrite(ledgruen, HIGH);

    digitalWrite(ledrot, LOW);

    digitalWrite(hubmagnet, HIGH);

  }

  else {

    digitalWrite(ledgruen, LOW);

    digitalWrite(ledrot, HIGH);

    digitalWrite(hubmagnet, LOW);

  }

  //########################################################################################################################################################################

  //Statusupdateteil

  if (rightcode == 0 && closestatus == 0) {

    Udp.beginPacket(serverip, serverport);

    Udp.print("9991");

    Udp.endPacket();

    Serial.println("Geschlossen versendet");

    closestatus = 1;

    openstatus = 0;

  }

  if (rightcode == 6 && openstatus == 0) {

    Udp.beginPacket(serverip, serverport);

    Udp.print("9992");

    Udp.endPacket();

    Serial.println("Geoeffnet versendet");

    openstatus = 1;

    closestatus = 0;

  }

  if (neuprogrammierstatus == 1) {

    Udp.beginPacket(serverip, serverport);

    Udp.print("9994");

    Udp.endPacket();

    Serial.println("Neu Programmierstatus-Ende versendet");

    neuprogrammierstatus = 0;

  }

  //###############################################################################################################################################

  //Programmiermodus

  if (newcode == 3 && rightcode == 6) {

    //Serial.println("In der Programmierabfrage");

    newcode = 0;

    for (int i = 0; i < 6; i++) {

      NeuerCode[i] = 10;

      NeuerCode2[i] = 10;

    }

    while (schleifenexit1 == 0) {

      //Serial.println("In der 1 While Schleife");

      digitalWrite(ledgruen, HIGH);

      digitalWrite(ledrot, HIGH);

      //Sendet Statusupdate an Server

      if (neuprogrammierstatus == 0) {

        Udp.beginPacket(serverip, serverport);

        Udp.print("9993");

        Udp.endPacket();

        Serial.println("Neu Programmierstatus-Anfang versendet");

        neuprogrammierstatus = 1;

      }

      schleifenstartzeit = millis();

      if (schleifenstartzeit - schleifenendzeit > 30000) {

        Serial.println("Schleifenstartzeit");

        Serial.println(schleifenstartzeit);

        Serial.println("Schleifenendzeit");

        Serial.println(schleifenendzeit);

        schleifenendzeit = schleifenstartzeit;

        Serial.println("Schleifenbreak");

        schleifenexit1 = 1;

        schleifenexit2 = 1;

      }

      tastereingabe();

      //Entprellen: Der Code bis zur Einschreiben im Array befindet sich in dem Millis-IF-Statement. Danach gibt die Variable Schritt zur Gleichheitsprüfung weiter.

      if (Taster0 == 1 || Taster1 == 1 || Taster2 == 1 || Taster3 == 1 || Taster4 == 1 || Taster5 == 1 || Taster6 == 1 || Taster7 == 1 || Taster8 == 1 || Taster9 == 1 || resetpinstatus == 1 || absenden == 1) {

        if (Taster0 == 1) {

          NeuerCode[schrittzaehler3] = 0;

          Serial.println("Im Array:");

          Serial.println(NeuerCode[schrittzaehler3]);

          Serial.println("Schrittzaehler3:");

          Serial.println(schrittzaehler3);

          schrittzaehler3++;