1

UNIVERSIDAD NACIONAL AUTONOMA DE HONDURAS

FACULTAD DE INGENIERA

INFORME GRUPO #1
PUENTE DUERO

ING. JAIME GALEAS

LENGUAJE DE PROGRAMACION

INTEGRANTES # CUENTA

Sindy Jaquelin Herrera Aguilera 20121004286

Genesis Emeli Izaguirre 20131009494
Selvin Yassir Mayes 20151004061
Estephany Maricela Leon 20111003145
Xenia Cerrato 20081003811
Ronal Joel Espinal 20101001483

Tegucigalpa, Francisco Morazn 28 de Abril del 2017

NDICE
Portada--------------------------------------------------------------------------------------------------1
2

ndice-------------------------------------------------------------------------------------------------- 2

Introduccin------------------------------------------------------------------------------------------ 3

Objetivos-----------------------------------------------------------------------------------------------4

Objetivos generales.------------------------------------------------------------------4

Objetivos especficos.--------------------------------------------------------------- 4

Marco Terico ---------------------------------------------------------------------------------------5

Conclusiones----------------------------------------------------------------------------------------10

Anexos--------------------------------------------------------------------------------------------------11

INTRODUCCION

Uno de los objetivos de una simulacin consiste en disear y desarrollar un modelo

3

De un sistema o proceso y conducir experimentalmente con este modelo para entender el

comportamiento del sistema del mundo real o evaluar varia estrategias con las cuales puedan
operar el sistema.
La simulacin de procesos es una de las ms grandes herramientas de la ingeniera ya que
simplifica Los procesos y los haces ms entendible para el ser humano. Esta simulacin es en
algunos casos casi indispensable.
Para este proyecto se desea realizar una simulacin de un puente, la cual fue desarrollada en el
lenguaje de programacin C++. Para su realizacin se utiliz del paradigma orientado a objetos
Y sus respectivas tcnicas las cuales son: herencia, cohesin, abstraccin, polimorfismo,
Acoplamiento y Encapsulamiento.
El proyecto consiste en una simulacin de un puente, la cual debe tomar en cuenta la cantidad de
carros que cruzan al mismo tiempo, la cantidad de carros en espera, etc. Ms adelante se
explicara ms a detalle en que consiste este proyecto y su funcionamiento.

OBJETIVOS
4

OBJETIVO GENERAL: Conocer el funcionamiento del programa mediante el

lenguaje de programacin C++

OBJETIVOS ESPECIFICOS:

Presentar una abstraccin simplificada de los elementos esenciales en la situacin

descrita.
Hacer uso de los paradigmas y los conceptos aprendidos, especficamente la teora
sobre los nombres, alcances y enlaces vistas en clase.
Tener un mejor manejo de las libreras, sintaxis, manejo de datos y
funcionamiento del lenguaje de programacin C++.
Adquirir experiencia en la realizacin de programas que tienen ms de una lnea
lgica de ejecucin, es decir, programas concurrentes.
Hacer uso del trabajo en equipo para la resolucin de problemas orientados a la
programacin.

MARCO TEORICO
5

El pueblo de Puente Duero debe su nombre a un viejo puente romano sobre el conocido rio. El
puente es estrecho y no permite el cruce de dos coches que circulen en sentidos contrarios. Por su
peculiar forma, alto en el centro y bajo en los extremos, no hay visibilidad, y desde un lado no
podemos saber si hay un coche empezando a cruzar el puente por el otro.

Se han instalado cuatro sensores y dos barreras. Dos sensores indican la llegada de coches en
cada direccin, emitiendo una seal por cada coche que pasa, y los otros dos indican salidas
respectivas. Las barreras bloquean las entradas al puente, y cuando reciben una seal se levantan
para permitir el paso de un coche (y uno solo); acto seguido se vuelven a cerrar.
1. Nunca cruzan simultneamente en el puente vehculos en sentidos opuestos.
2. Nadie espera eternamente para pasar
3. Todos pasan lo ms pronto posible salvo violacin de las normas 1 o 2.
4. Las seales de los sensores se atienden inmediatamente (o al menos lo ms pronto posible),
para no perder el paso de ningn coche.

