#!/usr/bin/python
# -*- coding: utf-8 -*-

######################################################################################################
 # SOFTWARE PARA DISPOSITIVO SOBRE DRON RADIOCONTROLADO.
 # DESARROLLO DE SOFTWARE E IMPLEMENTACIÓN DE HARDWARE:
 #  Juan de Dios Yáñez Ávila, CEO Onwards, Director I+D+i en Airvant.
 # EMAIL DE CONTACTO:
 #  juandediosyanez@onw4rds.com | juandediosyanez@gmail.com
 # ARCHIVO: interfaz.py
 # VERSIÓN: 1.0.
 # ENTORNO DE USO: Python 2.7.13.
 # FECHA: 2017/10/29
 # DERECHOS:
 ## Los derechos de uso/explotación de este software son al 50% por Airvant sociedad, y el 
 ## desarrollador del mismo. Software no destinado a venta. El código y archivos asociados están protegidos
 ## por las leyes de propiedad intelectual e industrial. El uso fraudulento y no permitido de los mismos
 ## está penado por la ley.
######################################################################################################

from Airvant import *
from Tkinter import *

import bluetooth, datetime, io, os, serial, time 
import RPi.GPIO as gpio

## Designamos las variables relacionadas con el hardware
 ## LUCES DE CONTROL
LED1G = 4
LED1B = 17
LED2B = 27
LED34G = 18
LED3R = 23
LED4R = 24

gpio.setmode(gpio.BCM)
gpio.setwarnings(False)

## Led de control configuración
gpio.setup(LED1G, gpio.OUT)
gpio.setup(LED1B, gpio.OUT)
gpio.setup(LED2B, gpio.OUT)
gpio.setup(LED34G, gpio.OUT)
gpio.setup(LED3R, gpio.OUT)
gpio.setup(LED4R, gpio.OUT)


### TENGO QUE CREAR UN PATRON POR CADA INCIDENCIA CON EL RGB
### TENGO QUE USAR EL PANEL 7 SEGMENTOS PARA INDICAR AL PILOTO EL PASILLO
### - CUANDO EL PANEL INDIQUE EL PASILLO PODRÁ COMENZAR.
### - CUANDO ESTE APAGADO NO TIENE TAREA ASIGNADA
### SE PODRÍAN CREAR LOS PATRONES DE LUCES DENTRO DE EL MÓDULO DE FUNCIONES Airvant.

## Designamos las variables relacionadas con el análisis del trabajo en el pasillo
piloto_empieza = 0
piloto_termina = 0
lecturas_correctas = 0
lecturas_incidencias = 0

## Puede que queramos borrar un pasillo entero por el motivo que sea, en ese caso llamaremos al técnico
## y será el encargado de acceder via VNC o Putty al archivo del pasillo que queremos borrar.
## El piloto solo puede borrar una última lectura, en el tiempo indicado por los led amarillos.
	##	def borrar(pasillo):
	##		import os
	##		pasillo = str(pasillo)
	##		name_doc = 'lecturas/'+pasillo+'.txt'
	##		fichero = open(name_doc, 'r')
	##		a = []
	##		for linea in fichero.readlines():
	##			a.append(linea)
	##		fichero.close()
	##		a.pop(len(a)-1)
	##		os.remove(name_doc)
	##		fichero2 = open(name_doc, 'w')
	##		for i in range(len(a)):
	##			for j in range(len(a[i])):
	##				fichero2.write(a[i][j])
	##		fichero2.close()
	##		print("Borrado")
##
	##	def borrar_():
	##			empresa_b = empresa.get()
	##			pasillo_b = entrada_pasillo.get()
	##			pasar = empresa_b+pasillo_b
	##			pasar = str(pasar)
	##			borrar(pasar)
##

