ÍNDICE DE ANEXOS
6. CONCLUSIONES Y RECOMENDACIONES
82
CONCLUSIONES
1. Se diseñó y estructuró una base de datos para el almacenamiento de la información de cada activo informático asignados con un TAG para cada uno de los equipos con el fin de facilitar la supervisión, monitoreo y control de la estación.
2. Se diseñó un sistema de control electrónico para escanear los TAG’s para encontrar los activos informáticos, tomando en cuenta los requerimientos para su conformación, atendiéndolos por medio de sus procesos de control establecidos en el dispositivo móvil.
3. El proyecto se realizó siguiendo las normas y experiencias obtenidas al transferir la información de los activos informáticos encontrados a la base de datos para actualizarlos.
4. Se transfirió la información de los activos informáticos encontrados desde el dispositivo móvil hasta el servidor, en donde reposa la base de datos para actualizarla y cumplir con la dinámica de la aplicación. Además se facilitó para que se pueda encontrar los activos con búsquedas anteriores de las cuales ya se tuvieron información una vez que se realizó las respectivas pruebas del manejo del dispositivo.
5. Se diseñó un portal web de consulta para activos informáticos, los mismos que en cuanto, a tiempos así: reduciendo y facilitando la búsqueda e información.
6. Se tuvo excelentes resultados, ya que se pudo realizar la tarea de encontrar los activos informáticos en menos tiempo que de manera manual y eliminando el empleamiento de personal para realizar esta tarea, además la presentación de registros de búsquedas realizadas en la App. Web ayuda a tener una guía de las actividades realizadas (justificación laboral) y como un historial.
RECOMENDACIONES
1. Hay que asegurarse que queden bien sujetos los TAG´s que van en cada uno de los activos informáticos para poder operar e identificar a los activos, ya que de esa manera se puede garantizar el funcionamiento.
2. Se recomienda que en un futuro para la explotación y desarrollo del presente proyecto, se permita configurar un control electrónico del sistema embebido con todas las opciones desde una interfaz WEB almacenada dentro del sistema embebido, esta es una característica que sería muy utilizada.
3. Para la transferencia de la información, es necesario estar conectado con un cable de red a la red local en donde se encuentra el equipo servidor de base de datos para poder actualizar los datos. También es muy importante que no se apague bruscamente el dispositivo móvil para evitar no tener problemas con vida útil de la batería y por ende no se podría realizar la transferencia de información.
4. Se recomienda que en un futuro para la explotación del presente sistema, se desarrolle el mismo proyecto con opciones de conectividad inalámbrica a la red interna del Departamento informático del Consejo Nacional Electoral, en vista que así se garantiza que el sistema no tenga vulnerabilidades físicas, como desconexiones de cableado, garantizando que se gane apertura con la consulta de los activos por la aplicación web.
84
ANEXOS
Anexo 1.Código fuente del ESM
# Las librerías lógicamente no se utilizan al mismo tiempo.
# Es decir, por ejemplo, si una librería es la que permite en un programa # visualizar el cuadro desplegable (Opciones) de la barra de herramientas, # por eso cada aplicación administra y gestiona ciertas reglas para el tiempo # de ejecuciones, las librerías en diferentes espacios de tiempo
# y según las necesidades y peticiones del usuario a la aplicación # determinada en el momento de uso, estas son:
from flask import Flask, render_template, request, redirect, url_for, send_from_directory
import os, csv, logging import model
import sqlite3 as lite import pdb
from datetime import datetime import time
import config
from flaskext.mysql import MySQL from werkzeug import secure_filename from pymysql.err import IntegrityError
# Esto hace un llamado a flask y mysql, lo que permite indicar la configuración # mediante una llamada a los diferentes procesos para ser ejecutados
mysql = MySQL()
# Inicializa Flask
# Esta es la ruta de acceso al directorio de subida app.config [ ''] 'UPLOAD_FOLDER uploads /' =
# Estas son la extensión que estamos aceptando para ser subido app.config [ 'ALLOWED_EXTENSIONS'] = conjunto ([ 'csv',])
# Para un archivo determinado, hay que volver si se trata de un tipo que # no permita la configuración de conexión del mysql, esto permite entrar a la # base de datos para la realización del trabajo.
# MySQL database configuration
app.config['MYSQL_DATABASE_USER'] = config.db_user app.config['MYSQL_DATABASE_PASSWORD'] = config.db_password app.config['MYSQL_DATABASE_DB'] = config.db_database app.config['MYSQL_DATABASE_HOST'] = config.db_host mysql.init_app(app) def allowed_file(filename): return '.' in filename and \
filename.rsplit('.', 1)[1] in app.config['ALLOWED_EXTENSIONS']
lee la carga delcsv
def read_csv_product(filename): """
# Leer el archivo CSV y guardar la búsqueda
"""
query_insert_product = """
INSERT INTO product(id, brand, name, description) VALUES ('%s', '%s', '%s', '%s')
ON DUPLICATE KEY UPDATE brand = VALUES(brand),
86 name = VALUES(name),
description = VALUES(description) """
query_insert_serial_number = """
INSERT INTO serial_number(id, rfid, serial_number, state, observation, product_id)
VALUES('%s', '%s', '%s', '%s', '%s', '%s') ON DUPLICATE KEY UPDATE
rfid = VALUES(rfid), state = VALUES(state),
observation = VALUES(observation) """
try:
with open(os.path.join(app.config['UPLOAD_FOLDER'], filename), encoding='utf-8') as csv_file:
reader = csv.reader(csv_file) reader.__next__()
con = mysql.connect() for row in reader:
assert len(row) == 8 if not row[5]:
continue
product_id = str(hash('%s%s' % (row[1].lower(), row[2].lower(),)))
query = query_insert_product % (product_id, row[1], row[2], row[0])
cursor = con.cursor() cursor.execute(query)
row[3], row[6], row[7], product_id)
cursor.execute(query) con.commit()
except UnicodeDecodeError:
return u"Error: La codificación debe ser UTF-8" except IntegrityError as e:
return u"Error de integridad: {}".format(str(e))
return True
@app.route('/') def index():
cursor = mysql.connect().cursor()
cursor.execute("SELECT * FROM product") products = cursor.fetchall()
res = []
# For product in products:
cursor.execute("""SELECT * FROM serial_number
WHERE product_id = '{}'""". format(product[0])) serial_number = cursor.fetchall()
res.append({'product': product, 'serial_number': serial_number}) return render_template('index.html', products=res)
# Route that will process the file upload
@app.route('/upload/<object>', methods=['POST']) def upload(object):
88 # Para obtener el nombre del archivo subido se realiza
file = request.files['file']
# Check if the file is one of the allowed types/extensions if file and allowed_file(file.filename):
# Hacer el nombre de archivo seguro y eliminar caracteres no compatibles filename = secure_filename(file.filename)
# Mover el archivo de la carpeta temporal a la instalación web # Carpeta de carga
file.save(os.path.join(app.config['UPLOAD_FOLDER'], filename))
# Redirigir al usuario a la ruta uploaded_file, que básicamente # se mostrará en el navegador el archivo subido
return redirect(url_for('uploaded_file', filename=filename)) if object == 'product': _id = read_csv_product(filename) if type(_id) is str: return _id return redirect(url_for('index'))
# Esta ruta está esperando un parámetro que contiene el nombre # de un archivo. A continuación, se localizará el archivo de la carga # del directorio y se muestra en el navegador web
@app.route('/uploads/<filename>') def uploaded_file(filename):
return send_from_directory(app.config['UPLOAD_FOLDER'], filename)
@app.route('/search/<sid>/products') def search_list(sid):
return render_template('search.products.html',
products=[product for product in model.Search().browse_search_ products(sid)])
@app.route('/locations')
# Cargar la página def locations():
cursor = mysql.connect().cursor()
cursor.execute("SELECT * FROM location") locations = cursor.fetchall()
return render_template('location.html', locations=locations)
# Añadir el documento en la carpeta contenedora para ser procesada @app.route('/location/add', methods=['POST']) def add_location(): name = request.form.get('name') description = request.form.get('description') rfid = request.form.get('rfid') conn = mysql.connect() cursor = conn.cursor() insert_location_script = """
INSERT INTO location(name, description, rfid) VALUES('%s', '%s', '%s')
cursor.execute(insert_location_script % (name, description, rfid)) conn.commit()
print('name {0} :: description {1}'.format(name, description)) return redirect(url_for('locations'))
90 @app.route('/buscar/<filename>') def uploaded_file(filename): return send_from_directory(app.config['UPLOAD_FOLDER'], filename) if __name__ == '__main__': app.run( host="0.0.0.0", port=int("8080"), debug=True )
Anexo 2.Código fuente del ESJ
-*- encoding: utf-8 -*- """
# Ingreso de archivo para encontrar los items # Carga de CSV al ESJ
"""
import os, csv, logging, urllib2 import model
import sqlite3 as lite import pdb
from datetime import datetime import time
import model, config
from flask.ext.mysql import MySQL import pymysql
# Se importan plantillas HTML y se accede a datos enviados en paquetes, # por medio del objeto de solicitud. Además de reorienta por medio de url_for
# para redirigir al usuario una vez que la carga se realiza y el comando # send_from_directory ayuda para enviar la ruta en el
# navegador para el archivo que el usuario acaba de subir
from flask import Flask, render_template, request, redirect, url_for from flask import send_from_directory, jsonify
from werkzeug import secure_filename
# Inicialización de la aplicación FLASK app = Flask(__name__)
# Esta es la ruta de acceso al directorio de subida app.config['UPLOAD_FOLDER'] = 'uploads/'
# These are the extension that we are accepting to be uploaded app.config['ALLOWED_EXTENSIONS'] = set(['csv', ]) mysql = MySQL() # Configuración de MySQL app.config['MYSQL_DATABASE_USER'] = config.server['mysql_db']['user'] app.config['MYSQL_DATABASE_PASSWORD'] = config.server['mysql_db']['password'] app.config['MYSQL_DATABASE_DB'] = config.server['mysql_db']['db'] app.config['MYSQL_DATABASE_HOST'] = config.server['mysql_db']['host'] mysql.init_app(app)
# Estas son las extensiones que se acepta para ser subido def allowed_file(filename):
return '.' in filename and \
92 # Esta ruta muestra un formulario para realizar una petición AJAX
# JQuery y cargar para ejecutar la solicitud y actualizar el valor de la operación def update_locations(cursor):
sql = """
SELECT id, rfid, name, description FROM location
"""
conn = mysql.connect() cursor = conn.cursor()
locations = cursor.execute(sql)
model.Location().update_location([loc for loc in cursor.fetchall()])
def read_csv(filename): """
# Lectura del archivo CSV y guardado de la búsqueda """ conn = mysql.connect() cursor = conn.cursor() update_locations(cursor) now = datetime.now() _id = time.mktime(now.timetuple())
with open(os.path.join(app.config['UPLOAD_FOLDER'], filename)) as csv_file:
reader = csv.reader(csv_file) next(reader)
query_serial = """select description, brand, name, serial_number, n.id, rfid from product p
join Serial_Number n on p.id = n.product_id where n.id = '%s'"""
for row in reader: cursor = conn.cursor() cursor.execute(query_serial % row[0]) serial_number = cursor.fetchone() if not serial_number: continue values = (_id, now.strftime("%Y-%m-%d %H:%M:%S"), serial_number[0].decode("utf8"), serial_number[1], serial_number[2], serial_number[3], serial_number[4], serial_number[5], 'active' ) model.Search().insert_search_products(values) return _id @app.route('/') def index(): active_time_id = model.Search().browse_active_time_id() if active_time_id:
return redirect(url_for('search_list', sid=active_time_id))
return render_template('index.html')
# Ruta que va a procesar para la carga de archivos @app.route('/upload', methods=['POST'])
94 # Obtención del nombre del archivo subido
file = request.files['file']
if file and allowed_file(file.filename):
# Realización del nombre de archivo seguro y eliminación de caracteres # no compatibles
filename = secure_filename(file.filename)
# Mover el archivo de la carpeta temporal a la carpeta de carga de la # instalación web
file.save(os.path.join(app.config['UPLOAD_FOLDER'], filename))
# Redirect the user to the uploaded_file route, which # will basicaly show on the browser the uploaded file # return redirect(url_for('uploaded_file',
# filename=filename)) try:
_id = read_csv(filename)
return redirect(url_for('search_list', sid=_id)) except pymysql.err.OperationalError:
return render_template("not_found.html")
# Esta ruta está en espera del parámetro que contiene el nombre del archivo. # A continuación, se localizará el archivo de la carga en el directorio, para # mostrarlo en el navegador
@app.route('/uploads/<filename>') def uploaded_file(filename):
return send_from_directory(app.config['UPLOAD_FOLDER'], filename)
@app.route('/search/<sid>/products') def search_list(sid):
return render_template('search.products.html', sid=sid,
products=[product for product in model.Search(). browse_search_products(sid)])
@app.route('/search/upload', methods=['GET']) def upload_search():
now = datetime.now() insert_search_sql = """
INSERT INTO search(id, start, end) VALUES(%d, '%s', '%s')
ON DUPLICATE KEY UPDATE start = start, end = end
"""
insert_search_line_sql = """
INSERT INTO search_line(search_id, serial_number_id, location_id, found_time)
VALUES(%d, '%s', %s, '%s') """
sid = request.args.get('sid', 0, type=int) conn = mysql.connect()
cursor = conn.cursor()
for product in model.Search().browse_search_products(sid): print product[6]
print product
sql = insert_search_sql % (int(sid), product[6],
now.strftime("%Y-%m-%d %H:%M:%S")) cursor.execute(sql)
96 product[7] and product[7] or 'NULL',
product[8] and product[8] or 'NO ENCONTRADO')
cursor.execute(sql) conn.commit() model.Search().inactive_search(sid) return jsonify(result="ok") if __name__ == '__main__': app.run( host="0.0.0.0", # port=int("8080"), debug=True
BIBLIOGRAFÍA
Abraham Silberschatz, (2002), Fundamentos de Bases de Datos. (4ta edición). Madrid, España: McGrawHill
A.O. George & J. Wiley, (1991). Principles of Polymerización. (3rd edition, pág. 34). New York, EEUU.
Audífonos Genius. Recuperado el 10 de mayo de 2015, de: http://www. geniusnet.com
Batería Samsung. Recuperado el 10 de mayo de 2015, de: http:// www.samsung.com/mx/consumer/mobile-devices/accessories/battery/EB- B600BEBECMX
BeagleBone Black. Recuperado el 10 de mayo de 2015, de: https://beagleboard.org/black
Bishop, R.C. & Dorf, R.H. (2005). Sistemas de control moderno. (10ma edición). Madrid, España: Pearson Prentice Hall.
Create a professional website (Topología). Recuperado el 15 de mayo de 2015, de: http://www.angelfire.com: http://www.angelfire.com
Erick Jones y Christopher A. Chung, (2009), RFID in Logistics: A Practical Itroductios. (1ra edición). Inglaterra.
Jorge Sierra y Acosta, (2001), Administración de almacenes y Control de Inventarios. Enciclopedia virtual, Eumed.net
Mind mapping, concept mapping, outlining. Recuperado el 18 de mayo de 2015, de: www.mindomo.com
Python. Recuperado el 18 de mayo de 2015, de: https://www.python.org
RFID Reader ID-12LA (125 kHz). Recuperado el 10 de mayo de 2015, de: http://www.sparkfun.com
Sergio Gómez González, (2007). El gran libro de SolidWorks Office Profesional. (2da edición). Editorial: Marcombo S.A.
Sistemas de control. Recuperado el 10 de julio de 2015, de: http:// es.slideshare.net /andresnoble/ sistema-de-control-502542
98
Subsistema de procesamiento de datos o middleware. Recuperado el 6 de noviembre de 2015, de: http://www.rfidpoint.com/fundamentos/ middleware/
Tesis UPS Guayas con RFID, sistemas de control. Recuperado el 3 de junio de 2015, de: http://iespoetaclaudio.centros.educa.jcyl.es/sitio/upload/ Sistemas_de_control.pd
W. Bolton, (2008). Mecatrónica Sistemas de Control Electrónico en la Ingeniería Mecánica y Eléctrica. México: Alfaimega S.A