Se cre una clase cola utilizando apuntadores,

6

En el nodo primero apunta al primer auto que se ingrese en caso de que solo exista un auto en la
cola auto 1 sera tanto el primero como el ultimo, mientras la cola este vaca tanto primero como
ltimo son NULL.

En C podemos crear tipos de datos con la palabra reservada struct esta palabra nos permite crear
un dato que no sea ni string ni int sino que nosotros definimos las propiedades muy parecido al
concepto de clase , en este caso cada dato tipo Nodo tiene dos atributos int dato (almacena la
matrcula del vehculo) y otro dato tipo Nodo *siguiente que tendr tanto un dato como la
direccin a la que apunte La cual se usa en dos ocasiones para crear una cola derecha y una cola
izquierda, se utiliz este TAD (Tipo de dato abstracto) ya que sigue el orden firts in- firts out ya
que necesitamos que el primer auto en entrar a la cola es el primero que salga.

Cada auto se identifica con un nmero de matrcula propiedad que tendr cada objeto de la clase
cola que se asigna de manera aleatoria a los autos con la funcin rand() que es la funcin
utilizada en C para nmeros aleatorios y la propiedad direccin que puede ser izquierda derecha
o ninguno. Utilizar la clase cola nos permiti utilizar la funcin Sacar auto() , Ingresar_auto que
corresponden a el mtodo sacar() y meter() de cualquier TAD Cola respectivamente.
7

Tanto las 2 barreras como los 4 sensores son mtodos booleanos.

Los sensores devuelven true si el atributo sensorD (sensor derecho) que tambin es un atributo
booleano est activado si est activado quiere decir que hay un auto en espera para pasar en el
puente. As respectivamente cada sensor

Si el puente est vaco se activa el atributo barrera1 se llama al mtodo levantar barrera y se da
paso al auto, el auto entra por el puente se cierra la barrera y el sensor vuelve a ser false si no hay
ms autos en la cola de lo contrario contina siendo true.
8

Se cuentan los coches que hay en el puente cada vez que se da paso a un auto en el puente se
aumenta el contador en 1.

El mtodo puente_O verifica si el puente est ocupado si es as hace una espera con la funcin
sleep() y luego se desocupa.

Sino est ocupado imprime directamente puente desocupado

El mtodo levantarb recibe como parmetro la barrera que se quiere levantar

Y cada vez que el auto termina de pasar, y sale del puente se decrementa el contador en 1.

El mximo permitido de coches en cada lado es de 2 autos por lado.

Las siguientes lneas de cdigo:

9

Nos permiten ingresar autos tanto en la cola izquierda como en la cola derecha cada 5 3 y 7
segundos usando clock(), CLOCKS_PER_SEC esto nos permite que el programa sea
concurrente libre de bloqueos.

CONCLUCIONES
10

El programa creado funciono con xito y logro cumplir con los requisitos planteados en
la descripcin de lo que debe hacer el programa.
Se hizo de una manera exitosa del paradigma orientado a objeto y su respectiva
caracterstica.
Se hizo de la abstraccin para mostrar con el programa una versin simplificada de lo que
sera el puente Duero en una situacin de la vida real.
Se aprendi sobre las concurrencia en los programas y sobre cmo aplicarla para el
desarrollo de nuestro proyecto
Se logr aprender ms afondo del uso de las libreras, manejo de datos y funcionamiento
del lenguaje de programacin C++ y finalmente se logr trabajar en equipo de manera
exitosa para la resolucin del problema planteado.

ANEXOS

#include <iostream>
11

using namespace std;

#include <Time.h>

#include <windows.h> //sleep

