Go Down

Topic: Ascensor con memoria de llamadas (Read 172 times) previous topic - next topic

Oxxo

Buenas noches, soy nuevo en el foro. Realizo este tema en el foro porque estoy haciendo un prototipo para un ascensor de 5 paradas. PB, 1, 2, 3, 4. Realice el código, lo probé en proteus y físicamente y funciono excelente. Mi consulta es la siguiente: Como hago para que mi ascensor memorice las llamadas realizadas al pulsar el boton correspondiente a un piso?

El ascensor actualmente, solo acepta una llamada a la vez (cuando llega al piso indicado). Mientras eso sucede, no recibe ninguna otra llamada. Quiero que, por ejemplo, realizarle una llamada al piso 1 y luego al 4. Entonces que suba, atienda la del piso 2, despues de "X" cantidad de tiempo, atienda la llamada al piso 4. Y a su vez, mientras va rumbo al piso 4, realizarle una llamada al piso 1, y que al llegar al piso 4, y despues de esperar "X" cantidad de tiempo, vaya al piso 1. Es la lógica normal de un ascensor.

Muchas gracias si me pueden ayudar con eso

IgnoranteAbsoluto

Puedes usar un array de cinco elementos para guardar qué llamadas se han solicitado y están pendientes de atender.

Pero espero que no estés usando delay(). Has de utilizar millis() y máquinas de estados.

En este mismo foro podrás encontrar algunos tutoriales sobre el uso de millis() y máquinas de estados: índice de tutoriales

Oxxo

Ok muchas gracias... ya me pongo a leer los foros

Oxxo

Buenas... Realice varias pruebas para solucionar mi problema, y no pude... no se donde esta el error... mientras realizaba esas modificaciones, aproveche para agregar mas pisos a mi ascensor... ahora va desde el piso 0 hasta el 8, pero sigo con el problema de que solo atiende una llamada a la vez... como seria mas o menos el codigo a implementar para que, mientras ejecute una orden, se memorice otra, y se ejecute al finalizar la primera orden antes dicha... le coloco mi codigo como va;

Quote
#include <EEPROM.h>
const int aa = 2;///primer display
const int ab = 3;
const int ac = 4;
const int ad = 5;
const int ae = 6;
const int af = 7;
const int ag = 8;

const int ba = 9;///segundo display
const int bb = 10;
const int bc = 11;
const int bd = 12;
const int be = 14;
const int bf = 15;
const int bg = 16;

const int SW1 = A0; ///SW ---->> Significa interruptor piso 1
const int SW2 = A1;
const int SW3 = A2;
const int SW4 = A3;
const int SW5 = A4;
const int SW6 = A5;
const int SW7 = A6;
const int SW8 = A7;
const int SW9 = A8;
const int CNY70 = A9;

const int Subir = 17;
const int Bajar = 18;

int entrada1 = 0; ///declaro las variables de entrada digital
int entrada2 = 0;
int entrada3 = 0;
int entrada4 = 0;
int entrada5 = 0;
int entrada6 = 0;
int entrada7 = 0;
int entrada8 = 0;
int entrada9 = 0;
int pisoActual = 1;
int piso = pisoActual;

int sensor = 0;  //declaro la variable del  sensor

void setup() {
  Serial.begin(4800);
  pinMode(aa, OUTPUT);//// declaro los pines a,b,c,d,etc como salidas
  pinMode(ab, OUTPUT);
  pinMode(ac, OUTPUT);
  pinMode(ad, OUTPUT);
  pinMode(ae, OUTPUT);
  pinMode(af, OUTPUT);
  pinMode(ag, OUTPUT);
  pinMode(ba, OUTPUT);
  pinMode(bb, OUTPUT);
  pinMode(bc, OUTPUT);
  pinMode(bd, OUTPUT);
  pinMode(be, OUTPUT);
  pinMode(bf, OUTPUT);
  pinMode(bg, OUTPUT);
  pinMode(Subir, OUTPUT);
  pinMode(Bajar, OUTPUT);
 
  pinMode(SW1, INPUT); //// declaro los SWcomo entradas
  pinMode(SW2, INPUT);
  pinMode(SW3, INPUT);
  pinMode(SW4, INPUT);
  pinMode(SW5, INPUT);
  pinMode(SW6, INPUT);
  pinMode(SW7, INPUT);
  pinMode(SW8, INPUT);
  pinMode(SW9, INPUT);
  pinMode(CNY70, INPUT); //declaro en pin A9(CNY70) como entrada
 
 digitalWrite(Subir, LOW);
 digitalWrite(Bajar, LOW);
Serial.println(EEPROM.read(0));

display1(1);
display2(pisoActual);

}

