TARJETA de CONTROL para ASCENSORES con ESP32 V5

Si bien es cierto, ya hemos publicado varias versiones de tarjetas electrónicas para elevadores y ascensores de carga, todas ellas controladas con microcontroladores ATmega.

En esta nueva versión damos un paso importante y utilizamos un cerebro mucho más potente: el ESP32.

Esta es la primera gran mejora.

Gracias a este microcontrolador, ahora disponemos de cuatro entradas adicionales, las cuales pueden utilizarse, por ejemplo, para habilitar un quinto piso o para integrar sensores de seguridad, como el sensor de puerta cerrada.

En total, contamos con 12 entradas digitales de 24 voltios.

Además, incorporamos dos salidas adicionales.

Anteriormente solo teníamos tres salidas, pero ahora, con estas nuevas incorporaciones, ya tenemos la posibilidad de controlar directamente la apertura y el cierre de las puertas del ascensor.

Además, la lógica y el funcionamiento general es mucho más seguro que la anterior versión anterior.

1. Tensión de alimentación……………………….…………24VDC
2. Corriente de alimentación………………….……………40mA
3. Entadas digitales 12-24VDC……………………….……12
4. Pantalla display de 7 seg ……………………………… Sí
5. Salidas RLY…………………………………………………………5
   • • Tensión AC…………..……….………………….….……250V
     • Corriente AC…………………………………………….5A
     • Tensión DC………………………………………………30V
     • Corriente DC……………………………………………5A
6. Entorno de programación………………………..………..Arduino IDE
7. Condiciones ambientales min……………………….….-40°
8. Condiciones ambientales max…………………..……….80°
9. Pulsadores de maniobra…………………………………………..Sí
10. Dimensiones……………………………………………………….105x105mm
11.  Empotrable………………………………….……………………Sí
12. Puerto de programación…………………………………………Sí

¿Para qué sirve?

Modo de control manual para mantenimiento y pruebas.
El ascensor no responde a llamadas automáticas.

Controles

Uso básico

1. Presione OK (D2) → entra en modo maniobra

2. Mantenga SUBIR o BAJAR para mover el ascensor

3. Suelte el botón → el motor se detiene

4. Presione OK (D2) para salir

Seguridad

• Si no se presiona ningún botón → motor detenido

• Si se presionan SUBIR y BAJAR juntos → motor detenido

• El piso detectado se muestra en el display

• Tiempo máximo: 30 segundos (sale automáticamente)

Al salir del modo

• El motor se detiene

• El sistema se reinicia

• Vuelve al modo automático de forma segura

⚠️ Uso exclusivo para personal técnico
No utilizar con pasajeros dentro.

// ============================================
// CONTROL DE ASCENSOR - MODO NORMAL (SIN MANIOBRA)
// ============================================

// -------- PINES SENSORES DE PISO ----------
#define S1 13
#define S2 12
#define S3 14
#define S4 27

// -------- PINES PULSADORES ----------
#define B1 26
#define B2 25
#define B3 33
#define B4 32
#define CONTINUE_BTN 36
#define DOOR_SENSOR  39

// -------- MOTOR ----------
#define MOTOR_UP    19
#define MOTOR_DOWN  18

// -------- DISPLAY 7 SEGMENTOS ----------
#define DS_PIN 21
#define SH_PIN 22
#define ST_PIN 23

// -------- CONSTANTES ----------
#define INIT_SEARCH_TIME 10000
#define SENSOR_CHECK_INTERVAL 50

// -------- ESTADOS ----------
enum SystemState {
  STATE_INITIAL_SEARCH,
  STATE_REPOSE,
  STATE_MOVING,
  STATE_WAITING_CONTINUE
};

SystemState currentState = STATE_INITIAL_SEARCH;

// -------- VARIABLES ----------
int currentFloor = 0;
int targetFloor = 0;
bool directionUp = true;
bool doorsClosed = true;
unsigned long searchStartTime = 0;
unsigned long lastSensorCheck = 0;

// -------- COLA ----------
#define MAX_REQUESTS 8
int requestQueue[MAX_REQUESTS];
int requestCount = 0;

// -------- DISPLAY ----------
byte digitPatterns[5] = {
  0b11111100, // 0
  0b01100000, // 1
  0b11011010, // 2
  0b11110010, // 3
  0b01100110  // 4
};

