#include <Servo.

h>
/*
====================================================================================================
=====================================
CONSTANTES
====================================================================================================
===================================== */
// Constantes de configuracin de pines y nombres para su testeo
const int PLANTAS = 3;

// Ascensor con tres plantas

// Parmetros de ngulo de giro del servo

const int ANGULOMAXIMO = 180;

const int ANGULOMINIMO =
0;
const int PASO
= 30;
const int outServo
=
3;
los pines asociados al PWM

// Salida del servo. Pendiente de ubicar. Utilizar para el control

// Pines de salida del BCD 7 segementos. Muestra la planta actual

= 10;
= 11;
= 12;
= 13;
// Led's que simulan el sentido de giro del motor del ascensor
const int subidaMotor
= 0;
const int bajadaMotor
= 1;
const
const
const
const

int
int
int
int

outPinA
outPinB
outPinC
outPinD

// Leds que indican el estado en que nos encontramos

const int ledReposo
= 2;
const int ledEntreplanta = A0;
const int ledPuerta
= A2;
const int fCarrera
pin analgico
const int sensorPuerta

= A4;

// Sensor de final de carrera del motor subida bajada. Lectura de

= A5;

// Sensor de seguridad de la puerta. Lectura de pin analgico

// Pines de entrada de la botonera del ascensor y botn de cada planta

const int botAscensor[PLANTAS] = {4,5,6};
// Dentro se indica el nmero del pin utilizado
const int botPlanta[PLANTAS]
= {7,8,9};
//int fCarreraPlanta[PLANTAS -1];
a la planta --> parar el ascensor
//int sensorPuerta[PLANTAS -1];
por cada planta

// Sensor de final de carrera que avisa de llegada

// Sensor de seguridad de cierre de puertas --> uno

/*
====================================================================================================
=====================================
VARIABLES
====================================================================================================
===================================== */
// Configuracin del servomotor
// Crear un objeto servo
// posicin de servo

Servo puertaServo;
int posicionServo = 0;

// Registros utilizados para el funcionamiento del Ascensor. De la planta

a PLANTAS -1]
int botonesAscensor[PLANTAS];
// Array de pulsadores del teclado del ascensor
int pulsadoresPlanta[PLANTAS];
// Array de pulsadores de cada planta
//int finalCarrPlanta[PLANTAS];
// Array de finales de carrera para cada planta
// Variables para conocer el estado y ubicacin del ascensor

