Informe Proyecto Parqueadero Programación en C

1. Programa.
Nuestro Sistema de parqueadero, tiene 5 acciones básicas ubicadas en un menú

principal, la de ingresar un auto, salida de auto, estado de parqueadero, buscar
auto y finalizar programa. Para cada acción se utilizan diferentes funciones
además de la funciones de simulación, que nos dan ciertas condiciones iniciales
del parqueadero necesarias para la demostración su funcionamiento.
Librerías.
A. Stdio.h.
Esta librería es de las más básica de C, nos permite usar funciones

tales como printf, puts, gets etc. Básicamente esta librería nos permite
utilizar todas las funciones las cuales tienen que ver con la lectura e
impresión de datos ya sea en pantalla o en un fichero.
B. Stdin.h.
Esta librería se encarga de algunos procesos básicos para ejecutar

programas en C/C++. En nuestro programa esta librería nos brinda las
funciones:
 Rand(): Genera números aleatorios.
 Srand(): Da una semilla para generar diferentes aleatorios.
 Atoi(): Nos permita transformar de cadena a enteros.

C. String.h.
Esta librería nos facilita las operaciones con cadenas de caracteres

en general. En nuestro programa esta librería nos permite usar la función
strlenght(), la cual nos indica que tan larga es una cadena de caracteres.
D. Ctype.h.
Esta librería nos permite modificar y saber la naturaleza de las

variables de tipo char. En nuestro programa, utilizamos la función
toupper(), para poder transformar ciertos caracteres a mayúsculas.
E. Conio.h y Conio2.h
Estas librerías nos permiten utilizar variadas funciones para
facilitar la impresión en pantalla. Las funciones utilizadas de estas
funciones son:
 Gotoxy(): Esta función nos permite ubicar el curosr en un
punto determinado de la pantalla y asi junto con printf se
puede escribir un texto en cualquier lugar de la pantalla
.
 Textbackground(): Esta función nos permite cambiar el
color de fondo de la pantalla y puede ser limitada por
otras textbackgrounds crenado así diferentes colores en la
pantalla.
 Textcolor(): Esta función nos permite darle un color

determinado a un texto.
F. Time.h.
Esta librería nos permite trabajar con el tiempo del ordenador y

poder imprimir de diferentes maneras el tiempo además de poder
manejar los segundos transcurridos en un intervalo. De esta librería
utilizamos las funciones:
 Time(): Nos da el número de segundos desde 1979.
 Difftime(): Nos da la diferencia en segundos de dos times().
 Localtime: Transforma el time(), a lo que nosotros elijamos,
ya sea añon, minutos, segundos, etc.
Aparte de estas funciones, también utilizamos macros y estructuras tales
como:
 Time_t: Crea una variable para guardar un time().
 Struct tm: Crea una varibale para guardar un localtime().
Estructuras
A. Plc.
Esta estructura contiene dentro de ella un arreglo y una variable y
se encarga de tener los datos de una placa de vehiculo. El arreglo es de
tipo char y de tamaño 3, en el se guarda la parte alfabética de una placa
de auto.
La variable es de tipo int y en ella se guarda la parte numérica de la placa
de un auto.
B. Ats.
Esta estructura nos permite guardar dentro de ella datos del carro
que ingresa al parqueadero como su placa, tiempo de ingreso y de salida
y su código. La placa se guarda en una varible de tipo “plc”. El tiempo
de ingreso y de salida, se guardan en dos varibales respectivamente de
tipo time_t. Finalmente el código se guarda en un arreglo de tipo entero y
tamaño 3.
C. Est.
Esta estructura es la encargada de guardar los datos relacionados
con un puesto de parqueo, como su estado y el auto que se encuentra
estacionado en este puesto.La función tiene dos variables. La primera,
llamada autos, es de tipo ats y permite guardar en ella todas las
características del auto que esta estacionado. La segunda llamada estado
es de tipo entero y contiene números entre 0 y 1. Los cuales representan
si el parqueadero esta vacío o lleno respectivamente.
Definiciones
En el programa se definieron varios valores los cuales ayudaron
en algunos aspectos del programa como la simulación, el poder graficar
los parqueaderos, etc. Los valores definidos fueron:
 MAXniv: Este valor da el número de niveles que tendrá el
parqueadero. Este valor ayuda en toda operación que tenga que ver
relacionada con guardar datos en la matriz.
 MAXfil: Este valor da el número de filas que existe en el
parqueadero. Este valor ayuda en toda operación que este
realacionada con guardar datos en la matriz.
 MAXfil: Este valor da el número de columnas que existe en el

parqueadero. Este valor ayuda en toda operación que este
realacionada con guardar datos en la matriz.
 BLOQUES: Este valor da el número de carros que existirá por bloque

en parqueadero. El valor ayuda en el proceso de graficado del
parqueadero y sus calles verticales.
 ESPini: Este valor nos permite dar un espaciado inicial al momento

de graficar el parqueadero.
 SIMcte: Este valor es exclusivo para el proceso de simulación, guarda

un valor en segundo para simular que un carro ha estado mas tiempo
en el parqueadero.
2. Funciones.
Simulación:
Para la simulación del parqueadero fueron utilizadas tres funciones, las cuales se
encargaron de generar autos, y de posicionarlos en posiciones aleatorias de
parqueo, aparte de asignarles un tiempo de entrada, una placa y un código propio
de salida. Las funciones utilizadas fueron:
A. Randómicos.
“int randomico(int min,int max);
Esta función se encarga de crear números aleatorios en un intervalo

