Al concluir el programa el Arduino se congela o inica de Nuevo

Buenos días Colegas.

Estoy desarrollando un proyecto de apertura de puertas, con un sensor en la puerta y un lector RFID, que envien los datos a través de Ethernet a un servidor, el caso es que mi programación funciona, pero al finalizar el código parece que el arduino se reinicia ya que vuelve a void setup, alguien tendrá alguna idea, se los agradecería mucho.

Saludos

Arduino UNO
Lan Shield W5100
RFID PN532

#include <Ethernet.h>
#include <SPI.h>
#include <Wire.h>
#include <Adafruit_PN532.h> 
#define PN532_IRQ   (3)
#define PN532_RESET (4)  
Adafruit_PN532 nfc(PN532_IRQ, PN532_RESET);
#if defined(ARDUINO_ARCH_SAMD)
   #define Serial SerialUSB
#endif

//Asignamos una dirección MAC
byte mac[] = {  0xDE, 0xBD, 0xBE, 0xEF, 0xFE, 0xED};
 
//Asignar dirección IP
IPAddress ip(192,168,1,172);
 
//Inicializar instancia de la libreria ethernet
EthernetClient client;
 
//Dirección IP del servidor con la página PHP

//Variables que neceita para funcionar
char url[]="GET /arduino/index.php?uid=";
char habitacion[]="12";
String codigo;        //Aquí se almacena la respuesta del servidor
String nombre;        //Aquí se almacena el nombre que recuperamos de MySQL
boolean fin = false;  
boolean pregunta = true;
boolean enviado = false;
boolean senala=false;
boolean senalc=false;
int impresoa=0;
int impresoc=0;
const int SensorPin = 2;     // the number of the pushbutton pin
const int RlyPin =  8;
int SensorState = 0;
int Rojo = 5;
int Verde = 7;
int Azul = 6;

void setup() {
  
  // Iniciar puerto serie
  Serial.begin(115200);
  // Dar un respiro a Arduino
  delay(1000);
  
  
  pinMode(RlyPin, OUTPUT);
   pinMode(Rojo, OUTPUT);
   pinMode(Verde, OUTPUT);
   pinMode(Azul, OUTPUT);
  // initialize the pushbutton pin as an input:
  pinMode(SensorPin, INPUT);
  digitalWrite(RlyPin,LOW);
  //Iniciar la coneción de red
  
 Ethernet.begin(mac, ip);
  // Imprimir la dirección IP
  Serial.print("IP: ");
  Serial.println(Ethernet.localIP());
    nfc.begin();

  uint32_t versiondata = nfc.getFirmwareVersion();
  if (! versiondata) {
    Serial.print("Didn't find PN53x board");
    while (1); // halt
  }
  nfc.SAMConfig();
  
  attachInterrupt(digitalPinToInterrupt(2),sensor,CHANGE);
  
}
 