// ============================================
// SETUP
// ============================================
void setup() {
  Serial.begin(115200);

  pinMode(S1, INPUT); pinMode(S2, INPUT);
  pinMode(S3, INPUT); pinMode(S4, INPUT);

  pinMode(B1, INPUT); pinMode(B2, INPUT);
  pinMode(B3, INPUT); pinMode(B4, INPUT);

  pinMode(CONTINUE_BTN, INPUT);
  pinMode(DOOR_SENSOR, INPUT);

  pinMode(MOTOR_UP, OUTPUT);
  pinMode(MOTOR_DOWN, OUTPUT);

  pinMode(DS_PIN, OUTPUT);
  pinMode(SH_PIN, OUTPUT);
  pinMode(ST_PIN, OUTPUT);

  stopMotor();
  updateDisplay(0);

  if (checkAnySensorActive()) {
    determineCurrentFloor();
    currentState = STATE_REPOSE;
    updateDisplay(currentFloor);
  } else {
    startInitialSearch();
  }
}

// ============================================
// LOOP
// ============================================
void loop() {
  doorsClosed = (digitalRead(DOOR_SENSOR) == HIGH);

  switch (currentState) {
    case STATE_INITIAL_SEARCH: handleInitialSearch(); break;
    case STATE_REPOSE: handleRepose(); break;
    case STATE_MOVING: handleMoving(); break;
    case STATE_WAITING_CONTINUE: handleWaitingContinue(); break;
  }

  readFloorButtons();
  delay(10);
}

// ============================================
// FUNCIONES DE SENSORES
// ============================================
int readSensor() {
  if (digitalRead(S1)) return 1;
  if (digitalRead(S2)) return 2;
  if (digitalRead(S3)) return 3;
  if (digitalRead(S4)) return 4;
  return 0;
}

bool checkAnySensorActive() {
  return readSensor() > 0;
}

void determineCurrentFloor() {
  currentFloor = readSensor();
}

// ============================================
// BÚSQUEDA INICIAL
// ============================================
void startInitialSearch() {
  digitalWrite(MOTOR_DOWN, HIGH);
  searchStartTime = millis();
}

void handleInitialSearch() {
  int f = readSensor();
  if (f > 0) {
    stopMotor();
    currentFloor = f;
    updateDisplay(f);
    currentState = STATE_REPOSE;
  }
}

// ============================================
// REPOSO
// ============================================
void handleRepose() {
  updateDisplay(currentFloor);

  if (requestCount > 0 && doorsClosed) {
    targetFloor = getNextFloor();
    directionUp = targetFloor > currentFloor;
    startMotor();
    currentState = STATE_MOVING;
  }
}

// ============================================
// MOVIMIENTO
// ============================================
void handleMoving() {
  if (!doorsClosed) {
    stopMotor();
    currentState = STATE_REPOSE;
    return;
  }

  if (millis() - lastSensorCheck >= SENSOR_CHECK_INTERVAL) {
    lastSensorCheck = millis();
    int f = readSensor();

    if (f > 0) {
      currentFloor = f;
      updateDisplay(f);

      if (f == targetFloor) {
        stopMotor();
        removeFromQueue(f);
        currentState = STATE_WAITING_CONTINUE;
      }
    }
  }
}

// ============================================
// ESPERA CONTINUAR
// ============================================
void handleWaitingContinue() {
  if (doorsClosed && digitalRead(CONTINUE_BTN)) {
    currentState = STATE_REPOSE;
  }
}

// ============================================
// MOTOR
// ============================================
void startMotor() {
  stopMotor();
  if (directionUp) digitalWrite(MOTOR_UP, HIGH);
  else digitalWrite(MOTOR_DOWN, HIGH);
}

void stopMotor() {
  digitalWrite(MOTOR_UP, LOW);
  digitalWrite(MOTOR_DOWN, LOW);
}

// ============================================
// COLA
// ============================================
void readFloorButtons() {
  if (digitalRead(B1)) addToQueue(1);
  if (digitalRead(B2)) addToQueue(2);
  if (digitalRead(B3)) addToQueue(3);
  if (digitalRead(B4)) addToQueue(4);
}

void addToQueue(int f) {
  for (int i = 0; i < requestCount; i++)
    if (requestQueue[i] == f) return;

  if (requestCount < MAX_REQUESTS)
    requestQueue[requestCount++] = f;
}

void removeFromQueue(int f) {
  for (int i = 0; i < requestCount; i++) {
    if (requestQueue[i] == f) {
      for (int j = i; j < requestCount - 1; j++)
        requestQueue[j] = requestQueue[j + 1];
      requestCount--;
      return;
    }
  }
}

int getNextFloor() {
  return requestQueue[0];
}

// ============================================
// DISPLAY
// ============================================
void updateDisplay(int n) {
  if (n < 0 || n > 4) n = 0;
  digitalWrite(ST_PIN, LOW);
  shiftOut(DS_PIN, SH_PIN, LSBFIRST, digitPatterns[n]);
  digitalWrite(ST_PIN, HIGH);
}