dado. La función toma como parámetros dos números enteros, los cuales
se usaran como los límites del intervalo de creación. Primero
B. Generar Placas Aleatorias.
“void gPlcAlf(est parqueos[ ][ ][MAXcol ], int i, int j, int k);
Esta función se encarga se generar la parte alfabética de una placa

de auto. Los parámetros que utiliza son una variable de tipo “est” la cual
tiene toda la información hacer de nuestro parqueo, y tres variable de tipo
entero, cuya función es entregarnos la ubicación del carro en nuestra
matriz parqueos. Una vez recibidos los parámetros, lo primero que
realiza la función es crear un arreglo, “letras [26]”, del tamaño de las
letras del alfabeto y definirlo con todas las letras mayúsculas de este.
Después se crean dos variables de tipo entero, una variable “l” que
maneja nuestro lazo “for”, y una variable “n”, la cual se encarga de
guardar un numero aleatorio generado por la función randómicos.
Iniciamos nuestro lazo “for”, el cual va desde 0 hasta 4, y lo primero que
haremos será guardar en “n” un randomico entre 0 y 26. Siguiente de esto
se realiza una condición, que guarda un “\n”, en caso de que se llegue a la
última posición, es decir cuando l=3, caso contrario se guardara en la
estructura “parqueos[i][j][k].autos.placa.Pcar[l]” una letra aleatoria de
nuestro arreglo inicial, la cual será elegida por “n” de esta manera “letras
[n]”. La definición quedara de esta manera:
“parqueos[i][j][k].autos.placa.Pcar[l]= letras [n]”;
C. Generar Datos Iniciales

“void iniciarparqueos(est parqueos[ ][ ][MAXcol ]);
Esta es una función de tipo void y se encarga de llenar nuestro

arreglo de tipo “est” con todos los datos necesarios para la simulación.
Esta función toma como parámetro único un arreglo multidimensional de
tipo “est” llamado parqueos, pues este arreglo llevara las condiciones
iniciales del parqueo para la simulación. Lo primero que realiza nuestra
función es crear tres variables de tipo entero i,j,k las cuales se van a
encargar de controlas nuestros lazos “for” y también darnos la posición a
modificar en nuestro arreglo multidimensional “parqueos[i][j][k]”.
También se definirá un “srand” el cual tomará como parámetro un
time(NULL), con la finalidad de tener siempre condiciones de
simulación diferentes, cada vez que se ejecute el programa. Después
crearemos tres lazos “for” anidados, los cuales controlaran desde el
exterior hasta el interior, nuestro nivel, filas y columnas de la matriz
parqueos respectivamente. En nuestro lazo interior, se realizaran las
asignaciones de valores para la estructura. Para empezar, con la función
randomicos, se crearan número entre el 0 y el 1, los cuales serán
guardados en el arreglo “parqueos [i] [j] [k].estado”. A continuación se
analizará este arreglo en la posición indicada, si el valor de
parqueos.estado es 0, entonces no se realizará ninguna modificación
extra a nuestro arreglo. Pero si el valor de parqueos.estado es 1, entonces
se le asignara en su estructura de autos, un código de salida en y un
tiempo de ingreso dado por la función time(NULL). En su estructura de
placa, “parqueos.autos.placa”, se le asignará un número de placa en
“Pnum” y con la función “gPlcAlf” una parte alfabética en “Pcar”.
Control de Impresión.
D. Imprimir Encabezado.
“void imprimirEncabezado();
Esta función se encarga e imprimir el encabezado del programa

en cada una de las pantallas que se abran. Este encabezado contiene
datos de la creación del programa. La función contiene 7 arreglos de tipo
char, donde cada uno de ellos contienen los caracteres de una línea de
encabezado. Por ejemplo los arreglos linea1 y línea 7 contienen los
márgenes superiores e inferiores respectivamente. Mientras que las líneas
internas contienen los datos del programa. Cada posición de impresión
de línea es controlada por la función gotoxy().
E. Imprimir Menu.
“void dibujarMenu();
Esta función al igual que la de imprimir encabezado, no recibe
ningún parámetro. La función es la encargada de imprimir en pantalla el
menú principal donde una puede elegir las diferentes acciones que puede
ejecutar el programa. Esta función usa dentro de ella la función de
imprimir el encabezado.
F. Movimiento Cursor.
“int movimientocursor();
Al igual que las otras dos funciones, esta no recibe ningún

parámetro. Esta función se encarga de hacer que se mueva un cursor en
el menú principal, de manera que la opción que uno vaya a elegir estará
resalta por un fondo verde .La función es de tipo int, pues devuelve un
entero al main. Esta función crea 4 variables. 3 de tipo entero que son: x,
que es la variable de condición de parada en el lazo do,while interno; fin,
que es la variable de condición de parada en el lazo do, while externo y
posCursor, la cual nos da la posición del cursor en el menú y es retornada
al main.. Tambien hay una variable de tipo char llamada Cursor, en la
cual se almacena las teclas presionadas para moverse en el menú.
La función utiliza un lazo do,while que se encarga de mantener al cursor
en movimiento hasta que se seleccione una opción y se retorne un valor.
Internamente en este lazo, hay otro lazo do,while encargado de guardar
el valor de un carácter dentro de la variable Cursor. Este lazo solo se
detiene si se presiona arriba, abajo o enter. Después de haber presionado
correctamente las teclas, la función utiliza una condición múltiple que
analiza cual fue la tecla aplastada y dependiendo de esto da un valor a la
variable posCursor, de manera que si uno aplasta arriba el valor del
posCursor disminuirá y lo contrario si una aplasta abajo. En caso de que
se presione enter, la función retornara el valor de la variable posCursor al
main.
Si no se ha presionado enter, la función utilizará otra condición múltiple
la cual analizara la posición del cursor y dependiendo de la posición que
tenga en el menú, volverá a imprimir el menu, pero con la posición del
cursor resaltada, y se reiniciara el lazo do,while .
G. Imprimir Parqueaderos
“void imprimirparqueos(est parqueos[ ][ ][MAXcol ]);
Esta función recibe como único parámetro un arreglo de tipo est

