Red de conocimiento informático - Descarga de software - Simulación de ascensor

Simulación de ascensor

La principal estrategia de programación para ascensores es responder primero a las solicitudes que se encuentran más alejadas en la dirección actual de viaje. Cuando se cumplen los requisitos, se puede cambiar de dirección. La estrategia sobre dónde se detiene el ascensor cuando no hay ninguna solicitud es diferente. Programar varios ascensores también es complejo. El algoritmo de programación del siguiente programa es idea mía. Puede que no sea bueno, pero básicamente se puede utilizar.

El código fuente del programa es el siguiente:

(Nota: compilado con C Builder 6.0)

// -

# include ltvcl.h gt

# incluir ltSyncObjs.hpp gt

# incluir ltiostream gt

# incluir ltstring gt

# incluir ltvector gt

#Pragma hdrstop

Usar espacio de nombres estándar

int num_piso, num_ascensor, capacidad_ascensor, tiempo_piso, tiempo_parada

TCriticalSection * lock = NULL

Solicitud de estructura

{

Nombre de cadena;

int de

int a;

Sala de ascensor;

TRequest(const string amp; name1, int from1, int to1):

Nombre (name1), from (from1), to (to1)

{

Elevador=-1;

}

};

Vector lt vector ltTRequest gt gt Arriba, abajo, fuera;

Clase TV;

Vector lt TV * gt ascensor

int select_elevator(const TRequest amp; req, int excluir _ ascensor =- 1);

void select_elevator_all()

{

int i, j;

for(I = 0 ;iltup.size ();i)

for(j = 0;j ltup[i].size();j)

{

arriba[i][ j]. ascensor = seleccionar _ ascensor(arriba[I][j]);

}

for(I = 0; i ltdown . size(); i )

for(j = 0;j lt abajo[i].size();j)

{

abajo[i][j].

ascensor = seleccionar _ ascensor(abajo[I][j]);

}

}

// -

TV- me gusta: hilo público

{

Público:

int persona _ num

int id

int cur _ piso

int run_time

int status; //0 - detener, 1 - arriba, 2 - detener arriba, 3 - bajar, 4 - detener abajo;

Boolean full()

{

Número de personas devuelto == capacidad del ascensor;

}

bool tiene (vector constante) ltTRequest gt amp five)

{

for(int I = 0; i lt(int)v . size(); i )

if (v [ i].

ascensor == id)

devuelve verdadero

devuelve falso

}

bool tiene _ arriba _ solicitudes (int cur _ piso)

{

for(int I = cur _ piso; I lt=número de piso; i)

{

If (! full() amp; amphas(arriba[i])

return true

if (i!= cur _ floor ampamp(!full() amp; amphas(abajo[i] ] ]) || tiene(fuera[i]))

{

devuelve verdadero

}

}

Devuelve falso

}

bool tiene _ down _ solicitudes (int cur _ floor)