void loop() { 

    //Comprobamos si tenemos datos en el puerto serie
       digitalWrite(Rojo,HIGH ); 
  digitalWrite(Verde,HIGH); 
  digitalWrite(Azul,HIGH);
     
    if (pregunta == true) Serial.println("Escanea Tarjeta de la persona: ");
    pregunta = false;
   
  uint8_t success;
  uint8_t uid[] = { 0, 0, 0, 0, 0, 0, 0 };  // Buffer to store the returned UID
  uint8_t uidLength;                        // Length of the UID (4 or 7 bytes depending on ISO14443A card type)
  
  success = nfc.readPassiveTargetID(PN532_MIFARE_ISO14443A, uid, &uidLength);
    
  if (success) {
      delay(100);    
    if (uidLength == 4)
    {
      // We probably have a Mifare Classic card ... 
      uint32_t cardid = uid[0];
      cardid <<= 8;
      cardid |= uid[1];
      cardid <<= 8;
      cardid |= uid[2];  
      cardid <<= 8;
      cardid |= uid[3]; 
      Serial.println(cardid);
       delay(100);
      String carid1= (String)cardid;
      httpRequest(carid1);
      pregunta = true;   
   // delay(500);
  }    else if(uidLength == 7)  {
        
        // We probably have a Mifare Classic card ... 
      uint32_t cardid = uid[0];
      cardid <<= 8;
      cardid |= uid[1];
      cardid <<= 8;
      cardid |= uid[2];  
      cardid <<= 8;
      cardid |= uid[3]; 
      cardid <<= 8;
      cardid |= uid[4]; 
      Serial.println(cardid);
        delay(100);
      String carid1= (String)cardid;
       httpRequest(carid1);
      pregunta = true;   
    //delay(500);
    }
  }
}
// Con esta función hacemos la conecion con el servidor
int httpRequest(String identificador) {
  char url_1[]="";
      char a[15];
     identificador.toCharArray(a,(identificador.length()+1));
     strcat(url_1, url);
     strcat(url_1, habitacion);
     strcat(url_1, "h");
     strcat(url_1, a);
    // Serial.println(url_1);
  // Comprobar si hay conexión
    delay(200);
      if (client.connect(IPAddress(192,168,1,74),8080))
        {
        //  Serial.println("Client connected");
          client.print(url_1);//?uid=13h4016290435
           client.println(" HTTP/1.0");
           client.println("Host: 192.168.1.74");
           client.println("User-Agent: arduino-ethernet");
           client.println("Connection: close");
           client.println();          
          
        }
      else{        
      client.stop();
        Serial.println("Client connect failed");}
      
  delay(500);
  //  Serial.println("3");
  //Comprobamos si tenemos respuesta del servidor y la 
  //almacenamos en el string ----> codigo.
 
 while (client.available()) {
    //Serial.println("4");
    char c = client.read();
    //Serial.println("5");
    codigo += c;
    //
    fin=true;
    //Habilitamos la comprobación del código recibido 
  }
  //Serial.println(codigo);
  //Si está habilitada la comprobación del código entramos en el IF
  if (fin)  {
   // Serial.println(codigo);
   //Analizamos la longitud del código recibido
    int longitud = codigo.length();
    //Buscamos en que posición del string se encuentra nuestra variable
   int posicion = codigo.indexOf("valor=");
    //Borramos lo que haya almacenado en el string nombre
    nombre = ""; 
   //Analizamos el código obtenido y almacenamos el nombre en el string nombre
    for (int i = posicion + 6; i < longitud; i ++){
      if (codigo[i] == ';') i = longitud;
      else nombre += codigo[i];
    }
    //Deshabilitamos el análisis del código
    fin = false;
    //Imprimir el nombre obtenido
    Serial.println("Habitación: " + nombre);
    enviado=true;
    if(nombre=="OK"){
      
    digitalWrite(Rojo,HIGH ); 
  digitalWrite(Verde,HIGH); 
  digitalWrite(Azul,LOW); 
      digitalWrite(RlyPin,HIGH);       
    delay(2000);
    digitalWrite(RlyPin,LOW);   
    }else{
   digitalWrite(Rojo,LOW ); 
  digitalWrite(Verde,HIGH); 
  digitalWrite(Azul,HIGH); 
  delay(1000);
    }
   
  }
  //Borrar código y salir de la función//Dirección IP del servidor
  codigo="";
  return 1;

}
void sensor(){
  int impreso=0;
 SensorState = digitalRead(SensorPin);
      if(SensorState==HIGH && impreso==0){
         if (client.connect(IPAddress(192,168,1,74),8080)) {
    client.print("GET /arduino/index.php?rege=");
    client.print(habitacion);
    client.print("a0");     
    client.println(" HTTP/1.0");
    client.println("Host: 192.168.1.74");
    client.println("User-Agent: arduino-ethernet");
    client.println("Connection: close");
    client.println();
    impreso++;
          Serial.println("Cerrada");
        }else{
           client.stop(); 
        }
        }
      else if(SensorState==LOW&& impreso==0){
          if (client.connect(IPAddress(192,168,1,74),8080)) {
    client.print("GET /arduino/index.php?rege=");
    client.print(habitacion);
    client.print("a1");   
    client.println(" HTTP/1.0");
    client.println("Host: 192.168.1.74");
    client.println("User-Agent: arduino-ethernet");
    client.println("Connection: close");
    client.println();
          impreso++;
        }else{
           client.stop();
        }
          Serial.println("Abierta");
        }
    
    
}

Que es esto

#include<elapsedMillis.h>

elapsedMillis timeElapsed;

int sensor = 0;

int contador = 0;

int estado_anterior = 0;


void setup() {

  Serial.begin(9600);

  pinMode(sensor, INPUT);

}

void loop() {

  int lectura = analogRead(sensor);

  if(lectura!=estado_anterior){

    if(lectura < 5) {

      for (contador; contador <=100; contador++) {

     Serial.println(timeElapsed/1000);

    timeElapsed = 0;

  }

  }

  }

estado_anterior = lectura;

}]#include <Ethernet.h>

Observa que tienes dos loop() en tu código

Al parecer tuve un error, pero eso no es parte del código, ya edite el post

El arduino se reinicial cuando algo lo deja en espera demasiado tiempo y no me refiero a una lectura de puerto serie
Ese algo debe ser un dispositivo que genere una interrupción y su mal uso provoca este inconveniente.

Lo que yo haría seria esto. Usaría varios Serial.print para detectar donde se cuelga el código.
Y luego de hacerlo intentaría llegar a la instrucción que genera el problema y entonces pensar en como resolverlo.

Veo que utilizas una interrupción que dispara la función sensor()

Tienes que prever que pasa si estando ejecutando la función de interrupción, vuelve a saltar la misma interrupción.

La función disparada por un interrupción tiene que ser muy breve y concisa, y la ha de poder solventar el propio dispositivo,
Tu intentas hacer trafico http involucrando un servidor externo dentro de una función de interrupción y eso no puede ser así.
Todo ese código que tienes en la función sensor() lo tienes que quitar de ahí,

Por otro lado, lee sobre detachinterrupt(), busca ejemplos.

Quizás un interrupción no es adecuado a lo que quieres hacer.