llamado pruebas. La función se encarga de imprimir una imagen creada
con caracteres para poder visualizar el parqueadero y ver que espacios
están disponibles y cuales están ocupados. La función colorea de verde a
los espacios disponibles los cuales serán identificados con un 0, y
coloreara de rojo los espacios ocupados los cuales serán identificados
con un rojo.
H. Imprimir Hora.
“void imprimirHora(int x, int y, int z);
Esta función recibe como parámetros tres variables de tipo entero,

las cuales son la hora, los minutos y los segundos respectivamente. Esta
función imprime de manera adeacuada la hora, minutos y segundos,
agregando un 0 a cada una de estas en caso de que su valor sea menor a
10.
I. Imprimir Factura.
“void imprimirFactura(est parqueos[ ][ ][MAXcol ], int

pago, float diffseg, int x, int y, int z);
Esta función se encarga de imprimir los datos que van a salir en

la factura del consumidor, como la hora de ingreso, de salida, el valor a
pagar, la placa del vehículo. La función recibe como parámetros todos
los valores los cuales vaya a imprimir y la diferencia de segundos entre
el tiempo de ingreso y el tiempo. La función realiza dentro de ella una
operación con el tiempo para mandar la hora, minutos y segundos a la
función imprimir hora.
J. Mover SI/NO
“int movsino();
Esta función se encarga de crear un pequeño menú de dos

opciones, si o no. Estas son seleccionadas mediante un cursor que
resaltará la opción la cual estemos seleccionando. Su funcionamiento es
similar al de la función que controla el movimiento del cursor en el menú
principal , con la diferencia de que solo tiene dos acciones.
Acciones
K. Validar Placa Numérica.
“int validarNum(est parqueos[ ][ ][MAXcol ], int i, int j, int

k);
La función señalada se encarga de validar si un numero leído es
menor que 9999. En caso de que sea verdadero, la función retornara un
valor igual a 1, caso contrario retornara un valor igual a 0.
L. Validar Placa Alfabética.
int validarPlaca(est parqueos[ ][ ][MAXcol ], int i, int j, int

k);
La función valida que cada uno de los tres elementos del arreglo
placa, sean letras mayúsculas. Si esto es verdadero la función retornara al
main un 1, caso contrario retornara un 0.
M. Ingresar un Auto
void ingresarAuto(est parqueos[ ][ ][MAXcol ], int cont0);
Esta función toma como parámetros un arreglo de tipo est, el cual

son los parqueos y un entero cont0 el cual nos deja saber cuantos
parqueaderos están disponibles. La función empieza analizando si
existen parqueaderos vacíos comparando el cont0 con 0. Si es que
existen parqueaderos disponibles la función continuara, si no la función
imprimirá un mensaje de error y retornara al main. En caso de que
existan parqueaderos disponibles, se procederá a buscar que parqueadero
está disponible y enviará al auto a esta posición. A continuación se
cambiara en la matriz parqueos el estado por un 1 para saber que ahora
esta posición está ocupada y en la estructura autos se asignara un tiempo
de ingreso al auto, y finalmente se le dará su código de salida. Después
se procederá a leer la placa y el número de placa manualmente y
mediante la función validar placa y validar num, se asegurara que la
placa ingresada será correcta. Al final en la pantalla se imprimirá el
código de salida del auto para que el consumidor lo pueda guardar.
N. Facturar Auto.
void facturarAuto(est parqueos[ ][ ][MAXcol ], int cont0);
Esta función toma los parámetros parqueos y cont0 para su

funcionamiento. La función primero determina si es que hay vehículos en
el estacionamiento. Si esto es falso, entonces se imprimirá un mensaje de
error y retornara al main. Si es verdadero se procederá a leer el código de
ingreso que se entregado a cada cliente al momento de entrar al
parqueadero. Se validara el código de ingreso, si este mal escrito, o si
este no lleva a ningún carro, entonces se imprimirá un mensaje de error y
se retornara al main. Caso contrario se verificara cuanto tiempo ha estado
el carro seleccionado parqueado. Si es tiempo es menor a una hora no se
cobrara nada, si el tiempo es mayor a una hora se preguntara al cliente si
tiene una factura de consumo. Si la tiene al cliente se le descontara un
dólar del pago total, en caso de que no tengo una factura de consumo se
procederá a facturar al auto sin descuento alguno. Finalmente se enviará
todos los datos a la función imprimir factura y se imprimirá en pantalla
los datos y el valor a pagar.
O. Estado del parqueadero.
int frecuencia(est parqueos[ ][ ][MAXcol ]);
La función frecuencia es la encargada de contar cuantos unos y

cuantos ceros están guardados en la matriz parqueos.estado. Esta función
imprime en pantalla el número de estacionamientos disponibles y el
número de parqueaderos ocupados y retorna al main el valor de los
parqueaderos disponibles.
P. Buscar Auto.
void BuscarAuto(est parqueos[ ][ ][MAXcol ], int cont0);
Esta función es muy parecida de cierta manera a facturar auto. La