def iniciar_trabajo_code128():
	## Avisamos de variables globales
	global piloto_empieza
	global piloto_termina
	global lecturas_correctas
	global lecturas_incidencias

	### LUCES DE CONTROL
	global LED1G
	global LED1B
	global LED2B
	global LED34G
	global LED3R
	global LED4R

	## APAGAMOS TODAS LAS LUCES, POR SI EXISTE TRABAJO NO HAYA PROBLEMAS
	gpio.output(LED1G, gpio.LOW)
	gpio.output(LED1B, gpio.LOW)
	gpio.output(LED2B, gpio.LOW)
	gpio.output(LED34G, gpio.LOW)
	gpio.output(LED3R, gpio.LOW)
	gpio.output(LED4R, gpio.LOW)

	SUBIENDO = True # ESTA VARIABLE ES ESENCIAL PARA EL CONTROL DE LA OPERATIVA DE VUELO
	## Registramos la hora en la que el piloto comienza el trabajo en el pasillo.
	piloto_empieza = datetime.datetime.now()
	## Tenemos que hacer un reajuste para evitar los errores de introducir un 0 o no en la designación de pasillos.
	## Estos serán siempre numéricos, y si poseen letras deberemos reajustar este hecho
	empresa = dato_empresa.get()
	# Reajustamos el número de pasillo para que siempre sea lo que queremos.
	# No tendremos 1000 pasillos en un mismo almacén, por tanto con una designación 001 es suficiente.
	pasillo = int(dato_pasillo.get())
	pasillo = str("{:03d}".format(pasillo))
	alturamax = int(dato_alturamax.get())
	alturamin = 2
	longitud = int(dato_longitudcodigo.get())
	## Ponemos el valor del pulsometro de apagado en False
	inputValue = False
	ultima_lectura = ''
	## Nos vamos a mover por columnas y alturas para una correcta medición
	columna = 1
	altura = 1
	item = 0
	## Creamos el archivo_trabajo y si ya existe seguimos leyendo desde el punto en el que nos quedamos.
	## Por cada empresa se crea una carpeta concreta, y dentro de esta un archivo con nombre de la empresa y pasillo.
	archivo = empresa + " " + pasillo + ".txt"
	#direccion = "trabajos/" + str(empresa) + "/" + str(archivo)
	direccion = "trabajos/" + str(archivo) # PARECE QUE NO PODEMOS CREAR UNA CARPETA
	EXISTE = False
	if(os.path.exists(direccion) == False):
		archivo_trabajo = open(direccion, "w")
		archivo_trabajo.close()
	else:
		archivo_trabajo = open(direccion, "r") # si existe es que se tubo que parar el trabajo por lo que sea
		###
		# Mostramos en LED1 un parpadeo verde y azul, indicando que el trabajo ya estaba en curso
		EXISTE = True
		for aviso in range(10):
			gpio.output(LED1G, gpio.HIGH)
			time.sleep(0.3)
			gpio.output(LED1G, gpio.LOW)
			gpio.output(LED1B, gpio.HIGH)
			gpio.output(LED2B, gpio.HIGH)
			time.sleep(0.3)
			gpio.output(LED1B, gpio.LOW)
			gpio.output(LED2B, gpio.LOW)
		###
		items = archivo_trabajo.readlines() # tenemos todos los items para ver la evolución
		# contabilizamos los item leídos
		item = len(items) # retomamos la cuenta de items
		archivo_trabajo.close()
		# volvemos al punto de trabajo en el que nos quedamos
		if(item != 0):
			ultima_lectura = items[-1].split("|")
			###
			print(ultima_lectura)
			# columna | altura | lectura item
			columna = int(ultima_lectura[0]) #3
			altura = int(ultima_lectura[1])  #3
			aux = str(ultima_lectura[3])
			ultima_lectura = str(ultima_lectura[2]) #0000000000010
			if(aux[0] == 'T'):
				SUBIENDO = True
			if(aux[0] == 'F'):
				SUBIENDO = False
			else:
				print("Trabajo terminado en MULTICAPA, requerir técnico para borrado de multicapa")
			print(SUBIENDO)
			"""
				if(SUBIENDO == True):
					altura = altura + 1 #4
					if(altura > alturamax):
						altura = altura - 1
						columna = columna + 1
						SUBIENDO = False
					if(altura == alturamax):
						columna = columna + 1 #4
						SUBIENDO = False      # false	
				else:
					altura = altura - 1 		#2
					if(altura < alturamin):
						altura = altura + 1	#3
						columna = columna +1
						SUBIENDO = True
					if(altura == alturamin):
						columna = columna +1	#7
						SUBIENDO = True
			"""
			archivo_trabajo.close()
		else:
			print("Error, trabajo creado sin registros. Borre archivo de trabajo")
			return
			### ESTO ES UNA SITUACIÓN QUE HAY QUE RESOLVER
	
	## Pantalla del técnico --> inicio del trabajo en pasillo	
	print("Empresa: {0} Nº de pasillo: {1} Longitud de código: {2} \n Columna | Altura | Lectura | Operativa".format(empresa, pasillo, longitud)) #print(pasillo, longitud, num)
	
	while(True):
		## INDICAMOS AL PILOTO CON LEC1G QUE PUEDE COMENZAR A TRABAJAR
		gpio.output(LED1G, gpio.HIGH)
		###
		## PARA HACER TESTs RECURRIREMOS A UNA FUNCIÓN ESPECÍFICA
		# lectura = test_n568(int(longitud))
		##
		###
		###
		## EL SENSOR DEBE DEVOLVER UNA LECTURA CORRECTA, O PASADO UN TIEMPO SIN LEER PEDIR AL OPERARIO
		## REALIZAR ALGUNA ACCIÓN. NO PODEMOS GUARDAR UNA INCIDENCIA AUTOMÁTICAMENTE PUES ESTA PUEDE
		## SER UNA LECTURA DE OTRO CODIGO DE BARRAS, Y LEERLA Y GUARDARLA IMPLICARÁ QUE EL MAPA DEL
		## PASILLO NO SEA CORRECTO.
		lectura = n568xug(int(longitud))
		## CUANDO SALIMOS DE LA LECTURA DEL SENSOR, LED1G VUELVE A APAGARSE, LO VOLVEMOS A ENCENDER
		gpio.output(LED1G, gpio.HIGH)
		## PROCESAMOS LA LECTURA
		## SI EXISTE UNA LECTURA VÁLIDA LA INTEGRAMOS EN EL MAPA
		if (lectura != ultima_lectura and lectura != ''):
			item = item + 1
			ultima_lectura = lectura
			if(SUBIENDO == True):
				altura = altura + 1		
				if(altura > alturamax):
					altura = altura - 1
					columna = columna + 1
					SUBIENDO = False
			else:
				altura = altura - 1
				if(altura < alturamin):
					altura = altura + 1
					columna = columna +1
					SUBIENDO = True
			dato_item = str(columna)+"|"+str(altura)+"|"+str(lectura)+"|"+str(SUBIENDO)+"\n" 
			## Guardamos en el archivo_trabajo y en items la lectura
			archivo_trabajo = open(direccion, 'a')
			archivo_trabajo.write(dato_item)
			archivo_trabajo.close()
			## Mostramos la lectura
			print(dato_item)
			## Como es una lectura correcta, la contabilizamos como tal
			lecturas_correctas = lecturas_correctas + 1
			###
			## Lectura correcta -> led 3 y 4 en verde
			gpio.output(LED34G, gpio.HIGH)
			time.sleep(0.4)
			gpio.output(LED34G, gpio.LOW)
			time.sleep(0.1)
			###
		## SI NO EXISTE UNA LECTURA VÁLIDA, SOLICITAMOS AL PILOTO UNA ACCIÓN
		if(lectura == ''):
			###
			## Ya no podemos seguir trabajando, marcamos error
			gpio.output(LED1G, gpio.LOW)
			gpio.output(LED3R, gpio.HIGH)
			gpio.output(LED4R, gpio.HIGH)
			###
			## En caso de que no se lea nada en el timeout dado se encienden unas luces de aviso para actuar
			# EN ESTE CASO TENDREMOS QUE USAR EL MANDO BLUETOOTH, SEGÚN EL BOTÓN SE REGISTRARÁ:
			# - INCIDENCIA DESCONOCIDA --> tenemos que aumentar el numero de incidencias
			# - HUECO --> aumenta el conteo de columnas y alturas
			# - MULTICAPA DE X TAMAÑO --> detiene el conteo de columnas y alturas
			# - FINALIZAR EL TRABAJO Y TRANSFORMARLO EN UN EXCEL
			# ENCENDEMOS LA BANDA EN EL COLOR AZUL DE AIRVANT ESPERANDO UNA INDICACIÓN 1/7
			## Actualmente el led rojo parpadea esperando presionar el boton para finalizar el trabajo pero EL BOTÓN AHORA ES INNECESARIO, PUES DISPONEMOS DE UNA CONEXIÓN BLUETOOTH PARA DAR COMANDOS CONCRETOS
            		## Pedimos al piloto que indique lo que ocurre. Luz roja de error hasta conexion en azul.
			respuesta_piloto = peticion_piloto()
			gpio.output(LED2B, gpio.HIGH)
			## ANALIZAMOS LA RESPUESTA DEL PILOTO
			## i: iniciar trabajo. Genera unos 10 segundos para ponerse en posición de lectura
			## c: continua trabajo. Estaba pausado por alguna razón. 10 segundos para ponerse en posición.
			## t: terminar trabajo.
			## h: hueco. Hueco es una ubicación vacía al 100% ¿? OPCIÓN FOTO
			## b: bulto. Bulto es una ubicación con cosas indistinguibles. Hueco no vacío al 100%
			## e: error. Error es cuando por alguna razón no podemos leer una etiqueta, que sabemos es legible. ¿? OPCIÓN FOTO
			## m: multicapa. Multicapa, es una ubicación con más de una etiqueta a leer.
			## m:nº: tamaño de multicapa. El tamaño se establece numéricamente con un máximo de 9 lecturas (sin contar hueco) 
			### INICIAR
			if(respuesta_piloto == "i"):
    			gpio.output(LED2B, gpio.LOW)
				print("Piloto va a comenzar el trabajo...")
				time.sleep(10)
				gpio.output(LED1G, gpio.HIGH)
			###
			### CONTINUAR
			if(respuesta_piloto == "c"):
				# Aunque este descansando el tiempo de pasillo sigue corriendo.
				gpio.output(LED2B, gpio.LOW)
				print("Piloto retoma el trabajo...")
				time.sleep(10)
				gpio.output(LED1G, gpio.HIGH)
			###
			### TERMINAR
			if(respuesta_piloto == "t"):
				piloto_termina = datetime.datetime.now()
				###
				## Terminado el trabajo se apagan todas las luces encendidas
				gpio.output(LED2B, gpio.LOW)
				###
				print("Piloto ha terminado el pasillo...")
				### AQUI PODRIAMOS YA ENVIAR EL TRABAJO, PERO MEJOR LO HAGA EL TÉCNICO
				return
			###
			### HUECO
			if(respuesta_piloto == "h"):
				lectura = "HUECO"
				if(SUBIENDO == True):
					altura = altura + 1
					if(altura > alturamax):
						altura = altura - 1
						columna = columna + 1
						SUBIENDO = False
				else:
					altura = altura - 1
					if(altura < alturamin):
						altura = altura + 1
						columna = columna +1
						SUBIENDO = True
				dato_item = str(columna)+"|"+str(altura)+"|"+str(lectura)+"|"+str(SUBIENDO)+"\n"
				## Guardamos en el archivo_trabajo y en items la lectura
				archivo_trabajo = open(direccion, 'a')
				archivo_trabajo.write(dato_item)
				archivo_trabajo.close()
				## Mostramos la lectura
				print(dato_item)
				###
				## Avisamos hueco como una lectura correcta, y volvemos anormal
				gpio.output(LED34G, gpio.HIGH)
				time.sleep(0.4)
				gpio.output(LED34G, gpio.LOW)
				time.sleep(0.1)
				gpio.output(LED2B, gpio.LOW)
				gpio.output(LED1G, gpio.HIGH)
			###
			### BULTO
			if(respuesta_piloto == "b"):
				lectura = "BULTO"
				if(SUBIENDO == True):
					altura = altura + 1
					if(altura > alturamax):
						altura = altura - 1
						columna = columna + 1
						SUBIENDO = False
				else:
					altura = altura - 1
					if(altura < alturamin):
						altura = altura + 1
						columna = columna +1
						SUBIENDO = True
				dato_item = str(columna)+"|"+str(altura)+"|"+str(lectura)+"|"+str(SUBIENDO)+"\n"
				## Guardamos en el archivo_trabajo y en items la lectura
				archivo_trabajo = open(direccion, 'a')
				archivo_trabajo.write(dato_item)
				archivo_trabajo.close()
				## Mostramos la lectura
				print(dato_item)
				###
				## Avisamos hueco como una lectura correcta, y volvemos anormal
				gpio.output(LED34G, gpio.HIGH)
				time.sleep(0.4)
				gpio.output(LED34G, gpio.LOW)
				time.sleep(0.1)
				gpio.output(LED2B, gpio.LOW)
				gpio.output(LED1G, gpio.HIGH)
			###
			### ERROR
			if(respuesta_piloto == "e"):
				lectura = "INCIDENCIA"
				if(SUBIENDO == True):
					altura = altura + 1
					if(altura > alturamax):
						altura = altura - 1
						columna = columna + 1
						SUBIENDO = False
				else:
					altura = altura - 1
					if(altura < alturamin):
						altura = altura + 1
						columna = columna +1
						SUBIENDO = True
				dato_item = str(columna)+"|"+str(altura)+"|"+str(lectura)+"|"+str(SUBIENDO)+"\n"
				## Guardamos en el archivo_trabajo y en items la lectura
				archivo_trabajo = open(direccion, 'a')
				archivo_trabajo.write(dato_item)
				archivo_trabajo.close()
				## Mostramos la lectura
				print(dato_item)
				lecturas_incidencias = lecturas_incidencias + 1
				###
				## Encendemos las dos luces de error un tiempo prudencial, y volvemos a normal
				gpio.output(LED3R, gpio.HIGH)
				gpio.output(LED4R, gpio.HIGH)
				time.sleep(1)
				gpio.output(LED2B, gpio.LOW)
				gpio.output(LED3R, gpio.LOW)
				gpio.output(LED4R, gpio.LOW)
				gpio.output(LED1G, gpio.HIGH)
				###
			###
			### MULTICAPA
			## Dentro de una multicapa, dado el tamaño, solo podremos contar con las opciones:
			## c: continuar.
			## h: hueco.
			## e: error.
			if(respuesta_piloto == "m"):
				## En multicapa tenemos los dos led azules encendidos
				gpio.output(LED1B, gpio.HIGH)
				if(SUBIENDO == True):
					altura = altura + 1
					if(altura > alturamax):
						altura = altura - 1
						columna = columna + 1
						SUBIENDO = False
				else:
					altura = altura - 1
					if(altura < alturamin):
						altura = altura + 1
						columna = columna +1
						SUBIENDO = True
				item_multicapa = 0
				## PEDIMOS EL TAMAÑO DE LA MULTICAPA
				item_ultimo = int(respuesta_piloto)
				items_multicapa = list([])
				## MIENTRAS NO LEYAMOS TODOS LOS CÓDIGOS DEFINIDOS EN EL TAMAÑO DE LA MULTICAPA, LEÉMOS.
				while(item_multicapa < item_ultimo):
					lectura_multicapa = n568xug(int(longitud))
					## SI EXISTE LECTURA Y ES DISTINTA A LA ÚLTIMA
					if(lectura_multicapa != ultima_lectura and lectura_multicapa != ''):
						items_multicapa.append(lectura_multicapa)
						ultima_lectura = lectura_multicapa
						###
						## Lectura correcta
						gpio.output(LED34G, gpio.HIGH)
						time.sleep(0.4)
						gpio.output(LED34G, gpio.LOW)
						time.sleep(0.1)
						###
						lecturas_correctas = lecturas_correctas + 1
						item_multicapa = item_multicapa + 1
					## SI HA PASADO EL TIEMPO DE LECTURA, SOLICITAMOS ACCIÓN AL PILOTO
					if(lectura_multicapa == ''):
						###
						## Tenemos una incidencia desconocida en multicapa
						gpio.output(LED3R, gpio.HIGH)
						gpio.output(LED4R, gpio.HIGH)
						###
						respuesta_piloto_multicapa = peticion_piloto_multicapa()
						### CONTINUAR
						if(respuesta_piloto == "c"):
							# Aunque este descansando el tiempo de pasillo sigue corriendo.
							gpio.output(LED2B, gpio.LOW)
							print("Piloto retoma el trabajo...")
							#gpio.output(LED1G, gpio.HIGH)
						###
						### ERROR
						if(respuesta_piloto_multicapa == "e"):
							lectura_multicapa = "INCIDENCIA"
							lecturas_incidencias = lecturas_incidencias + 1
							items_multicapa.append(lectura_multicapa)
							###
							## Error desconocido en multicapa
							gpio.output(LED3R, gpio.HIGH)
							gpio.output(LED4R, gpio.HIGH)
							time.sleep(1)
							gpio.output(LED3R, gpio.LOW)
							gpio.output(LED4R, gpio.LOW)
							###
							item_multicapa = item_multicapa + 1
						###
						### HUECO
						if(respuesta_piloto_multicapa == "h"):
							lectura_multicapa = "HUECO"
							items_multicapa.append(lectura_multicapa)
							###
							## Aviso hueco en multicapa
							gpio.output(LED34G, gpio.HIGH)
							time.sleep(0.4)
							gpio.output(LED34G, gpio.LOW)
							time.sleep(0.1)
							# item_multicapa = item_multicapa + 1 # NO VAMOS A CONTAR HUECOS EN MULTICAPA
						###
						### NO SE CONTEMPLA LA OPCIÓN TERMINAR HASTA NO SALIR DE LA MULTICAPA
				### LEÉMOS LA LISTA CREADA EN MULTICAPA Y LA MOSTRAMOS POR PANTALLA
				for lectura_en_multicapa in items_multicapa:
					dato_item = str(columna)+"|"+str(altura)+"|"+str(lectura_en_multicapa)+"|"+str("MULTICAPA")+"\n" 
					## Guardamos en el archivo_trabajo y en items la lectura
					archivo_trabajo = open(direccion, 'a')
					archivo_trabajo.write(dato_item)
					archivo_trabajo.close()
					## Mostramos la lectura al técnico
					print(dato_item)
				### FIN DE MULTICAPA
				gpio.output(LED1B, gpio.LOW)
				###
			### FIN DE LA COMUNICACIÓN CON EL PILOTO
			gpio.output(LED2B, gpio.LOW)
			gpio.output(LED1G, gpio.HIGH)
			###	


