Escolar Documentos
Profissional Documentos
Cultura Documentos
HUAMANGA
FALCULTAD DE INGENIERÍA DE MINAS GEOLOGÍA Y
CIVIL
ESCUELA PROFESIONAL DE INGENIERÍA DE SISTEMAS
SISTEMAS DIGITALES Y ARQUITECTURA DE COMPUTADORAS IS - 341
FECHA : 26 de julio
AYACUCHO – PERÚ
2018
ÍNDICE
I. RESUMEN............................................................................................................... 3
II. FUNDAMENTACIÓN TEÓRICA..............................................................................4
III. INGENIERÍA DEL PROYECTO................................................................................6
IV. PRUEBAS Y EVALUACIÓN DE FUNCIONAMIENTO............................................15
V. IMPACTO AMBIENTAL.........................................................................................15
VI. COSTOS Y PRESUPUESTOS..................................................................................16
VII. OBSERVACIONES.................................................................................................16
VIII. CONCLUSIONES Y RECOMENDACIONES........................................................16
IX. BIBLIOGRAFÍA.....................................................................................................17
X. ANEXOS...............................................................................................................17
LINEAS DE CÓDIGO...................................................................................................22
2
I. RESUMEN
El estacionamiento automatizado es un proyecto de sistemas digitales que
pretende solventar la necesidad de información acerca de la disponibilidad de
espacios para el aparcamiento de vehículos. La problemática actual de las
instituciones públicas y privadas en relación a la administración de sus garajes,
nos sitúa en el contexto de usuarios quienes tienen la necesidad de parquear sus
vehículos, con el desconocimiento de la cantidad disponible de espacios para
este fin. El objetivo propuesto para este proyecto es el de brindar la información
necesaria de los espacios disponibles de aparcamiento en los garajes, para evitar
solicitudes denegadas de los mismos a través de la simulación del mismo
mediante una maqueta ilustrativa.
3
II. FUNDAMENTACIÓN TEÓRICA
Para el diseño de un sistema digital que nos permita la administración de
información de los espacios de aparcamiento, se requiere el conocimiento de los
siguientes conceptos:
Computación física
Significa la construcción de sistemas interactivos físicos mediante el uso de
software y hardware que pueden sentir y responder al mundo analógico. Si bien
esta definición es suficientemente amplia para abarcar aspectos como los
sistemas inteligentes de control de tráfico de automóviles o los procesos de
automatización de fábricas, en un sentido más amplio, la computación física es
un marco creativo para la comprensión de la relación de los seres humanos en el
mundo digital. En la práctica, se utilizan sensores y microcontroladores para
traducir entradas analógicas a sistemas basados en software, y/o controlar
dispositivos electromecánicos como motores, servos, iluminación u otro
hardware.
Para el desarrollo de este proyecto nos basaremos en este concepto, llevar las
señales físicas digitalizarlas, procesar y que generen una acción que modifique el
entorno para un estacionamiento.
Arduino
Es una plataforma de electrónica abierta para la creación de prototipos basa-da
en software y hardware libre, flexibles y fáciles de usar. Se creó para artistas,
diseñadores, aficionados y cualquier interesado en crear entornos u objetos
interactivos.
Arduino puede tomar información del entorno a través de sus pines de entrada,
para esto toda una gama de sensores puede ser usada y puede afectar aquello que
le rodea controlando luces, motores y otros actuadores. El microcontrolador en
la placa Arduino se programa mediante el lenguaje de programación Arduino
(basado en Wiring) y el entorno de desarrollo Arduino (basado en Processing).
Arduino se programa en el lenguaje de alto nivel C/C++ y generalmente tiene los
siguientes componentes para elaborar el algoritmo:
• Estructuras
• Variables
• Operadores matemáticos, lógicos y booleanos
• Estructuras de control (Condicionales y ciclos)
• Funciones
SISTEMA REACTIVO
Un sistema reactivo se compone de las siguientes partes:
4
Entradas: Toman las señales del mundo físico y las convierte en corriente o
voltaje
Procesadores: Manipulan, interpretan y transforman las señales.
Salidas: Convierten la corriente o voltaje en señales físicamente útiles.
COMPONENTES ELECTRÓNICOS
Servomotor SG90.
Un servomotor es un tipo especial de motor que permite controlar la posición del
eje en un momento dado. Está diseñado para moverse determinada cantidad de
grados y luego mantenerse fijo en una posición.
Display de 7 segmentos
El display de 7 segmentos, es un componente que se utiliza para la
representación de números en muchos dispositivos electrónicos.
Pulsadores:
Un pulsador es un operador eléctrico que, cuando se oprime, permite el paso de
la corriente eléctrica y, cuando se deja de oprimir, lo interrumpe.
Resistencias
Encargadas de la regulación de voltaje para el correcto funcionamiento del
sistema digital
Batería 9V
Para la realización del proyecto se utilizará una batería de 9V que será la
encargada del suministro de energía para el sistema.
Multiplexor; Los multiplexores son circuitos combinacionales con varias
entradas y una única salida de datos. Están dotados de entradas de control
capaces de seleccionar una, y solo una, de las entradas de datos para permitir su
transmisión desde la entrada seleccionada hacia dicha salida.
En el campo de la electrónica el multiplexor se utiliza como dispositivo que
puede recibir varias entradas y transmitirlas por un medio de transmisión
compartido. Para ello lo que hace es dividir el medio de transmisión en múltiples
canales, para que varios nodos puedan comunicarse al mismo tiempo.
Hardware:
5
DIAGRAMA DE BLOQUES
BASE DE DATOS EN
LA NUBE
APLICACIÓN MÓVIL
DE CONSULTA
MICROSERVOS
DEMULTIPLEXOR
SENSORES DE
PUERTO SERIAL ARDUINO UNO PROXIMIDAD
MULTIPLEXOR
DISPLAY 7
SEGMENTOS
6
DIAGRAMA DE BLOQUES DEL SISTEMA RECEPTOR DE DATOS
COMPUTADORA
APLICACIÓN
PUERTO SERIAL MONGO DRIVER
RECEPTORA INTERNET
ENTORNO DE MLAB
INTERNET
PEERING CONECCIÓN
BASE DE DATOS
NO SQL
INTERNET
PEERING CONECCIÓN
7
DIAGRAMA DE LA APLICACIÓN DE CONSULTA
INTERNET
PEERING CONECCIÓN
ENTORNO ANDROID
APLICACIÓN DE CONSULTA
LIBRERIAS Y JVM
KERNEL LINUX
Software:
#include "Estacionamiento.h"
#define NUM_MAX_CARROS 8
Estacionamiento est(NUM_MAX_CARROS, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
10, 11, 12);
void setup() {
8
pinMode(LED_BUILTIN, OUTPUT);
digitalWrite(LED_BUILTIN, LOW);
void loop() {}
Clase Funcionamiento
#ifndef Estacionamiento_h
#define Estacionamiento_h
#include "Arduino.h"
#include "TransmisorDeDatos.h"
#include "SensorProximidad.h"
#include "SelectorPosicion.h"
#include "Display7Seg.h"
#include <Servo.h>
/*
Representa una puerta del estacionamiento (salida
o entrada).
*/
struct puerta {
Servo motor; //Servomotor de la puerta.
SensorProximidad prx; //Sensor de proximidad de
las puertas.
int id; //identificador de la
puerta.
/*
Inicializa el sensor de proximidad.
*/
void initPrx(int trig, int echo) {
SensorProximidad pr(trig, echo);
prx = pr;
}
/*
Inicializa el servomotor.
*/
void initServo(int pinServo) {
motor.attach(pinServo);
}
};
/*
Representa al conjunto de sensores de proximidad y
brinda información de
las plazas del estacionamiento.
*/
struct controladorSensores {
9
SensorProximidad prx; //Sensor de proximidad de las
plazas.
SelectorPos3Bits pos; //Selector de 3 bits.
/*
Estructura definida en TransmisorDeDatos.h,
representa los datos
que se enviaran a la base de datos mediante el
puerto Serial.
*/
datos _estadoActual;
/*
Inicializa el selector de posición, el sensor de
proximidad y el estado actual
del estacionamiento.
*/
void init(int trig, int echo, int C, int B, int A,
int numMaxCarros) {
pinMode(pos.C, OUTPUT);
pinMode(pos.B, OUTPUT);
pinMode(pos.A, OUTPUT);
if (d <= 30) {
_estadoActual.numActualCarros++;
_estadoActual.plazasDisponibles.insertarNodo(byte(i))
;//Indica la plaza en la que se ubica el carro
estacionado.
}
nextPos();
}
}
/*
Avanza una posición en el rango [0, 8], si la
posición esta fuera de este
rango se reinicia en 0;
*/
int nextPos() {
pos._pos++;
10
pos.setPos(pos._pos);
return pos._pos;
}
};
/*
La clase Estacionamiento representa el
estacionamiento que se desea implementar.
*/
class Estacionamiento {
private:
Transmisor _tx; //Transmisor de los
datos del estacionamiento,
//ya está inicializado.
public:
Estacionamiento() {}
/*
Inicializa las puertas, el estado actual del
estacionamiento y el transmisor de datos.
*/
Estacionamiento (int numMaxCarros, int
pinTrigEnt, int pinEchoEnt, int pinServoEntrada,
int idPuertaEntrada, int
pinTrigSld, int pinEchoSld, int pinServoSalida,
int idPuertaSalida, int trigCtr,
int echoCtr, int C, int B, int A) {
_numMaxCarros = numMaxCarros;
_pEntrada.initPrx(pinTrigEnt, pinEchoEnt);
_pEntrada.initServo(pinServoEntrada);
_pEntrada.id = idPuertaEntrada;
_pSalida.initPrx(pinTrigSld, pinEchoSld);
_pSalida.initServo(pinServoSalida);
_pSalida.id = idPuertaSalida;
ctr.init(trigCtr, echoCtr, C, B, A,
numMaxCarros);
ctr._estadoActual.sitiosRestantes =
numMaxCarros - ctr._estadoActual.numActualCarros;
}
int getNumCarrosActual() {
11
return ctr._estadoActual.numActualCarros;
}
int getPlazasDisponibles() {
return ctr._estadoActual.sitiosRestantes;
}
if (idPuerta == _pEntrada.id) {
selec = _pEntrada;
}
selec.motor.write(0);
}
if (idPuerta == _pEntrada.id) {
selec = _pEntrada;
}
selec.motor.write(90);
}
/*
Se enviará y actualizara los datos cada vez
el numActualCarros sea diferente a un valor anterior.
*/
void updateNumActualCarros(int numActualCarros) {
int numAnteriorCarros =
ctr._estadoActual.numActualCarros;
if (numAnteriorCarros != numActualCarros) {
ctr._estadoActual.numActualCarros =
numActualCarros;
ctr._estadoActual.sitiosRestantes =
_numMaxCarros - numActualCarros;
_tx.enviarDatos(ctr._estadoActual);
}
}
};
#endif
12
13
IV. PRUEBAS Y EVALUACIÓN DE FUNCIONAMIENTO
Realizamos las pruebas del proyecto haciendo una simulación, e implementando
algunos materiales ya adquiridos.
Prueba N° 1
En el despliegue de la
primera prueba se
observaron los
siguientes detalles:
- Los sensores no
reportaron la
presencia de los
autos
- El suministro de energía aparentemente no es suficiente.
Prueba N° 2
Para el despliegue se integró un transistor LM 7508 para la regulación del
voltaje para el sistema, con los siguientes detalles:
- El sistema dispone del voltaje suficiente, pero los sensores siguen sin
reportar la presencia de los autos.
V. IMPACTO AMBIENTAL
El objetivo el proyecto responde a la demanda de espacios de aparcamiento, lo
que en consecuencia evitará la congestión vial.
El prototipo antes descrito cumple su rol ambiental, en la reutilización de
algunos materiales reciclados, que servirán para la implementación de sus
estructuras.
14
VI. COSTOS Y PRESUPUESTOS
A continuación, se presenta el cuadro de costos de los materiales para la
implementación del estacionamiento automatizado:
PRECIO
MATERIAL CANTIDAD TOTAL
UNITARIO
Arduino UNO 1 29.00 29.00
Cables 10 0.50 5.00
Display 7 Segmentos 1 2.00 2.00
Servomotor SG90 2 9.50 19.00
Pulsador 2 pines 1 2.00 2.00
Sensor de Proximidad 9 7.20 64.80
Multiplexor (74LS151) 1 1.50 1.50
Decoder (74LS138) 1 3.50 3.50
Not Gate (74LS04) 2 2.50 5.00
Bin to 7 Seg (74LS47) 1 4.50 4.50
Autos de Juguete 8 1.00 8.00
Cartones 3 2.00 6.00
Total 150.30
VII. OBSERVACIONES
- El sensor de proximidad usado no tuvo la respuesta deseada debido a una
precisión baja en la medición de distancias, razón por la cual las medidas
obtenidas no estaban de acuerdo al modelo de programación sugerido.
15
IX. BIBLIOGRAFÍA
- https://www.xataka.com/especiales/guia-del-arduinomaniaco-todo-lo-que-
necesitas-saber-sobre-arduino
- https://aprendiendoarduino.wordpress.com/tag/computacion-fisica/
- https://www.arrow.com/es-mx/categories/sensors/proximity-sensors
- https://techlandia.com/mux-demux-info_250607/
X. ANEXOS
Arduino Atmega328
Servomotor SG90
16
Dimensiones y Especificaciones
Voltaje de trabajo: DC 5V
Corriente de trabajo: 15mA
Frecuencia de trabajo: 40Hz
Alcance máximo: 4 m
Rango mínimo: 2 cm
Ángulo de medición: 15 grados
Señal de entrada del disparador: pulso TTL
10μS
Señal de salida de eco Señal de palanca TTL
y el rango en proporción
Dimensión 45 * 20 * 15 mm
17
18
19
20
LINEAS DE CÓDIGO
ArduinoPortListener
import time, serial, pymongo, threading
from pymongo import MongoClient
puerto = serial.Serial()
puerto.port = 'COM3'
def listenPort():
while True:
try:
puerto.open()
print(puerto.readline())
puerto.close()
break
except serial.serialutil.SerialException:
print('Puerto %s no disponible' % puerto.port)
serial.time.sleep(2)
21
cliente =
MongoClient('mongodb://arduinoUNO:4w5dczd7JYqDFbaEa2fFVHDQ@ds2592
50.mlab.com:59250/estacionmiento')
db = cliente['estacionmiento']
test = db['test']
datos = {"_id":"update", "numCar":numCars,
"plazasDisponibles":plazasDisponibles}
test.replace_one({"_id":"update"}, datos, upsert=True)
cliente.close()
del datos, test, db, cliente
#hilo1 = threading.Thread(target = listenPort, daemon = True)
#hilo1.start()
Display7Seg
#ifndef Display7Seg_h
#define Display7Seg_h
#include "Arduino.h"
#include "SelectorPosicion.h"
/*
La clase Display7Seg representa a un display de 7 segmentos
de colector común.
Para la reducción del uso de pines se debe usar un IC 74LS47.
*/
class Display7Seg {
private:
SelectorPos4Bits _pos;
public:
Display7Seg() {}
/*
Inicializa los pines de entrada del IC 74LS47.
Siempre se debe llamar a esta función antes de usar
los demás métodos de esta clase.
*/
Display7Seg(int A, int B, int C, int D) {
22
_pos.A = A;
_pos.B = B;
_pos.C = C;
_pos.D = D;
pinMode(_pos.A, OUTPUT);
pinMode(_pos.B, OUTPUT);
pinMode(_pos.C, OUTPUT);
pinMode(_pos.D, OUTPUT);
}
/*
Establece el digito mostrado por el display de 7 segmentos.
*/
void setDigito(int digito) {
_pos.setPos(digito);
}
/*
Cambia los digitos del display de 7 segmentos de acuerdo al
tiempo de retraso seleccionado.
*/
void test(int delayTime) {
for (int i = 0; i < 10; i++) {
setDigito(i);
delay(delayTime);
}
}
/*
Cambia los digitos del display de 7 segmentos cada 1s.
*/
void test() {
for (int i = 0; i < 10; i++) {
setDigito(i);
delay(1000);
}
}
23
};
#endif
SensorProximidad
#ifndef SensorProximidad_h
#define SensorProximidad_h
#include "Arduino.h"
/*
La clase SensorProximidad representa a un sensor de
proximidad
HC-SR04 de 4 pines: Vcc, Trig, Echo, Gnd.
1) d = t/58 cm
rango = t*(velocidadDelSonido/2)/10000
2)rango = t*0.01716 cm
Donde:
t: representa el tiempo en us que tarda en
llegar la señal
emitida por el Trigger hacia el Echo.
d: distancia hacia el objeto en cm.
rango: distancia hacia el objeto en cm.
public:
/*
Constructor que se invoca al declarar una variable
de la clase SensorProximidad:
SensorProximidad prx;
*/
SensorProximidad() {}
/*
24
Constructor que inicializa los pines Trig y Eco del
sensor de proximidad.
_TRIGGER = pinTrigger;
_ECHO = pinEcho;
}
/*
Obtiene la proximidad de un objeto de acuerdo a la
fórmula:
1) d = t/58 cm
Donde:
t: representa el tiempo en us que tarda en
llegar
la señal emitida por el Trigger hacia el
Echo.
d: distancia hacia el objeto en cm.
digitalWrite(_TRIGGER, HIGH);
delayMicroseconds(10);
digitalWrite(_TRIGGER, LOW);
/*
Obtiene la proximida de un objeto de acuerdo a la
fórmula:
2) rango = t*(velocidadDelSonido/2)/10000 =
t*0.01716 cm
Donde:
t: representa el tiempo en us que tarda en
llegar la señal emitida por el Trigger hacia el Echo.
rango: distancia hacia el objeto en cm.
Retorna la proximidad de un objeto (int).
*/
float obtenerRango() {
25
digitalWrite(_TRIGGER, HIGH);
delayMicroseconds(10);
digitalWrite(_TRIGGER, LOW);
26