función pide el código de salida del auto al cliente y busca el lugar a
donde fue enviado el auto del cliente. Si no existe el carro o el código de
salida es erróneo, se imprime un mensaje de error y se retorna al main.
Caso contrario se imprime en pantalla la placa del auto y el nivel, fila y
columna en la cual se encuentra.
Q. J
3. MAIN
El main del programa se encarga de ordenar las diferentes funciones y

realizar diferentes operaciones con ellas para así crear un programa que
funcione.
En el main, lo primero que se realiza es la creación de algunas variables como:
 Parqueos [MAXniv][MAXfil][MAXcol] : Este es un arreglo de tipo “est” y
en esta matriz de 3 dimensiones están todos los espacios de parqueo de
nuestro estacionamiento. En esta variable se almacenaran todos los datos
relacionados con el parqueo y el auto que se encuentre ahí.
 Cont0: Esta variable de tipo entero será la encargada de almacenar el

numero de parqueaderos vacios que existen en nuetro parqueadero. El valor
de esta variable estará dado por la función frecuencia().
 Opc: Esta variable es la encargada de almacenar el dato retornado por la

función movimientocursor();
Una vez creadas las variables del main, se procede imprimir el encabezado y
titulo de el programa. Después se llama a la función iniciarparqueos() y se crean
las condiciones iniciales para la simulación. Es entonces cuando se abre el menú
principal en la pantalla y se manda a la función movimientocursor() para que
devuelva un valor a opc. Con una función switch() se crea diferentes
condiciones dependiendo del valor de opc. Estas opciones son:
 Si OPC es 0, el programa ingresa un auto al parqueadero. Para esto se

manda la función ingresarAuto().
 Si OPC es 1, el programa factura un auto que sale del parqueadero. Para
esto se envía a la función facturarAuto().
 Si OPC es 2, el programa imprime las posiciones de parqueo. Para esto
se usa la función imprimirparqueaderos().
 Si OPC es 3, el programa indica donde se encuentra el auto del cliente.
Para esto se envía la función buscarAuto().
 Finalmente si OPC es 4, entonces el programa finaliza y retorna al main