def iniciar_trabajo_GS1():
    	## Avisamos de variables globales
	global piloto_empieza
	global piloto_termina
	global lecturas_correctas
	global lecturas_incidencias

	### LUCES DE CONTROL
	global LED1G
	global LED1B
	global LED2B
	global LED34G
	global LED3R
	global LED4R

	## APAGAMOS TODAS LAS LUCES, POR SI EXISTE TRABAJO NO HAYA PROBLEMAS
	gpio.output(LED1G, gpio.LOW)
	gpio.output(LED1B, gpio.LOW)
	gpio.output(LED2B, gpio.LOW)
	gpio.output(LED34G, gpio.LOW)
	gpio.output(LED3R, gpio.LOW)
	gpio.output(LED4R, gpio.LOW)

	SUBIENDO = True # ESTA VARIABLE ES ESENCIAL PARA EL CONTROL DE LA OPERATIVA DE VUELO
	## Registramos la hora en la que el piloto comienza el trabajo en el pasillo.
	piloto_empieza = datetime.datetime.now()
	## Tenemos que hacer un reajuste para evitar los errores de introducir un 0 o no en la designación de pasillos.
	## Estos serán siempre numéricos, y si poseen letras deberemos reajustar este hecho
	empresa = dato_empresa.get()
	# Reajustamos el número de pasillo para que siempre sea lo que queremos.
	# No tendremos 1000 pasillos en un mismo almacén, por tanto con una designación 001 es suficiente.
	pasillo = int(dato_pasillo.get())
	pasillo = str("{:03d}".format(pasillo))
	alturamax = int(dato_alturamax.get())
	alturamin = 2
	longitud = int(dato_longitudcodigo.get())
	## Ponemos el valor del pulsometro de apagado en False
	inputValue = False
	ultima_lectura = ''
	## Nos vamos a mover por columnas y alturas para una correcta medición
	columna = 1
	altura = 1
	item = 0
	## Creamos el archivo_trabajo y si ya existe seguimos leyendo desde el punto en el que nos quedamos.
	## Por cada empresa se crea una carpeta concreta, y dentro de esta un archivo con nombre de la empresa y pasillo.
	archivo = empresa + " " + pasillo + ".txt"
	#direccion = "trabajos/" + str(empresa) + "/" + str(archivo)
	direccion = "trabajos/" + str(archivo) # PARECE QUE NO PODEMOS CREAR UNA CARPETA
	EXISTE = False
	if(os.path.exists(direccion) == False):
		archivo_trabajo = open(direccion, "w")
		archivo_trabajo.close()
	else:
		archivo_trabajo = open(direccion, "r") # si existe es que se tubo que parar el trabajo por lo que sea
		###
		# Mostramos en LED1 un parpadeo verde y azul, indicando que el trabajo ya estaba en curso
		EXISTE = True
		for aviso in range(10):
			gpio.output(LED1G, gpio.HIGH)
			time.sleep(0.3)
			gpio.output(LED1G, gpio.LOW)
			gpio.output(LED1B, gpio.HIGH)
			gpio.output(LED2B, gpio.HIGH)
			time.sleep(0.3)
			gpio.output(LED1B, gpio.LOW)
			gpio.output(LED2B, gpio.LOW)
		###
		items = archivo_trabajo.readlines() # tenemos todos los items para ver la evolución
		# contabilizamos los item leídos
		item = len(items) # retomamos la cuenta de items
		archivo_trabajo.close()
		# volvemos al punto de trabajo en el que nos quedamos
		if(item != 0):
			ultima_lectura = items[-1].split("|")	# 1|2|123456789012345678|12345678901234|-|True
			print(ultima_lectura)
			columna = int(ultima_lectura[0]) #1
			altura = int(ultima_lectura[1])  #2
			## NUESTRA LECTURA VA A SER UNA CONJUNCIÓN DE 00 + | + 01 + | + 02 (n18+n14+n14)
			## LA ÚLTIMA LECTURA ES SIEMPRE UNA CONJUNCIÓN
			aux = str(ultima_lectura[5]) 
			ultima_lectura = ultima_lectura[2] + "|" + ultima_lectura[3] + "|" + ultima_lectura[4] #123456789012345678|12345678901234|-
			if(aux[0] == 'T'):
				SUBIENDO = True
			if(aux[0] == 'F'):
				SUBIENDO = False
			else:
				print("Trabajo terminado en MULTICAPA, requerir técnico para borrado de multicapa")
			print(SUBIENDO)
			archivo_trabajo.close()
		else:
			print("Error, trabajo creado sin registros. Borre archivo de trabajo")
			return
			### ESTO ES UNA SITUACIÓN QUE HAY QUE RESOLVER
	
	## Pantalla del técnico --> inicio del trabajo en pasillo	
	print("Empresa: {0} Nº de pasillo: {1} Código GS1-128\n Columna | Altura | IA 00 | IA01 | IA02 | Operativa".format(empresa, pasillo))
	while(True):
		## INDICAMOS AL PILOTO CON LEC1G QUE PUEDE COMENZAR A TRABAJAR
		gpio.output(LED1G, gpio.HIGH)
		###
		## PARA HACER TESTs RECURRIREMOS A UNA FUNCIÓN ESPECÍFICA
		# lectura = test_n568(int(longitud))
		##
		###
		###
		## EL SENSOR DEBE DEVOLVER UNA LECTURA CORRECTA, O PASADO UN TIEMPO SIN LEER PEDIR AL OPERARIO
		## REALIZAR ALGUNA ACCIÓN. NO PODEMOS GUARDAR UNA INCIDENCIA AUTOMÁTICAMENTE PUES ESTA PUEDE
		## SER UNA LECTURA DE OTRO CODIGO DE BARRAS, Y LEERLA Y GUARDARLA IMPLICARÁ QUE EL MAPA DEL
		## PASILLO NO SEA CORRECTO.
		lectura = n568xug_GS1(SUBIENDO)
		## CUANDO SALIMOS DE LA LECTURA DEL SENSOR, LED1G VUELVE A APAGARSE, LO VOLVEMOS A ENCENDER
		gpio.output(LED1G, gpio.HIGH)
		## PROCESAMOS LA LECTURA
		## SI EXISTE UNA LECTURA VÁLIDA LA INTEGRAMOS EN EL MAPA
		if (lectura != ultima_lectura and lectura != ''):
			item = item + 1
			ultima_lectura = lectura
			if(SUBIENDO == True):
				altura = altura + 1		
				if(altura > alturamax):
					altura = altura - 1
					columna = columna + 1
					SUBIENDO = False
			else:
				altura = altura - 1
				if(altura < alturamin):
					altura = altura + 1
					columna = columna +1
					SUBIENDO = True
			dato_item = str(columna)+"|"+str(altura)+"|"+str(lectura)+"|"+str(SUBIENDO)+"\n" 
			## OJO CON LA LECTURA, QUE AHORA ES UNA CONJUNCIÓN DE 3 CADENAS SEPARADAS POR |
			## Guardamos en el archivo_trabajo y en items la lectura
			archivo_trabajo = open(direccion, 'a')
			archivo_trabajo.write(dato_item)
			archivo_trabajo.close()
			## Mostramos la lectura
			print(dato_item)
			## Como es una lectura correcta, la contabilizamos como tal
			lecturas_correctas = lecturas_correctas + 1
			###
			## Lectura correcta -> led 3 y 4 en verde
			gpio.output(LED34G, gpio.HIGH)
			time.sleep(0.4)
			gpio.output(LED34G, gpio.LOW)
			time.sleep(0.1)
			###
		## SI NO EXISTE UNA LECTURA VÁLIDA, SOLICITAMOS AL PILOTO UNA ACCIÓN
		if(lectura == ''):
			###
			## Ya no podemos seguir trabajando, marcamos error
			gpio.output(LED1G, gpio.LOW)
			gpio.output(LED3R, gpio.HIGH)
			gpio.output(LED4R, gpio.HIGH)
			###
			## En caso de que no se lea nada en el timeout dado se encienden unas luces de aviso para actuar
			# EN ESTE CASO TENDREMOS QUE USAR EL MANDO BLUETOOTH, SEGÚN EL BOTÓN SE REGISTRARÁ:
			# - INCIDENCIA DESCONOCIDA --> tenemos que aumentar el numero de incidencias
			# - HUECO --> aumenta el conteo de columnas y alturas
			# - MULTICAPA DE X TAMAÑO --> detiene el conteo de columnas y alturas
			# - FINALIZAR EL TRABAJO Y TRANSFORMARLO EN UN EXCEL
			# ENCENDEMOS LA BANDA EN EL COLOR AZUL DE AIRVANT ESPERANDO UNA INDICACIÓN 1/7
			## Actualmente el led rojo parpadea esperando presionar el boton para finalizar el trabajo pero EL BOTÓN AHORA ES INNECESARIO, PUES DISPONEMOS DE UNA CONEXIÓN BLUETOOTH PARA DAR COMANDOS CONCRETOS
            		## Pedimos al piloto que indique lo que ocurre. Luz roja de error hasta conexion en azul.
			respuesta_piloto = peticion_piloto()
			gpio.output(LED2B, gpio.HIGH)
			## ANALIZAMOS LA RESPUESTA DEL PILOTO
			## i: iniciar trabajo. Genera unos 10 segundos para ponerse en posición de lectura
			## c: continua trabajo. Estaba pausado por alguna razón. 10 segundos para ponerse en posición.
			## t: terminar trabajo.
			## h: hueco. Hueco es una ubicación vacía al 100% ¿? OPCIÓN FOTO
			## b: bulto. Bulto es una ubicación con cosas indistinguibles. Hueco no vacío al 100%
			## e: error. Error es cuando por alguna razón no podemos leer una etiqueta, que sabemos es legible. ¿? OPCIÓN FOTO
			## m: multicapa. Multicapa, es una ubicación con más de una etiqueta a leer.
			## m:nº: tamaño de multicapa. El tamaño se establece numéricamente con un máximo de 9 lecturas (sin contar hueco) 
			### INICIAR
			if(respuesta_piloto == "i"):
    			gpio.output(LED2B, gpio.LOW)
				print("Piloto va a comenzar el trabajo...")
				time.sleep(10)
				gpio.output(LED1G, gpio.HIGH)
			###
			### CONTINUAR
			if(respuesta_piloto == "c"):
				# Aunque este descansando el tiempo de pasillo sigue corriendo.
				gpio.output(LED2B, gpio.LOW)
				print("Piloto retoma el trabajo...")
				time.sleep(10)
				gpio.output(LED1G, gpio.HIGH)
			###
			### TERMINAR
			if(respuesta_piloto == "t"):
				piloto_termina = datetime.datetime.now()
				###
				## Terminado el trabajo se apagan todas las luces encendidas
				gpio.output(LED2B, gpio.LOW)
				###
				print("Piloto ha terminado el pasillo...")
				### AQUI PODRIAMOS YA ENVIAR EL TRABAJO, PERO MEJOR LO HAGA EL TÉCNICO
				return
			###
			### HUECO
			if(respuesta_piloto == "h"):
				lectura = "HUECO|-|-"
				if(SUBIENDO == True):
					altura = altura + 1
					if(altura > alturamax):
						altura = altura - 1
						columna = columna + 1
						SUBIENDO = False
				else:
					altura = altura - 1
					if(altura < alturamin):
						altura = altura + 1
						columna = columna +1
						SUBIENDO = True
				dato_item = str(columna)+"|"+str(altura)+"|"+str(lectura)+"|"+str(SUBIENDO)+"\n"
				## Guardamos en el archivo_trabajo y en items la lectura
				archivo_trabajo = open(direccion, 'a')
				archivo_trabajo.write(dato_item)
				archivo_trabajo.close()
				## Mostramos la lectura
				print(dato_item)
				###
				## Avisamos hueco como una lectura correcta, y volvemos anormal
				gpio.output(LED34G, gpio.HIGH)
				time.sleep(0.4)
				gpio.output(LED34G, gpio.LOW)
				time.sleep(0.1)
				gpio.output(LED2B, gpio.LOW)
				gpio.output(LED1G, gpio.HIGH)
			###
			### BULTO
			if(respuesta_piloto == "b"):
				lectura = "BULTO|-|-"
				if(SUBIENDO == True):
					altura = altura + 1
					if(altura > alturamax):
						altura = altura - 1
						columna = columna + 1
						SUBIENDO = False
				else:
					altura = altura - 1
					if(altura < alturamin):
						altura = altura + 1
						columna = columna +1
						SUBIENDO = True
				dato_item = str(columna)+"|"+str(altura)+"|"+str(lectura)+"|"+str(SUBIENDO)+"\n"
				## Guardamos en el archivo_trabajo y en items la lectura
				archivo_trabajo = open(direccion, 'a')
				archivo_trabajo.write(dato_item)
				archivo_trabajo.close()
				## Mostramos la lectura
				print(dato_item)
				###
				## Avisamos hueco como una lectura correcta, y volvemos anormal
				gpio.output(LED34G, gpio.HIGH)
				time.sleep(0.4)
				gpio.output(LED34G, gpio.LOW)
				time.sleep(0.1)
				gpio.output(LED2B, gpio.LOW)
				gpio.output(LED1G, gpio.HIGH)
			###
			### ERROR
			if(respuesta_piloto == "e"):
				lectura = "INCIDENCIA|-|-"
				if(SUBIENDO == True):
					altura = altura + 1
					if(altura > alturamax):
						altura = altura - 1
						columna = columna + 1
						SUBIENDO = False
				else:
					altura = altura - 1
					if(altura < alturamin):
						altura = altura + 1
						columna = columna +1
						SUBIENDO = True
				dato_item = str(columna)+"|"+str(altura)+"|"+str(lectura)+"|"+str(SUBIENDO)+"\n"
				## Guardamos en el archivo_trabajo y en items la lectura
				archivo_trabajo = open(direccion, 'a')
				archivo_trabajo.write(dato_item)
				archivo_trabajo.close()
				## Mostramos la lectura
				print(dato_item)
				lecturas_incidencias = lecturas_incidencias + 1
				###
				## Encendemos las dos luces de error un tiempo prudencial, y volvemos a normal
				gpio.output(LED3R, gpio.HIGH)
				gpio.output(LED4R, gpio.HIGH)
				time.sleep(1)
				gpio.output(LED2B, gpio.LOW)
				gpio.output(LED3R, gpio.LOW)
				gpio.output(LED4R, gpio.LOW)
				gpio.output(LED1G, gpio.HIGH)
				###
			###
			### MULTICAPA
			## Dentro de una multicapa, dado el tamaño, solo podremos contar con las opciones:
			## c: continuar.
			## h: hueco.
			## e: error.
			if(respuesta_piloto == "m"):
				## En multicapa tenemos los dos led azules encendidos
				gpio.output(LED1B, gpio.HIGH)
				if(SUBIENDO == True):
					altura = altura + 1
					if(altura > alturamax):
						altura = altura - 1
						columna = columna + 1
						SUBIENDO = False
				else:
					altura = altura - 1
					if(altura < alturamin):
						altura = altura + 1
						columna = columna +1
						SUBIENDO = True
				item_multicapa = 0
				## PEDIMOS EL TAMAÑO DE LA MULTICAPA
				item_ultimo = int(respuesta_piloto)
				items_multicapa = list([])
				## MIENTRAS NO LEYAMOS TODOS LOS CÓDIGOS DEFINIDOS EN EL TAMAÑO DE LA MULTICAPA, LEÉMOS.
				while(item_multicapa < item_ultimo):
					lectura_multicapa = n568xug_GS1(SUBIENDO)
					## SI EXISTE LECTURA Y ES DISTINTA A LA ÚLTIMA
					if(lectura_multicapa != ultima_lectura and lectura_multicapa != ''):
						items_multicapa.append(lectura_multicapa)
						ultima_lectura = lectura_multicapa
						###
						## Lectura correcta
						gpio.output(LED34G, gpio.HIGH)
						time.sleep(0.4)
						gpio.output(LED34G, gpio.LOW)
						time.sleep(0.1)
						###
						lecturas_correctas = lecturas_correctas + 1
						item_multicapa = item_multicapa + 1
					## SI HA PASADO EL TIEMPO DE LECTURA, SOLICITAMOS ACCIÓN AL PILOTO
					if(lectura_multicapa == ''):
						###
						## Tenemos una incidencia desconocida en multicapa
						gpio.output(LED3R, gpio.HIGH)
						gpio.output(LED4R, gpio.HIGH)
						###
						respuesta_piloto_multicapa = peticion_piloto_multicapa()
						### CONTINUAR
						if(respuesta_piloto == "c"):
							# Aunque este descansando el tiempo de pasillo sigue corriendo.
							gpio.output(LED2B, gpio.LOW)
							print("Piloto retoma el trabajo...")
							#gpio.output(LED1G, gpio.HIGH)
						###
						### ERROR
						if(respuesta_piloto_multicapa == "e"):
							lectura_multicapa = "INCIDENCIA|-|-"
							lecturas_incidencias = lecturas_incidencias + 1
							items_multicapa.append(lectura_multicapa)
							###
							## Error desconocido en multicapa
							gpio.output(LED3R, gpio.HIGH)
							gpio.output(LED4R, gpio.HIGH)
							time.sleep(1)
							gpio.output(LED3R, gpio.LOW)
							gpio.output(LED4R, gpio.LOW)
							###
							item_multicapa = item_multicapa + 1
						###
						### HUECO
						if(respuesta_piloto_multicapa == "h"):
							lectura_multicapa = "HUECO|-|-"
							items_multicapa.append(lectura_multicapa)
							###
							## Aviso hueco en multicapa
							gpio.output(LED34G, gpio.HIGH)
							time.sleep(0.4)
							gpio.output(LED34G, gpio.LOW)
							time.sleep(0.1)
							# item_multicapa = item_multicapa + 1 # NO VAMOS A CONTAR HUECOS EN MULTICAPA
						###
						### NO SE CONTEMPLA LA OPCIÓN TERMINAR HASTA NO SALIR DE LA MULTICAPA
				### LEÉMOS LA LISTA CREADA EN MULTICAPA Y LA MOSTRAMOS POR PANTALLA
				for lectura_en_multicapa in items_multicapa:
					dato_item = str(columna)+"|"+str(altura)+"|"+str(lectura_en_multicapa)+"|"+str("MULTICAPA")+"\n" 
					## Guardamos en el archivo_trabajo y en items la lectura
					archivo_trabajo = open(direccion, 'a')
					archivo_trabajo.write(dato_item)
					archivo_trabajo.close()
					## Mostramos la lectura al técnico
					print(dato_item)
				### FIN DE MULTICAPA
				gpio.output(LED1B, gpio.LOW)
				###
			### FIN DE LA COMUNICACIÓN CON EL PILOTO
			gpio.output(LED2B, gpio.LOW)
			gpio.output(LED1G, gpio.HIGH)
			###

                    