struct Nodo{

int dato;

Nodo *siguiente;

}*primero,*ultimo=NULL,*primero2,*ultimo2=NULL; //apuntadores

int n,matric;

int x,cuentad=0,cuentai=0;

//sensores

bool p_ocupado=false,sensorD=false,sensorI=false,sensorSD=false,sensorSI=false;

bool barrera1=false,barrera2=false;

void Puente_O();

void Puente_des();

void Cuenta_Colad(int);

void Cuenta_Colai(int);

void Sensor_Ed(); //Entrada derecha

void Sensor_Eiz(); //Entrada izquierda

void Sensor_Sd(); //Salida Derecha

void Sensor_Siz();

void levantarb(bool); //Metodo levantar barrrera

//CLASE COLA

class Cola{
12

private:

int matricula;

string direccion; //izauierdo o derecho

public:

void Ingresar(Nodo *&,Nodo *&,int);

bool Cola_vacia(Nodo *);

void Sacar_auto(Nodo *&,Nodo*&,int &);

void Mostrar_Cola(Nodo *&,Nodo *&);

void Ingresa_unAuto(Cola,Nodo *&,Nodo *&);

Cola(int,string);

Cola(){};

~Cola(){};

};

Cola::Cola(int m,string d){

matricula=m;

direccion=d;

//Funcin determina si la cola esta vaca

bool Cola::Cola_vacia(Nodo *primero){

if(primero==NULL){

return true;

}
13

else{

return false;

void Cola::Ingresar(Nodo *&primero, Nodo *&ultimo,int n){

Nodo *nuevo= new Nodo();

nuevo->dato=n;

nuevo->siguiente=NULL;

if(Cola_vacia(primero)){

primero=nuevo;

cout<<"__________________________________________"<<endl;

cout<<"Auto ingresado";

else{

ultimo->siguiente=nuevo;

cout<<"__________________________________________"<<endl;

cout<<"Auto ingresado";

ultimo=nuevo;

}
14

void Cola::Sacar_auto(Nodo *&primero, Nodo *&ultimo,int &n){

if(Cola_vacia(primero)){

cout<<"Cola vacia, no se puede sacar auto"<<endl;

else{

n=primero->dato;

Nodo *aux=primero;

if(primero==ultimo){

primero=NULL;

ultimo=NULL;

}else{

primero=primero->siguiente;

cout<<"Se dio paso al auto con matricula "<<aux->dato<<endl<<endl;

delete aux;

void Cola::Mostrar_Cola(Nodo *&primero,Nodo *&ultimo){

if(Cola_vacia(primero)){

cout<<endl<<"Cola Vacia, no hay autos"<<endl;

}else{

Nodo *nuevo= new Nodo();

nuevo=primero;
15

while(nuevo!=NULL){

cout<<"Auto con matricula: "<<nuevo->dato<<endl;

nuevo=nuevo->siguiente;

void Cola::Ingresa_unAuto(Cola c1,Nodo *&p,Nodo *&ul){

matric= rand()%99+1;

c1.Ingresar(p,ul,matric);

int main()

Cola Coderecha= Cola();

Cola Coizquierda=Cola();

clock_t start, diff;

int psec;

int sec = 3;

int sec2=5;

int sec3=7;

int iterations = 0;

int maximo=2;
16

string nombre,contra,m;

cout<<"--------------BIENVENIDO AL PUENTE
DUERO------------------"<<endl;

cout<<"..................SENSORES ACTIVADOS......................"<<endl;

cout<<"..................BARRERRAS CERRADAS......................"<<endl;

cout<<endl<<endl;

//Ingresar a la cola derecha

while (iterations < 3) {

start = clock();

while (1) {

diff = clock() - start; //ahora-tic tas inicio a contar

psec = diff / CLOCKS_PER_SEC; //tics tacs totales

//CLOCKS_PE..numeros de tic tacs por segundo

if (psec >=sec) { //>=3 Se ejecuta cada 3 segundos

start=clock();

Coderecha.Ingresa_unAuto(Coderecha,primero,ultimo);

cout<<" - Cola derecha"<<endl<<endl;

Coderecha.Mostrar_Cola(primero,ultimo);

sensorD=true;
17

Sensor_Ed();

Puente_O();

barrera1=true;

levantarb(barrera1);

if(p_ocupado==false){

Coderecha.Sacar_auto(primero,ultimo,x);

barrera1=false;

levantarb(barrera1);

cuentad++;

Cuenta_Colad(cuentad);

p_ocupado=true;

Puente_O();

sensorSD=true;

Sensor_Sd();

Puente_des();

cuentad--;

}else{

cout<<"El puente esta ocupado no puede pasar";

if(psec<=sec2){ //cada 5 segundos

18

barrera2=true;

levantarb(barrera2);

sensorI=true;

Coizquierda.Ingresa_unAuto(Coizquierda,primero2,ultimo2);

cout<<" - Cola izquierda"<<endl<<endl;

Coizquierda.Mostrar_Cola(primero2,ultimo2);

barrera2=true;

Sensor_Eiz();

if(p_ocupado==false & sensorI==false){

Coizquierda.Sacar_auto(primero2,ultimo2,x);

barrera2=false;

levantarb(barrera2);

cuentai++;

Cuenta_Colai(cuentai);

p_ocupado=true;

Puente_O();

Puente_des();

cuentai--;

}else {

cuentai++;
19

if(psec<=sec3){ //cada 7 segundos

Sleep(8000);

Coizquierda.Ingresa_unAuto(Coizquierda,primero2,ultimo2);

cout<<" - Cola izquierda"<<endl<<endl;

Coizquierda.Mostrar_Cola(primero2,ultimo2);

sensorI=true;

Sensor_Eiz();

Puente_O();

if(p_ocupado==false){

for(int a=0; a<maximo;a++){

Coizquierda.Sacar_auto(primero2,ultimo2,x);

sensorSD=true;

Sensor_Siz();

cuentai++;

Cuenta_Colai(cuentai);

Puente_des();

Coderecha.Mostrar_Cola(primero,ultimo);
20

cuentai=cuentai-2;

iterations++;

break;

int m1;

cout<<"----------Cola Derecha--------"<<endl;

Coderecha.Mostrar_Cola(primero,ultimo);

cout<<endl<<endl;

cout<<"----------Cola Izquierda--------"<<endl;

Coizquierda.Mostrar_Cola(primero2,ultimo2);

cout<<endl;

return 0;
21

void Puente_O(){

if(p_ocupado){

cout<<"El puente esta ocupado espere...";

Sleep(12000); //cada auto se tarda 12 segundos en pasar el puente

}else{

cout<<"El Puente esta desocupado"<<endl<<endl;

void Puente_des(){

p_ocupado=false;

cout<<endl<<"Puente desocupado"<<endl<<endl;

void Cuenta_Colad(int c){

cout<<"Hay "<<c<<" autos en el puente lado derecho"<<endl<<endl;

void Cuenta_Colai(int c){

22

cout<<"Hay "<<c<<" autos en el puente lado izquierdo"<<endl<<endl;

void Sensor_Ed(){

if(sensorD){

cout<<"Sensor derecho detecta un auto en espera..."<<endl;

void Sensor_Eiz(){

if(sensorI){

cout<<"Sensor izquierdo detecta un auto en espera..."<<endl;

void Sensor_Sd(){

if(sensorD){

cout<<endl<<"Sensor derecho detecta que un auto salio..."<<endl;

void Sensor_Siz(){

if(sensorI){

cout<<endl<<"Sensor izquierdo detecta que un auto salio..."<<endl;

23

void levantarb(bool b){

if(b){

cout<<endl<<"Abriendo barrera..."<<endl;

}else{

cout<<endl<<"Cerrando barrera..."<<endl;