un 0.
Siempre al inicio de las funciones que guardan valores ingresados por teclado, se
utiliza la función fflush() para limpiar el buffer, en cada opción de la función
switch(), se limpia la pantalla, se manda a la función y para finalizar se vuelve a
imprimir el encabezado y el menú. Finalmente en cada opción del switch(), se
mandara la función movimientocursor() para así voler a elegir una opción del
menú.
4. Diagrama de Bloques.
5. Código
#include <stdio.h>
#include <ctype.h>
#include <string.h>
#include<stdlib.h>// LIBRERIA PARA GENERAR RANDOMICOS
#include <time.h>//LIBRERIA PARA TRABAJAR CON TIEMPO
#include <conio2.h>// LIBRERIA PARA CAMBIAR COLOR DE FUENTE
#define MAXfil 4 //MAXIMO DE FILAS
#define MAXcol 6 //MAXIMO DE COLUMNAS
#define MAXniv 1 // MAXIMO DE NIVELES
#define BLOQUES 3 // BLOQUES POR FILA
#define ESPini 10 //ESPACIADO INICIAL
#define SIMcte 3600
typedef struct {
char Pcar[3];
int Pnum;
}plc;//PLACA-MATRICULA
typedef struct {
time_t tiempoIngreso,tiempoSalida;
plc placa;
int codigo[3];
}ats;//AUTOMOVILES
typedef struct {
ats autos;
int estado;
}est;//ESTACIONAMIENTO
void imprimirEncabezado();
void imprimirHora(int x, int y, int z);
int validarNum(est parqueos[MAXniv][MAXfil][MAXcol],int i, int j, int k);
int validarPlaca(est parqueos[MAXniv][MAXfil][MAXcol],int i, int j, int k);
void imprimirFactura(est parqueos[MAXniv][MAXfil][MAXcol], int pago, float
diffseg,int i, int j, int k);
int movsino();
void facturarAuto(est parqueos[MAXniv][MAXfil][MAXcol],int cont0);
void ingresarAuto(est parqueos[MAXniv][MAXfil][MAXcol],int cont0);//
Ingresa un auto a la base de datos.
void buscarAuto(est parqueos[MAXniv][MAXfil][MAXcol],int cont0);
void gPlcAlf(est parqueos[MAXniv][MAXfil][MAXcol],int i, int j, int k);//
GENERA LA PARTE ALFABETICA DE LA PLACA(SIMULACION)
void dibujarMenu();// DIBUJA EL MENU
int movimientocursor();// MUEVE EL CURSO DEL MENU PARA PODER
ELEGIR UNA OPCION
void iniciarparqueos(est parqueos[MAXniv][MAXfil][MAXcol]);// DA LA
CONDICIONES INICIALES DEL ESTACIONAMIENTO Y DEFINE LOS
TIEMPOS INICIALES.(SIMULACION)
int randomicos(int min, int max);//GENERA RANDOMICOS ENTRE DOS
VALORES DADOS.(SIMULACION)
int frecuencia(est parqueos[MAXniv][MAXfil][MAXcol]);//DETERMINA
CUANTOS ESTACIONAMIENTOS LIBRES Y CUANTOS OCUPADOS
HAY
void imprimirparqueaderos(est parqueos[MAXniv][MAXfil][MAXcol]);//
DIBUJA EL ESTACIONAMIENTO CON SUS LUGARES LIBRES Y
OCUPADOS
int main(){
est parqueos[MAXniv][MAXfil][MAXcol];
int opc,cont0;
imprimirEncabezado();
iniciarparqueos(parqueos);
//cont0=frecuencia(parqueos);
//imprimirparqueaderos(parqueos);
dibujarMenu();
opc=movimientocursor();
do{
switch(opc){
case 0:
fflush(stdin);
clrscr();
ingresarAuto(parqueos,cont0);
system("cls");
dibujarMenu();
break;
case 1:
fflush(stdin);
clrscr();
facturarAuto(parqueos,cont0);
system("cls");
dibujarMenu();
break;
case 2:
clrscr();
cont0=frecuencia(parqueos);
imprimirparqueaderos(parqueos);
system("cls");
dibujarMenu();
break;
case 3:
clrscr();
buscarAuto(parqueos,cont0);
clrscr();
dibujarMenu();
break;
case 4:
opc=5;
system("cls");
gotoxy(5,5);printf("PROGRAMA TERMINADO\n");
break;
}
}while(opc!=5);
getchar();
return 0;
}
void imprimirHora(int x, int y, int z){

if(x<10){
printf("0%d:",x);
}else{
printf("%d:",x);
}
if(y<10){
printf("0%d:",y);
}else{
printf("%d:",y);
}
if(z<10){
printf("0%d",z);
}else{
printf("%d",z);
}
}
void imprimirFactura(est parqueos[MAXniv][MAXfil][MAXcol], int pago, float

diffseg,int i, int j, int k){
clrscr();
int xo,yo,zo,xf,yf,zf,diffsec,diffmin,diffh;
struct tm *horaIngreso;
horaIngreso=localtime(&parqueos[i][j][k].autos.tiempoIngreso);
xo=horaIngreso->tm_hour;
yo=horaIngreso->tm_min;
zo=horaIngreso->tm_sec;
diffsec=(int)difftime(parqueos[i][j][k].autos.tiempoSalida,parqueos[i][j][k].autos
.tiempoIngreso);
zf=zo;
xf=xo;
yf=yo;
if(zo+diffsec>59){
diffmin=(zo+diffsec)/60;
zf=(zo+diffsec)%60;
if(yo+diffmin>59){
diffh=(yo+diffmin)/60;
yf=(yo+diffmin)%60;
xf=xo+diffh;
}else{
yf=yo+diffmin;
}
}else{
zf=zo+diffsec;
}
gotoxy(2,9);printf("FACTURA..................");
gotoxy(4,11);printf("Hora de Ingreso........");
gotoxy(20,12);imprimirHora(xo,yo,zo);
gotoxy(4,14);printf("Hora de Salida.........");
gotoxy(20,15);imprimirHora(xf,yf,zf);
gotoxy(4,17);printf("Matricula del Vehiculo.");
gotoxy(20,18);printf("%s -
%d",parqueos[i][j][k].autos.placa.Pcar,parqueos[i][j][k].autos.placa.Pnum);
gotoxy(4,20);printf("Total a pagar..........");
gotoxy(20,21);printf("%d.00 USD \n\n",pago);
printf ("Presione ENTER para Pagar");
getchar();
void imprimirEncabezado(){
char
linea1[]={"*******************************************************
*********************************************"};
char linea2[]={"*
*"};
char linea3[]={"* Sistema de Parqueaderos
*"};
char linea4[]={"* Proyecto de Programacion
*"};
char linea5[]={"* Escuela Politecnica Nacional
*"};
char linea6[]={"*
*"};
char
linea7[]={"*******************************************************
*********************************************"};
textbackground(LIGHTGRAY);textcolor(BLACK);highvideo();
gotoxy(1,1);printf("%s",linea1);
textbackground(BLACK);textcolor(WHITE);
return;
}
int validarPlaca(est parqueos[MAXniv][MAXfil][MAXcol],int i, int j, int k){

int m;
int cont1=0;
for(m=0;m<3;m++){
if(parqueos[i][j][k].autos.placa.Pcar[m]>=65 &&
parqueos[i][j][k].autos.placa.Pcar[m]<=90){
cont1++;
}
}
if(cont1==3){
if(strlen(parqueos[i][j][k].autos.placa.Pcar)==3){
return 1;
}else{
return 0;
}
}else{
return 0;
}
}
int validarNum(est parqueos[MAXniv][MAXfil][MAXcol],int i, int j, int k){

if(parqueos[i][j][k].autos.placa.Pnum<=9999){
return 1;
}else{
return 0;
}
}
int movsino(){
int x=0,fin=0,posCursor=0;
char cursor;
textbackground(GREEN);
gotoxy(4,14);printf("1.Si ");
textbackground(BLACK);
gotoxy(4,15);printf("2.No ");
do{
do{
cursor=getch();
if(cursor==72 || cursor== 80 || cursor==13){
x=1;
}
}while(x!=1);
switch(cursor){
case 80:
if(posCursor==1){
posCursor=0;
}else{
posCursor++;
}
//printf("\n%d",posCursor);
break;
case 72:
if(posCursor==0){
posCursor=1;
}else{
posCursor--;
}
break;
case 13:
return posCursor;
}
switch(posCursor){
case 0:
break;
case 1:
break;
}
}while(fin==0);
return 0;
}
void facturarAuto(est parqueos[MAXniv][MAXfil][MAXcol],int cont0){

int i,j,k,pago,opc;
float diffseg;
char codigo[8];
if(cont0==(MAXniv*MAXfil*MAXcol)){
system("cls");
gotoxy(2,9);printf("Error");
gotoxy(2,11);printf("No hay vehiculos en el parqueadero");
gotoxy(2,11);printf("Presione cualquier tecla para volver al Menu");
getchar();
return;
}
gotoxy(2,9);printf("FACTURA");
gotoxy(2,11);printf("Ingrese codigo de Salida: ");
fgets(codigo,9,stdin);
getchar();
i=atoi(codigo);
j=atoi(&codigo[3]);
k=atoi(&codigo[6]);
if(parqueos[i][j][k].estado==0){
system("cls");
gotoxy(5,12);printf("CODIGO INGRESADO INVALIDO");
gotoxy(5,14);printf("Presione Enter para Regresar al Menu");
getchar();
return ;
}else{
parqueos[i][j][k].estado=0;
parqueos[i][j][k].autos.tiempoSalida=time(NULL)+SIMcte;
diffseg=difftime(parqueos[i][j][k].autos.tiempoSalida,parqueos[i][j][k].autos.tie
mpoIngreso);
if(diffseg<3600){
pago=0;
}else{
if(diffseg<7200){
gotoxy(2,13);puts("Tiene factura de consumo?");
opc=movsino();
if(opc==0){
pago=0;
}else{
pago=1;
}
}else{
pago=(int)diffseg/3600;
}
}
fflush(stdin);
imprimirFactura(parqueos,pago,diffseg,i,j,k);
clrscr();
gotoxy(5,12);printf("PAGO REALIZADO EXITOSAMENTE");
gotoxy(5,14);printf("Puede salir\n\n\n");
printf("Presione cualquier tecla para volver al Menu.");
getchar();
return ;
}
}
void buscarAuto(est parqueos[MAXniv][MAXfil][MAXcol],int cont0){

int i,j,k,pago,opc;
float diffseg;
char codigo[8];
if(cont0==(MAXniv*MAXfil*MAXcol)){
system("cls");
gotoxy(2,11);printf("No hay vehiculos en el parqueadero");
getchar();
return;
}
gotoxy(2,9);printf("BUSCAR AUTO");
gotoxy(2,11);printf("Ingrese codigo de Salida: ");
fgets(codigo,9,stdin);
getchar();
i=atoi(codigo);
j=atoi(&codigo[3]);
k=atoi(&codigo[6]);
system("cls");
gotoxy(5,12);printf("CODIGO INGRESADO INVALIDO");
getchar();
return ;
}else{
system("cls");
gotoxy(5,9);printf("Auto encontrado: %s-
%d",parqueos[i][j][k].autos.placa.Pcar,parqueos[i][j][k].autos.placa.Pnum);
gotoxy(5,12);printf("Su auto se encuentra en el nivel: %d",i);
gotoxy(5,13);printf(" fila: %d",j);
gotoxy(5,14);printf(" columna: %d",k);
getchar();
return;
}
}
void ingresarAuto(est parqueos[MAXniv][MAXfil][MAXcol], int cont0){

int i,j,k,x=0;
struct tm *horaIngreso;
if(cont0==0){
system("cls");
gotoxy(5,12);printf("No hay espacios disponibles");
gotoxy(5,14);printf("Presione cualquier tecla para regresar al Menu ");
getchar();
return ;
}
do{
srand(time(NULL));
i=randomicos(0,MAXniv);
j=randomicos(0,MAXfil);
k=randomicos(0,MAXcol);
parqueos[i][j][k].autos.codigo[0]=i;
parqueos[i][j][k].autos.codigo[1]=j;
parqueos[i][j][k].autos.codigo[2]=k;
parqueos[i][j][k].autos.tiempoIngreso=time(NULL);
x=1;
}
}while(x!=1);
horaIngreso=localtime(&parqueos[i][j][k].autos.tiempoIngreso);
gotoxy(2,9);printf("Hora de Ingreso: ");
gotoxy(2,10);imprimirHora(horaIngreso->tm_hour,horaIngreso-
>tm_min,horaIngreso->tm_sec);
gotoxy(2,11);printf("\nDatos Placa:");
//fflush("stdin");
gotoxy(2,13);printf ("\tIngrese Parte Alfabetica (Mayusculas): ");
fgets(parqueos[i][j][k].autos.placa.Pcar,4,stdin);
//parqueos[i][j][k].autos.placa.Pcar[3]='\0';
//printf(" %d ",strlen(parqueos[i][j][k].autos.placa.Pcar));
parqueos[i][j][k].autos.placa.Pcar[0]=toupper(parqueos[i][j][k].autos.placa.Pcar[
0]);
1]);
2]);
if(validarPlaca(parqueos,i,j,k)==0){
parqueos[i][j][k].autos.codigo[0]=-i;
parqueos[i][j][k].autos.codigo[1]=-j;
parqueos[i][j][k].autos.codigo[2]=-k;
parqueos[i][j][k].autos.tiempoIngreso=0;
system("cls");
gotoxy(5,12);printf("Placa Ingresada no Valida");
getch();
return;
}
gotoxy(2,15);printf("\n\tIngrese Parte Numerica: ");
scanf("%d",&parqueos[i][j][k].autos.placa.Pnum);
if(validarNum(parqueos,i,j,k)==0){
parqueos[i][j][k].autos.codigo[0]=-i;
parqueos[i][j][k].autos.codigo[1]=-j;
parqueos[i][j][k].autos.codigo[2]=-k;
parqueos[i][j][k].autos.tiempoIngreso=0;
system("cls");
gotoxy(5,12);printf("Placa Ingresada no Valida");
getchar();
getchar();
return;
}
clrscr();
gotoxy(5,12);printf("DATOS INGRESADOS SATISFACTORIAMENTE");
if(k<10 && j<10){
gotoxy(5,13);printf("Su codigo para salir es:
0%d.0%d.0%d\n\n\n",parqueos[i][j][k].autos.codigo[0],parqueos[i][j][k].autos.c
odigo[1],parqueos[i][j][k].autos.codigo[2]);
}else{
if(k>10 && j>10){
0%d.%d.%d\n\n\n",parqueos[i][j][k].autos.codigo[0],parqueos[i][j][k].autos.codi
go[1],parqueos[i][j][k].autos.codigo[2]);
}else{
if(k>10){
0%d.0%d.%d\n\n\n",parqueos[i][j][k].autos.codigo[0],parqueos[i][j][k].autos.co
digo[1],parqueos[i][j][k].autos.codigo[2]);
}else{
0%d.%d.0%d\n\n\n",parqueos[i][j][k].autos.codigo[0],parqueos[i][j][k].autos.co
digo[1],parqueos[i][j][k].autos.codigo[2]);
}
}
}
getchar();
getchar();
return;
}
void gPlcAlf(est parqueos[MAXniv][MAXfil][MAXcol],int i, int j, int k){

char letras[] =
{'A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y'
,'Z'};
char prov[] =
{'P','P','P','P','P','P','P','G','G','G','G','G','P','P','A','A','I','I','T','T','M','M','P','P','G','G'
};
int n,l;
for(l=0;l<4;l++){
n=randomicos(0,26);
if(l==0){
parqueos[i][j][k].autos.placa.Pcar[l]=prov[n];
}
if(l==3){
parqueos[i][j][k].autos.placa.Pcar[l]='\0';
}else{
parqueos[i][j][k].autos.placa.Pcar[l]=letras[n];
}
}
return ;
}
void dibujarMenu(){
gotoxy(4,9);printf("Menu: ");
textbackground(GREEN);textcolor(WHITE);
gotoxy(8,11);printf("\t 1. Ingreso de Auto ");
gotoxy(8,12);printf("\t 2. Salida de Auto ");
gotoxy(8,13);printf("\t 3. Estado del Parqueadero");
gotoxy(8,14);printf("\t 4. Buscar Auto ");
gotoxy(8,15);printf("\t 5. Finalizar Programa ");
return;
}
int movimientocursor(){
int x=0,fin=0,posCursor=0;
char cursor;
do{
do{
cursor=getch();
if(cursor==72 || cursor== 80 || cursor==13){
x=1;
}
}while(x==0);
switch(cursor){
case 80:
if(posCursor==4){
posCursor=0;
}else{
posCursor++;
}
break;
case 72:
if(posCursor==0){
posCursor=4;
}else{
posCursor--;
}
break;
case 13:
return posCursor;
}
switch(posCursor){
case 0:
break;
case 1:
break;
case 2:
break;
case 3:
break;
case 4:
break;
}
}while(fin==0);
return 0;
}
int frecuencia(est parqueos[MAXniv][MAXfil][MAXcol]){

int i,j,k,cont0=0,cont1=0;
for(i=0;i<MAXniv;i++){
for(j=0;j<MAXfil;j++){
for(k=0;k<MAXcol;k++){
cont0=cont0+1;
}else{
cont1=cont1+1;
}
}
}
}
highvideo();
printf("\n\n\tParqueaderos Disponibles: %d\n",cont0);
printf("\n\tParqueaderos Ocupados: %d\n\n",cont1);
lowvideo();
return cont0;
}
int randomicos(int min, int max){

max -=min;
return(rand()%max)+min;
}
void imprimirmatriz(est parqueos[MAXniv][MAXfil][MAXcol]){

int i,j,k;
printf("%d",parqueos[i][j][k].estado);
}
}
}
}
void iniciarparqueos(est parqueos[MAXniv][MAXfil][MAXcol]){
int i,j,k;
srand(time(NULL));
parqueos[i][j][k].estado=randomicos(0,2);
if (parqueos[i][j][k].estado==1){
parqueos[i][j][k].autos.codigo[0]=i;
parqueos[i][j][k].autos.codigo[1]=j;
parqueos[i][j][k].autos.codigo[2]=k;
parqueos[i][j][k].autos.tiempoIngreso=time(NULL);
parqueos[i][j][k].autos.placa.Pnum=randomicos(100,10000);
gPlcAlf(parqueos,i,j,k);
}
}
}
}
return;
}
void imprimirparqueaderos(est parqueos[MAXniv][MAXfil][MAXcol]){

int i,j,k,l,strfil,strcol,cont,comp,res,div,e;
res=MAXcol%BLOQUES;
div=MAXcol/BLOQUES;
if(res==0){
comp=div;
}else{
comp=div+1;
}
gotoxy(0,5);
textcolor(BLACK);textbackground(LIGHTGRAY);
printf("\n");
cont=1;
strfil=cont%2;
if(cont==1){
textcolor(BLACK);textbackground(BLACK);
for(e=0;e<ESPini;e++){
printf("e");
}
printf(" o");
for(l=0;l<MAXcol+comp;l++){
printf("***");
}
printf("o ");
textbackground(BLACK);printf("h");
printf("\n");
}
if(strfil==0){
printf("e");
}
textbackground(LIGHTGRAY);
printf(" *");
printf(" - ");
}
printf("* ");
printf("\n");
}
for(k=1;k<=MAXcol;k++){
strcol=k%BLOQUES;
if(k==1){
printf("e");
}
printf(" * ");
}
printf("|");
if(parqueos[i][j][k-1].estado==1){
textcolor(LIGHTRED);textbackground(LIGHTRED);
}else{
textcolor(LIGHTGREEN);textbackground(LIGHTGREEN);
}
printf("%d",parqueos[i][j][k-1].estado);
printf("|");
if(k==MAXcol){
printf(" * ");
}else{
if(strcol==0){
printf(" ");
}
}
}
printf("\n");
if(cont==MAXfil){// Imprime Margen Inferior
printf("e");
}
printf(" o");
printf("***");
}
printf("o ");
printf("\n");
}
cont++;
}
printf("\n");
}
textcolor(WHITE);textbackground(BLACK);
printf("\n\n\n\t Presione Enter para acceder al Menu: ");
getch();
return;
}
6. Capturas de Pantalla
PROGRAMA SIN ERRORES