def envio():
    ### AQUI TENEMOS QUE VER CUANDO ES UN TRABAJO DE CODE128 O DE GS1
	global piloto_termina
	global piloto_empieza
	global lecturas_correctas
	global lecturas_incidencias
	### LUCES DE CONTROL
	global LED1G
	global LED1B
	global LED2B
	global LED34G
	global LED3R
	global LED4R
	###
	piloto = dato_piloto.get()
	empresa = dato_empresa.get()
	# Reajustamos el número de pasillo para que siempre sea lo que queremos.
	# No tendremos 1000 pasillos en un mismo almacén, por tanto con una designación 001 es suficiente.
	pasillo = int(dato_pasillo.get())
	pasillo = str("{:03d}".format(pasillo))
	archivo = empresa + " " + pasillo + ".txt"
	email = dato_email.get()
	#direccion_trabajo = "trabajos/" + str(empresa) + "/" + str(archivo)
	direccion_trabajo = "trabajos/" + str(archivo)
	#direccion_excel = "trabajos/" + str(empresa) + "/" + str(empresa) + str(pasillo) + ".xlsx"
	direccion_excel = "trabajos/" + str(empresa) + str(pasillo) + ".xlsx"
	## Queremos enviar el trabajo que se encuentra en la dirección
	envio_trabajo(direccion_trabajo, direccion_excel, email, empresa, pasillo)
	## Mostramos al técnico como ha sido la operación
	print("Trabajo del piloto {0} finalizado.\n" .format(piloto))
	tiempo_de_trabajo = piloto_termina - piloto_empieza
	print(" Análisis del trabajo:\n Nº de lecturas correctas: {0}\n Nº de incidencias: {1}\n Tiempo de trabajo: {2}" .format(str(lecturas_correctas), str(lecturas_incidencias), str(tiempo_de_trabajo)))
	## Ponemos variable globales a cero, para no tener que cerrar el programa
	piloto_empieza = 0
	piloto_termina = 0
	lecturas_correctas = 0
	lecturas_incidencias = 0
	# gpio.cleanup() # CUIDADO, ESTO BORRA TODO EL GPIO, NO APAGA LOS LEDS
	gpio.output(LED1G, gpio.LOW)
	gpio.output(LED1B, gpio.LOW)
	gpio.output(LED2B, gpio.LOW)
	gpio.output(LED34G, gpio.LOW)
	gpio.output(LED3R, gpio.LOW)
	gpio.output(LED4R, gpio.LOW)
	time.sleep(0.1)
	## Si no lo ponemos podemos seguir haciendo trabajos sin reiniciar el programa
	# ESTOS RESULTADOS TAMBIÉN SE PODRIAN ENVIAR A OTRO EMAIL PARA TENER UN REGISTRO DE COMO SE TRABAJA
	# ESTO QUIZAS SE PODRIA HACER MAS EFICIENTE MEDIANTE UNA LECTURA DEL ARCHIVO_TRABAJO.TXT