[1

int planta
= 0;
// Indica la planta actual donde se encuentra el
ascensor. Se actualiza al llegar a una nueva planta
int estadoAscensor
= 0;
// '0' --> reposo, '1' --> subir, '2' --> bajar
boolean estadoReposo = false;
// Variable semforo para no re-escribir en los
puertos de salida. Reposo planta
boolean estadoPuerta = false;
// Variable semforo para no re-escribir en los
puertos de salida. Puerta
int estado = 0;
// Para la mquina de estados del ascensor
// Variables de ayuda a la secuencias de funcionamiento
boolean encendidoMotor = false;
boolean abriendoPuerta = false;
int
parpadeo = LOW;
// Variables para el parpadeo de led
long milisegundosAnteriores = 0;
// Almacena la ltima vez que el LED se ha actualizado. Se
utilizan variables long ya que el tiempo se mide en milisegundos
// Rpidamente se convertir en un nmero ms grande que se
puede almacenar en un int
long periodo
= 500;
// Intervalo de parpadeo del LED (milisegundos)
// Variables de filtrado de ruido en la lectura de sensores pticos
long miliSegAntLectura = 0;
// Variable que almacena la ltima lectura de 'millis()'
para comparar el tiempo transcurrido
long intervalo = 350;
// Tiempo de espera para eliminar ruido
boolean lecturaOptico = false;
// Variable para leer la primera activacin y rechazar el
resto durante un tiempo determinado 'intervalo'
// Variables de lectura pulsadores
int anteriorLeido = LOW;
// Lectura anterior del pulsador de entrada
/*
====================================================================================================
=====================================
FUNCIONES
====================================================================================================
===================================== */
// Lectura de la entrada indicada en 'pin'
boolean antiRebote(int pin){
boolean pulsado = false;
int leido = digitalRead(pin);
variable local
if (leido == HIGH && anteriorLeido == LOW)
pulsado = true;

// Lee el estado del pin y la almacena en una

// Si el pulsador cambia de 0 a 1

anteriorLeido = leido;
return pulsado;
}
// Retardo de tiempo indicado en tiempo para filtrar ruido en las lecturas
// Anchura del tiempo de antirrebote --> ( miliSegActuales - miliSegAntLectura > X mseg )
boolean retardo(){
unsigned long miliSegActuales = millis();
if(miliSegActuales - miliSegAntLectura > intervalo){
miliSegAntLectura = miliSegActuales;
// Guarda la ltima vez que se ha cumplido el tiempo de
filtro y actualiza la variable 'miliSegAntLectura'
if (lecturaOptico)
// Si ya se ha cumplido el tiempo del filtro y se ha
ledo el primer cambio en el sensor, se cambia
lecturaOptico = false;
// 'lecturaOptico = false' para iniciar una nueva captura
del senor
}
return lecturaOptico;
}

// Lee el sensor ptico del pin analgico correspondiente. Con filtro antirrebote
int lecturaSensorOptico(int sensor){
int lectura = LOW;
unsigned long miliSegActuales = millis();
if (analogRead(sensor) <= 100 && !retardo()){
// Se recoge el primer dato y cuando pasa un
tiempo mnimo 'intervalo' (filtro ruido) --> se puede volver a capturar un nuevo dato
lectura = HIGH;
// Hay activacin del sensor
lecturaOptico = HIGH;
}
return lectura;
}
// Lectura de los pulsadores de la botonera del ascensor y de cada planta
void lecturaPulsadores(){
for (int i = 0; i < PLANTAS; i++){
if (antiRebote(botAscensor[i])){
botonesAscensor[i] = HIGH;
}
if (antiRebote(botPlanta[i])){
pulsadoresPlanta[i] = HIGH;
}
}
}
// Indica el nmero de planta en que se encuentra
void numeroPlanta(int num){
// Convierte un nmero decimal a binario y lo saca por los pines de salida 0-3
digitalWrite(outPinD, HIGH && (num & B00001000));
digitalWrite(outPinC, HIGH && (num & B00000100));
digitalWrite(outPinB, HIGH && (num & B00000010));
digitalWrite(outPinA, HIGH && (num & B00000001));
}
// Indica si se ha pulsado algn botn de la planta indicada
boolean botonPulsado(int planta){
return (botonesAscensor[planta]== HIGH) || (pulsadoresPlanta[planta]== HIGH);
}
// Indica que se ha pulsado algn botn distinto al de la planta donde est el ascensor
boolean llamadaAscensor(int planta){
boolean llamada = false;
for (int i = 0; i < PLANTAS; i++){
if (i != planta){
if (botonesAscensor[i] == HIGH || pulsadoresPlanta[i] == HIGH)
llamada = true;
}
}
return llamada;
}
/*
------------------------------------------------------------------------------------------------------------------------------- */
// Sensor de llegada a planta. Llama a la funcin de lectura del sensor, escribe en la posicin
correspondiente y luego lo verifica
boolean sensorFinalCarrera(int sensor, int planta){
// finalCarrPlanta[planta] = lecturaSensorOptico(sensor); // Para cuando se dispone de un
sensor por planta
return lecturaSensorOptico(sensor) == HIGH;
// Verifico si se ha activado el
sensor de final de carrera
}
/*
*/
// Para el motor del ascensor

Funciones para control del motor de subida/bajada del ascensor

void pararMotor(){
// apagar el led correspondiente de simulado de funcionamiento
digitalWrite(subidaMotor, LOW);
digitalWrite(bajadaMotor, LOW);
encendidoMotor = false;
}
// Arranque en sentido de subida. Simulado con un led
boolean arranqueMotorSubida(){
digitalWrite(subidaMotor, HIGH);
return true;
}
// Arranque en sentido de bajada. Simulado con un led
boolean arranqueMotorBajada(){
digitalWrite(bajadaMotor, HIGH);
return true;
}
/*

*/
// Encendido con parpadeo de led de estado
void parpadeoLedEstado(int pin){
unsigned long milisegundosActuales = millis();
if(milisegundosActuales - milisegundosAnteriores > periodo) {
milisegundosAnteriores = milisegundosActuales;
// Guarda la ltima vez que parpadeaba el LED
parpadeo = !parpadeo;
// Conmuta el valor escrito en el pin
digitalWrite(pin, parpadeo);
}
}
// Encendido de led de estado
boolean ledEstadoEncendido(int pin){
digitalWrite(pin, HIGH);
return true;
}
// Apagado de led de estado
boolean ledEstadoApagado(int pin){
digitalWrite(pin, LOW);
return false;
}
// Incrementa o disminuye una posicin el valor de planta
void actualizarPlanta(){
if (estadoAscensor == 1)
// Ascensor subiendo
planta++;
else if (estadoAscensor == 2)
// Ascensor bajando
planta--;
}
// se comprueba que el sentido es de subida
boolean subidaAscensor(){
return (estadoAscensor == 1);
}
// Se comprueba que el sentido es de bajada
boolean bajadaAscensor(){
return (estadoAscensor == 2);
}
// Determina el sentido de subida/bajada indicndolo en la variable
// 'estadoAscensor' : '0' --> reposo, '1' --> subir, '2' --> bajar
int sentidoAscensor(int planta){
// Si el ascensor est subiendo

int i = planta;
while (i < PLANTAS){
if (botonesAscensor[i] == 1 || pulsadoresPlanta[i] == 1){
return 1; // Hay que ascender
}
i++;
}
// Si el ascensor est bajando
i = planta;
while (i > -1){
if (botonesAscensor[i] == 1 || pulsadoresPlanta[i] == 1){
return 2; // Hay que descender
}
i--;
}
return 0;
// Estado de reposo
}
/*
------------------------------------------------------------------------------------------------------------------------------- */
// Se borra en la planta correspondiente los botones que ah se hayan pulsado
void borradoRegistroPlanta(int planta){
botonesAscensor[planta] = 0;
pulsadoresPlanta[planta] = 0;
}
// Sensor de seguridad de cierre de la puerta ante obstculos
boolean sensorSeguridadPuerta(int sensor){
// sensorPuerta[planta] = lecturaSensorOptico(sensor);
// Para cuando se dispone de un sensor
por planta para cada puerta
return lecturaSensorOptico(sensor) == HIGH;
// Verifico que se ha activado el sensor
}
/* Funciones para control del motor paso a paso de la puerta del
ascensor */
// Indica que la puerta est completamente abierta
boolean puertaAbierta(){
return posicionServo == ANGULOMAXIMO;
}
// Indica que la puerta est completamente cerrada
boolean puertaCerrada(){
return posicionServo == ANGULOMINIMO;
}

// Se ha abierto completamente

// Se ha cerrado completamente

// Detiene el cierre de la puerta --> por algn obstculo

void paradaPuerta(){
delay(2000);
// Detiene el funcionamiento del motor paso a paso
}
// Detiene la puerta en la ltima posicin conocida
void detenerPuerta(){
puertaServo.write(posicionServo);
delay(500);
}
// Abre completamente la puerta desde la posicin en la que se encontraba en ese momento
boolean aperturaEmergenciaPuerta(){
while (posicionServo < ANGULOMAXIMO){
posicionServo = posicionServo + PASO;
puertaServo.write(posicionServo);
delay(50);
}
return true;
}

//

Valores en puerto serie (0-180)

// Se abre la puerta del ascensor, durante un tiempo determinado

// OJO --> hay que tener en cuenta que no se debe activar o tener en cuenta el sensor de seguridad
de la puerta
boolean aperturaPuerta(){
if (posicionServo < ANGULOMAXIMO){
posicionServo = posicionServo + PASO;
puertaServo.write(posicionServo);
delay(50);
}
return true;

//

Valores en puerto serie (0-180)

}
// Indica cuando se ha terminado de cerrar la puerta, tras un tiempo, de entrada del ascensor
boolean cierrePuerta(){
if (posicionServo > ANGULOMINIMO){
posicionServo = posicionServo - PASO;
puertaServo.write(posicionServo);
delay(100);
}
return true;

//

Valores en puerto serie (0-180)

}
/*

*/
/*
====================================================================================================
=====================================
INICIALIZACIN Y CONFIGURACIN
====================================================================================================
===================================== */
void setup() {
// Configuracin de los pines digitales como entrada
pinMode(fCarrera, INPUT);
for (int i = 0; i < PLANTAS; i++){
pinMode(botAscensor[i], INPUT);
// Dentro se indica el nmero del pin utilizado
pinMode(botPlanta[i] , INPUT);
botonesAscensor[i] = LOW;
pulsadoresPlanta[i] = LOW;
// finalCarrPlanta[i]= LOW; // Cuando se tiene un sensor de final carrera por planta
}
// Configuracin
pinMode(outPinD,
pinMode(outPinC,
pinMode(outPinB,
pinMode(outPinA,

de los pines digitales como salida. BCD 7 Segmentos

OUTPUT);
OUTPUT);
OUTPUT);
OUTPUT);

// Configuracin de led's de estado

pinMode(ledEntreplanta, OUTPUT);
pinMode(ledReposo, OUTPUT);
pinMode(ledPuerta, OUTPUT);
// Led's de simulacin del motor
pinMode(subidaMotor, OUTPUT);
pinMode(bajadaMotor, OUTPUT);
// Configuracin del servo de apertura/cierre de puerta
puertaServo.attach(outServo);
// Asocia el servo al pin 3

puertaServo.write(ANGULOMINIMO);

// Inicializa la posicin del servo

}
/*
====================================================================================================
=========================================
EJECUCIN DE LA APLICACIN
====================================================================================================
========================================== */
void loop(){
lecturaPulsadores();
Ascensor

// Lectura de todos los pulsadores del

switch(estado){
/* xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx */
case 0:
if (botonPulsado(planta)){
y se est en la misma planta.

ESTADO DE REPOSO EN PLANTA n

// En reposo, si se pulsa para abrir la puerta

// Ya sea planta de destino o para seguir

subiendo o bajando
estado = 2;
estadoReposo = ledEstadoApagado(ledReposo);
}
else if (llamadaAscensor(planta)){

// Si se pulsa un boton para subir o bajar

estado = 1;
estadoReposo = ledEstadoApagado(ledReposo);
}
else if (!estadoReposo){
entra una vez para no sobre-escribir los puertos

// Condicin de reposo en una planta. Solo

estadoReposo = ledEstadoEncendido(ledReposo);
numeroPlanta(planta);
}
break;
/* xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx ESTADO DE ENTREPLANTA
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx */
/* xxxxx Activa el motor para subir/bajar el ascensor, y espera la activacin del final
de carrera de la siguiente planta xxxxxxxx */
case 1:
parpadeoLedEstado(ledEntreplanta);
if (sensorFinalCarrera(fCarrera, planta)){
planta. Ascendiendo o descendiendo

// Indicador de entreplanta con parpadeo

// Espera a pasar por la siguiente

actualizarPlanta();
numeroPlanta(planta);

// Se actualiza la planta de llegada

// Planta a la que llegamos

if

// Llegada a planta deseada

(botonPulsado(planta)){
pararMotor();
ledEstadoApagado(ledEntreplanta);
estado = 0;

}
}
else if (!encendidoMotor){
arrancado el motor
estadoAscensor = sentidoAscensor(planta);
se est en reposo. La ascensin es preferente

// Condicin inicial. An no se ha

// Devuelve si se va a subir, bajar o

if (subidaAscensor()){
encendidoMotor = arranqueMotorSubida();
}
else if (bajadaAscensor()){
encendidoMotor = arranqueMotorBajada();
}

// Se est subiendo.
// Se est bajando

}
break;
/* xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx */

ESTADO DE APERTURA/CIERRE DE PUERTA

case 2:
// Si se activa el sensor de seguridad de la puerta --> Algn obstculo
if (sensorSeguridadPuerta(sensorPuerta) && !abriendoPuerta){ // Si se activa el sensor de
seguridad y se est cerrando la puerta
detenerPuerta();
// Detiene el cierre de la puerta
aperturaEmergenciaPuerta();
// Apertura de emergencia
paradaPuerta();
// Mantiene la puerta abierta durante
3 segundos
abriendoPuerta = true;
}
// Proceso normal: apertura + espera + cierre de puerta
else {
// No se activa el sensor de
seguridad
if (botonPulsado(planta)){
// Apertura de puerta
// Cada
pasada, se desplaza una distancia determinada por PASO del servo
if(!estadoPuerta){
// Inicio estado de apertura/cierre
de puerta. Solo entra una vez para no sobre-escribir los puertos
estadoPuerta = ledEstadoEncendido(ledPuerta);
}
aperturaPuerta();
abriendoPuerta = true;
if (puertaAbierta()){
borradoRegistroPlanta(planta);
botn de planta, se abren las puertas
paradaPuerta();
}
}
else if (puertaCerrada()){
estadoPuerta = ledEstadoApagado(ledPuerta);
estado = 0;
se encuentra el ascensor
}
else if(!botonPulsado(planta)){
abriendoPuerta = false;
cierrePuerta();
}
}
break;
}
}

// Por si alguien vuelve a pulsar el

// La puerta ya est cerrada

// Vuelve a reposo en la planta donde
// Proceso de cierre de puerta