Ingreso Auto:
Salida Auto:
Estado Parqueaderos:
Buscar Auto:
Finalizar Programa:
ERRORES:
Ingresar Auto:
Salida de Auto:
Buscar Auto:

Informe Proyecto Parqueadero Programación en C

Caricato da

Informazioni sul documento

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Copyright:

Formati disponibili

Informe Proyecto Parqueadero Programación en C

Caricato da

Copyright:

Formati disponibili

1. Programa.

Nuestro Sistema de parqueadero, tiene 5 acciones básicas ubicadas en un menú

Esta librería es de las más básica de C, nos permite usar funciones

Esta librería se encarga de algunos procesos básicos para ejecutar

 Srand(): Da una semilla para generar diferentes aleatorios.

 Atoi(): Nos permita transformar de cadena a enteros.

Esta librería nos facilita las operaciones con cadenas de caracteres

Esta librería nos permite modificar y saber la naturaleza de las

 Textcolor(): Esta función nos permite darle un color

Esta librería nos permite trabajar con el tiempo del ordenador y

 MAXfil: Este valor da el número de columnas que existe en el

 BLOQUES: Este valor da el número de carros que existirá por bloque

 ESPini: Este valor nos permite dar un espaciado inicial al momento

 SIMcte: Este valor es exclusivo para el proceso de simulación, guarda