######################################################################################################
 # CUANDO EL TÉCNICO SE ENCUENTRA GESTIONANDO EL TRABAJO, EL PANEL MUESTRA UNA "A" DE AIRVANT
 ## cuando se enciende el programa se encienden todas las luces
######################################################################################################

gpio.output(LED1G, gpio.LOW)
gpio.output(LED1B, gpio.LOW)
gpio.output(LED2B, gpio.LOW)
gpio.output(LED34G, gpio.LOW)
gpio.output(LED3R, gpio.LOW)
gpio.output(LED4R, gpio.LOW)
time.sleep(0.1)
gpio.output(LED1G, gpio.HIGH)
gpio.output(LED1B, gpio.HIGH)
gpio.output(LED2B, gpio.HIGH)
gpio.output(LED34G, gpio.HIGH)
gpio.output(LED3R, gpio.HIGH)
gpio.output(LED4R, gpio.HIGH)

## Borramos de la pantalla cualquier error
print("\n \n \n \n \n \n \n \n \n \n VERSIÓN PARA DEMOSTRACIONES\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n")

######################################################################################################	
 #	CÓDIGO RELACIONADO CON EL DISEÑO DE LA INTERFAZ GRÁFICA DEL TÉCNICO
 #	- EL TÉCNICO TIENE QUE AUTORIZAR EL TRABAJO DEL PILOTO.
 # 	- EL TÉCNICO DEFINE EL NOMBRE DE LA EMPRESA, EL PASILLO A PROCEDER, LA LONGITUD DE CÓDIGO, ETC.
 #	- EL TÉCNICO VE EN TIEMPO REAL EL TRABAJO DE CADA PILOTO.
 #	- EL TÉCNICO VERIFICA QUE EL TRABAJO EN PASILLO HA CONCLUIDO.
 ######################################################################################################