{

for(int I = cur_floor; i gt = 1; i-)

{

if (!full() amp; amp have(down[i])

devuelve verdadero

if (i! = cur _ floor amp amp(!full() amp; amphas(up[i]) || has(out[i]))

{

Devuelve verdadero

}

}

Devuelve falso

}

bool has_stop_requests(int cur_floor, int status)

{

if(status == 1 amp; amp! full() amp; amp ha estado (en el piso[abajo])

| estado = = 3 amperios completo() amphas(abajo[cur_floor])

Devuelve verdadero

si (tiene(fuera[cur_floor] ])

devuelve verdadero

devuelve falso

}

void process_list(vector ltTRequest gt amp ampaction de cadena constante, bool inc_other = false )

{

Vector ltTRequest gtvtmp

for(int I = 0; i lt(int)v . size(); i )

{

if (inc_other || v[i].elevator==id)

{

if (acción == "en")

{

Si (! Completo())

{

cout lt lt《Ascensor》 lt ltid lt lt":" lt ltv[i]. Nombre lt lt" " " lt ltAction lt ltendl

v[i]. Ascensor = id

Fuera, fuera. A].

push_back(v[I]);

persona_num;

}

Otro

{

vtmp . push _ back(v[I]);

}

}

Otros

{

cout lt lt《Ascensor》 lt ltid lt lt":" lt ltv[i]. namelt lt" " " lt ltactionlt ltendl

person_num-;

}

}

Otro

{

vtmp . push _ back(v[I]);

}

}

v = vtmp

}

Solicitudes de proceso no válidas(int cur_floor, int status)

{

if(status == 2 amp; ampup[cur_floor ].size() )

{

lista_proceso(arriba[cur_floor], " en ", verdadero

}

if(status ==); 4 amperios abajo[cur_floor].

tamaño())

{

process_list(abajo[cur_floor], " en ", verdadero); out[cur_floor], " out ");

seleccione _ ascensor _ todo();

}

Virtual void __fastcall Ejecutar(void)

{

Bloqueo - gt; get();

cout lt lt《Elevator》 lt ltid lt lt": Empezar desde el piso" lt ltcur _ floor lt ltendl

for(;;)

{

Bloquear - gt;Release();

Dormir(10);

bloqueo - gt;get();

run_time;

cambiar(estado)

{

Caso 0 :/ /stop

{

run_time = 0;

break;

}

Caso 1: // arriba

{

if(run_time gt;=tiempo de piso)

{

run_time = 0

cur _ piso ;

cout lt lt《Ascensor》 lt ltid lt lt": Piso de llegada" lt ltcur _ piso lt ltendl

}

Descanso;

}

Caso 2: //Parar hacia arriba

{

if(run_time gt; = tiempo de parada)

{

cout lt "Ascensor" lt lt lt ": Cierra la puerta" lt ltendl

process_requests (piso actual, estado);

run_time = 0;

status = 1;

}

Pausa;

}

Caso 3: //Abajo

{

if(run_time gt;=tiempo de piso)

{

run_time = 0

cur _ piso-;

cout lt lt《Ascensor》 lt ltid lt lt":Llegó al piso" lt ltcur _ piso lt ltendl

}

Pausa;

}

Caso 4: //Detener

{

if(run_time gt;=stop tiempo)

{

cout lt lt《Elevator》 lt ltid lt lt":Cierra la puerta" lt ltendl

process_requests(piso actual, estado);

run_time = 0;

status = 3;

}

Pausa;

}

}

if (run_time! = 0)

{

if(status == 2 ||status == 4)

process_requests(piso actual, estado

);

Continuar;

}

for(;;)

{

bool tiene _ arriba = has_up_requests(cur_floor);

bool has_down = has_down_requests(cur_floor);

if(has_up amp; amp status == 0)

{

estado = 1;

}

else if(has_down amp; amp status= = 0)

{

Estado = 3;

}

bool tiene _ parada = tiene _ parada _ solicitudes(cur _ piso, estado);

if (has_stop amp amp( status == 1 ||status == 3))

{

status;

cout lt lt《Elevator》 lt ltid lt lt":Abre el puerta" lt ltendl

process_requests(piso actual, estado);

}

if(!Haas up amp amp!Tiene down amp amp((estado 2 ) != 0))

{

estado = 0;

}

else if(! Hay un estado de amplificador inactivo == 3)

{

Estado = 1;

}

else if(!Haas up amp amp estado == 1 )

{

status = 3;

}

if (has_stop_requests(cur_floor, status))

Continuar;

Romper;

}

}

//lock- gt();

}

televa tor(int id 1): id(id 1), TThread(true)

{

FreeOnTerminate = true

persona_num = 0;

cur_piso = 1;

tiempo de ejecución = 0

Estado = 0; parada, 1 - arriba, 2 - parada arriba, 3 - abajo, 4 - parada abajo

}

__fastcall ~TElevator()

{

Bloquear-gt; get();

cout lt lt"El ascensor termina..." lt ltendl

Bloquear->liberar();

}

};

int select_elevator(const TRequest & request, int exclusion_elevator)

{

int ascensor=- 1;

int min _ peso =-1;

for(int I = 1; I lt = número de ascensores; i )

{

int target _ piso = req.from

bool arriba

_ dirección =(req . de lt; req. a);

TElevator *p = ascensor [I]

bool ascensor _ arriba =(p- gt; estado = = 1 | p->;estado == 2 | estado = = 4 | ascensor_floor = p->cur _ piso

bool need_up =(elevator_floorlttarget_floor);

int peso;

if(I = = excluir _ ascensor | | p- gt; complete())

{

peso = 4 * piso _ num

}

else if(ascensor piso== piso objetivo amp ascensor_parada)

{

Peso=-número de pisos;

}

else if(p- gt; status == 0)

{

Peso = abs(elevator_floor-target_floor)-floor_number;

}

else if(elevator_floor==target_floor)

{

if(elevator_descending)

{

Peso=Elevator_FloorTarget_Floor-2;

}

Otros

{

Peso = 2 *Cantidad_piso-( Elevator_FloorTarget_Floor);

}

}

Otros

{

if(need_up&elevator_up||!need_up&elevator_down)

{

peso = abs(elevator_floor-target_floor) ;

}

Otros

{

Si (need_start)

{

Peso=Elevator_FloorTarget_Floor-2;

}

Otro

{

Peso = 2 * Cantidad de piso-(Elevator_FloorTarget_Floor);

}

}

Si (need_up! = dirección ascendente)

{

if (dirección ascendente)

{

Peso = 2 *(objetivo _ piso-1) ;

}

Otros

{

Peso = 2*(floor_quantity-target_floor);

}

}

}

if(ascensor == -1 || peso lt peso mínimo)

{

Ascensor = I;

min_weight = peso;

}

}

Regreso ascensor

}

#pragma argsused

int main(int argc, char* argv[])

{

int

I;

lock = new TCriticalSection

cout lt lt"Input floor_elevator number_elevator number_passenger load floor_time stop_time:";

CIN gt; de ascensores gt gt capacidad del ascensor gt gt piso _ tiempo gt gt stop_time

char buf[80]

cin.getline( buf, sizeof(buf));

arriba .resize(piso _ num 1);

abajo .resize(piso _ num 1);

fuera . p>

Ascensor. resize(ascensor número 1);

for(I = 1; i lt=número de ascensores; i)

{

Ascensor[i] = nuevo ascensor(I);

Ascensor[I]- gt; resume();

}

p>

dormir(100) );

int x = 0, y = 0;

lock - gt; get();

cout lt lt Cambiar nombre de entrada a: " lt ltendl

for(;;)

{

Nombre de cadena;

Bloqueo - gt;Release();

Sueño(20);

CIN gt; gtNamegt gtx gt gty;

Bloquear - gt;Get()

//char buf; [80];

//cin.getline(buf, sizeof(buf));

if (x == y)

Continuar;

if(x lt; 1 | | x gt; número de piso)

Continuar

if(y lt ; 1 | >

req . ascensor = seleccione _ ascensor(req);

if(x lt; y)

push _ back(req

p>

Otro

<); p>push_back(req);

}

//lock- gt; release() ;

//Return 0;

}

// -