“int randomico(int min,int max);

Esta función se encarga de crear números aleatorios en un intervalo

B. Generar Placas Aleatorias.

“void gPlcAlf(est parqueos[ ][ ][MAXcol ], int i, int j, int k);

Esta función se encarga se generar la parte alfabética de una placa

“parqueos[i][j][k].autos.placa.Pcar[l]= letras [n]”;

C. Generar Datos Iniciales

Esta es una función de tipo void y se encarga de llenar nuestro

Esta función se encarga e imprimir el encabezado del programa

Al igual que las otras dos funciones, esta no recibe ningún

“void imprimirparqueos(est parqueos[ ][ ][MAXcol ]);

Esta función recibe como único parámetro un arreglo de tipo est

“void imprimirHora(int x, int y, int z);

Esta función recibe como parámetros tres variables de tipo entero,

“void imprimirFactura(est parqueos[ ][ ][MAXcol ], int

Esta función se encarga de imprimir los datos que van a salir en

Esta función se encarga de crear un pequeño menú de dos

K. Validar Placa Numérica.

“int validarNum(est parqueos[ ][ ][MAXcol ], int i, int j, int

L. Validar Placa Alfabética.

int validarPlaca(est parqueos[ ][ ][MAXcol ], int i, int j, int

void ingresarAuto(est parqueos[ ][ ][MAXcol ], int cont0);

Esta función toma como parámetros un arreglo de tipo est, el cual

void facturarAuto(est parqueos[ ][ ][MAXcol ], int cont0);

Esta función toma los parámetros parqueos y cont0 para su

O. Estado del parqueadero.

int frecuencia(est parqueos[ ][ ][MAXcol ]);

La función frecuencia es la encargada de contar cuantos unos y

void BuscarAuto(est parqueos[ ][ ][MAXcol ], int cont0);

Esta función es muy parecida de cierta manera a facturar auto. La

El main del programa se encarga de ordenar las diferentes funciones y

 Cont0: Esta variable de tipo entero será la encargada de almacenar el

 Opc: Esta variable es la encargada de almacenar el dato retornado por la

 Si OPC es 0, el programa ingresa un auto al parqueadero. Para esto se

void imprimirHora(int x, int y, int z){

void imprimirFactura(est parqueos[MAXniv][MAXfil][MAXcol], int pago, float

int validarPlaca(est parqueos[MAXniv][MAXfil][MAXcol],int i, int j, int k){

int validarNum(est parqueos[MAXniv][MAXfil][MAXcol],int i, int j, int k){

void facturarAuto(est parqueos[MAXniv][MAXfil][MAXcol],int cont0){

void buscarAuto(est parqueos[MAXniv][MAXfil][MAXcol],int cont0){

void ingresarAuto(est parqueos[MAXniv][MAXfil][MAXcol], int cont0){

void gPlcAlf(est parqueos[MAXniv][MAXfil][MAXcol],int i, int j, int k){

int frecuencia(est parqueos[MAXniv][MAXfil][MAXcol]){

int randomicos(int min, int max){

void imprimirmatriz(est parqueos[MAXniv][MAXfil][MAXcol]){

void imprimirparqueaderos(est parqueos[MAXniv][MAXfil][MAXcol]){

PROGRAMA SIN ERRORES

Potrebbero piacerti anche