root = Tk()
root.title("Airvant Inventario")
# root.iconbitmap('onwards.ico') # DA ERROR PONER EL ICONO
root.config(bg="lightblue")

menubar = Menu(root)
filemenu = Menu(menubar, tearoff=0)
filemenu.add_command(label="Salir", command=root.quit()) #root.quit
menubar.add_cascade(label="Archivo", menu=filemenu)
root.config(menu=menubar)
# ESTARÍA BIEN CREAR ALGO QUE PONGA EL DESARROLLADOR DE LA TECNOLOGÍA

img_airvant = PhotoImage(file="airvant_logo.png")

dato_piloto = StringVar()
dato_empresa = StringVar()
dato_pasillo = StringVar()
dato_alturamax = StringVar()
dato_longitudcodigo = StringVar()
dato_email = StringVar()
### NOS FALTA DEFINIR UNA NUEVA VARIABLE CODE PARA TOMAR UN TIPO DE TRABAJO Y OTRO, O UNA TRANSFORMACION
### U OTRA DEL ARCHIVO --> bien code128 o bien GS1

form_piloto = Label(root, text = "Nombre del piloto: ").grid(row=0, column=0, columnspan=2)
piloto = Entry(root, textvariable = dato_piloto).grid(row=1, column=0, columnspan=2)