void loop() {
if(EEPROM.read(0)==255){
pisoActual=1;
piso=1;
EEPROM.write(0,1);
display1(pisoActual);
display2(pisoActual);
Serial.println(EEPROM.read(0));
}else{
display1(pisoActual);
display2(pisoActual);
}
 entrada1 = digitalRead(SW1);//// Asigno los sw a las variables entrada y le digo que las lea como 1 y 0
 entrada2 = digitalRead(SW2);
 entrada3 = digitalRead(SW3);
 entrada4 = digitalRead(SW4);
 entrada5 = digitalRead(SW5);
 entrada6 = digitalRead(SW6);
 entrada7 = digitalRead(SW7);
 entrada8 = digitalRead(SW8);
 entrada9 = digitalRead(SW9);
 
 if(entrada1==HIGH){
   while(entrada1==HIGH){entrada1 = digitalRead(SW1);}
   display1(1);
   piso=1;
   if(pisoActual!=piso){
      MoverAscensor(piso);
   }
 }else if(entrada2==HIGH){
   while(entrada2==HIGH){entrada2 = digitalRead(SW2);}
   display1(2);
   piso=2;
   if(pisoActual!=piso){
      MoverAscensor(piso);
   }
 }else if(entrada3==HIGH){
   while(entrada3==HIGH){entrada3 = digitalRead(SW3);}
   display1(3);
   piso=3;
   if(pisoActual!=piso){
      MoverAscensor(piso);
   }
 }else if(entrada4==HIGH){
   while(entrada4==HIGH){entrada4 = digitalRead(SW4);}
   display1(4);
   piso=4;
   if(pisoActual!=piso){
      MoverAscensor(piso);
   }
 }else if(entrada5==HIGH){
   while(entrada5==HIGH){entrada5 = digitalRead(SW5);}
   display1(5);
   piso=5;
   if(pisoActual!=piso){
      MoverAscensor(piso);
   }
 }else if(entrada6==HIGH){
   while(entrada6==HIGH){entrada6 = digitalRead(SW6);}
   display1(6);
   piso=6;
   if(pisoActual!=piso){
      MoverAscensor(piso);
   }
 }else if(entrada7==HIGH){
   while(entrada7==HIGH){entrada7 = digitalRead(SW7);}
   display1(7);
   piso=7;
   if(pisoActual!=piso){
      MoverAscensor(piso);
   }
 }else if(entrada8==HIGH){
   while(entrada8==HIGH){entrada8 = digitalRead(SW8);}
   display1(8);
   piso=8;
   if(pisoActual!=piso){
      MoverAscensor(piso);
   }
 }else if(entrada9==HIGH){
   while(entrada9==HIGH){entrada9 = digitalRead(SW9);}
   display1(9);
   piso=9;
   if(pisoActual!=piso){
      MoverAscensor(piso);
   }
 }
}
int pisoSubir=0;
int i = 0;
void MoverAscensor(int nuevoPiso){
   pisoSubir = nuevoPiso - pisoActual;// +  +  + "-" +
   Serial.print("Me movere");
   Serial.print(pisoSubir);
   Serial.println("pisos.");
   if(nuevoPiso > pisoActual){
      digitalWrite(Subir, HIGH);
      digitalWrite(Bajar, LOW);
      i=0;
      while(i < pisoSubir){
   Serial.println("Subiendo...");
   sensor = digitalRead(CNY70); // Asigno a la variable sensor es estado de la entrada del CNY70
   if(sensor==HIGH){ //while(digitalRead(CNY70)==HIGH){}
      pisoActual++;
      EEPROM.write(0,pisoActual);
      i=i+1;
      delay(350);
      display2(pisoActual);
   }
      }
      digitalWrite(Subir, LOW);
      digitalWrite(Bajar, LOW);
   }else if(nuevoPiso < pisoActual){
      digitalWrite(Subir, LOW);
      digitalWrite(Bajar, HIGH);
      i=0;
      while(i > pisoSubir){
   Serial.println("Bajando...");
   sensor = digitalRead(CNY70); // Asigno a la variable sensor es estado de la entrada del CNY70
   if(sensor==HIGH){ //while(digitalRead(CNY70)==HIGH){}
      pisoActual--;
      EEPROM.write(0,pisoActual);
      i=i-1;
      delay(350);
      display2(pisoActual);
   }
      }
      digitalWrite(Subir, LOW);
      digitalWrite(Bajar, LOW);
   }
}