form_empresa = Label(root, text = "Nombre de empresa: ").grid(row=2, column=0, columnspan=2)
empresa = Entry(root, textvariable = dato_empresa).grid(row=3, column=0, columnspan=2)

form_pasillo = Label(root, text = "Nº de pasillo: ").grid(row=4, column=0)
pasillo = Entry(root, textvariable = dato_pasillo, width = 8).grid(row=4, column=1)

form_altura = Label(root, text = "Altura de pasillo: ").grid(row=5, column=0)
alturamax = Entry(root, textvariable = dato_alturamax, width = 8).grid(row=5, column=1)

form_longitud = Label(root , text = "Longitud del codigo: ").grid(row=6, column=0)
longitudcodigo = Entry(root, textvariable = dato_longitudcodigo, width = 8).grid(row=6, column=1)

form_email = Label(root , text = "GMAIL de envío: ").grid(row=7, column=0)
email = Entry(root, textvariable = dato_email).grid(row=7, column=1)

boton = Button(root, text = "EMPEZAR/CONTINUAR CODE128", command = iniciar_trabajo_code128 ).grid(row=8, column=0, columnspan=2)
### METEMOS LA OPCION DEL NUEVO CODIGO
boton = Button(root, text = "EMPEZAR/CONTINUAR CODE128", command = iniciar_trabajo_GS1 ).grid(row=8, column=0, columnspan=2)

###
#boton_borrar = Button(root, text = "BORRAR ITEM", command = borrar_).grid(row=5, column=1)
boton_fin = Button(root, text = "ENVIAR TRABAJO", command = envio).grid(row=9, column=0, columnspan=2)

Label(root, text="Aplicacion para inventariado de almacen. Version 0.1.\nDesarrollada por Onwards.\n", justify="center").grid(row=10, column=0, columnspan=2)
Label(root, image=img_airvant).grid(row=0, rowspan=11, column=2)

root.mainloop()