void display1(int numero) {
  switch (numero) {
  case 1:
      digitalWrite(aa, HIGH);
      digitalWrite(ab, HIGH);
      digitalWrite(ac, HIGH);
      digitalWrite(ad, HIGH);
      digitalWrite(ae, HIGH);
      digitalWrite(af, HIGH);
      digitalWrite(ag, LOW);
    break;
    case 2: etc....

IgnoranteAbsoluto

Antes que nada, deberías de leer las Normas del foro en Español y sobre todo el punto 7. Uso de etiqueta "code". Sería aconsejable poner todo el código según ese punto o adjuntarlo si es demasiado grande. Creo que en tu caso te has liado y usado la etiqueta [quote] en lugar de [code].

Además deberías de aportar más información, como qué Arduino estás utilizando. Un esquema de conexiones o decir qué y cómo tienes conectado al Arduino. Qué tienes pensado hacer, lo más detalladamente posible. Si, en tu caso, tienes alguna forma de saber en qué piso está o simplemente lo "calculas a ojo".

Para empezar, lo que quieres hacer no se suele hacer "a la fuerza bruta", copiando y pegando una y otra vez las mismas instrucciones cambiando el nombre a un par de variables hasta tener una copia de cada bloque de instrucciones por cada piso que tenga el edificio. Se suelen usar varios arrays en lugar de usar varios "conjuntos de variables". Por ejemplo: en lugar de tener entrada1, entrada2... entrada9, tendrías un array entradas[9]. Aunque lo más probable es que no se necesiten leer todas las entradas "de golpe", sino "barrerlas" y tratarlas una detrás de otra.

Teniendo en arrays los valores con los que vas a trabajar, lo que se hace es un bucle y se tratan uno tras otro, de uno en uno, como si fueran el mismo. Tal vez el bucle sea un for() tradicional o tal vez sea un pseudo for() (mira, si quieres, el post usar millis() junto con for() [SOLUCIONADO] para que te hagas una idea).

Por ejemplo, lo que tú harías así:
Code: [Select]

const int SW1 = A0; ///SW ---->> Significa interruptor piso 1
const int SW2 = A1;
const int SW3 = A2;
const int SW4 = A3;
const int SW5 = A4;
const int SW6 = A5;
const int SW7 = A6;
const int SW8 = A7;
const int SW9 = A8;

void setup() {
  pinMode(SW1, INPUT); //// declaro los SWcomo entradas
  pinMode(SW2, INPUT);
  pinMode(SW3, INPUT);
  pinMode(SW4, INPUT);
  pinMode(SW5, INPUT);
  pinMode(SW6, INPUT);
  pinMode(SW7, INPUT);
  pinMode(SW8, INPUT);
  pinMode(SW9, INPUT);
}


Otros lo haríamos así:
Code: [Select]

const int PINES_SW[] = {A0, A1, A2, A3, A4, A5, A6, A7, A8}; // Definimos un array con los pines de cada piso

const int TOTAL_PISOS = (sizeof(PINES_SW) / sizeof(PINES_SW[0])); // Esto calcula automáticamente cuantos elementos tiene el array PINES_SW

void setup() {
  for (int i = 0; i < TOTAL_PISOS; i++) { // Recorremos todo el array (el primer elemento de un array tiene índice cero)
    pinMode(PINES_SW[i], INPUT);          // Configuramos cada pin como entrada
  }     
}


Si te fijas, agregar o quitar pisos se convertiría en agregar o quitar elementos de un array.

Una cosa que me gustaría saber es si se trata de un proyecto personal o de un trabajo escolar.


Go Up