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

######################################################################################################
# SOFTWARE VERSIÓN 2.1.
#
#	Esta versión implementa una comunicación "constante" con el controlador bluetooth para ahorrar
#	tiempo en el proceso de respuesta al piloto. Además de esta mejora, se ahorra espacio de memoria
#	guardando en lecturas solo las últimas 5 lecturas y se genera el archivo EXCEL a medida que se
#	realiza el trabajo de pasillo.
#
# NOTAS:
#
#	En la versión 2.1. NO se puede realizar un borrado de última lectura. Para poder realizarlo hay
#	que parar el proceso de trabajo, abrir archivo_txt y borrar manualmente los registros. De tal modo
#	que estemos fuera de una multicapa y que la lectura anterior no sea tampoco una multicapa. Estos
#	problemas se resolverán en la versión 2.2.
#
# INFORMACIÓN:
#
#	Archivo:	 		Airvant_0201.py
#	Entorno de uso:		Python 2.7.13
#	Fecha:				2017/11/22
#	Autor:				Juan de Dios Yáñez Ávila	| CTO at Airvant
#	Contacto:			juandediosyanez@onw4rds.com	| juandediosyanez@airvant.es
#
# 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.
#
######################################################################################################

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

##################################################################################################
# VARIABLES DE HARDWARE                                                                          #
##################################################################################################

LED1G = 4
LED1B = 17
LED2B = 27
LED34G = 18
LED3R = 23
LED4R = 24

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

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)

##################################################################################################
# VARIABLES GLOBALES Y DEL PROGRAMA                                                              #
##################################################################################################

piloto_empieza = 0
piloto_termina = 0
lecturas_correctas = 0
lecturas_incidencias = 0

##################################################################################################
# FUNCIONES ESPECÍFICAS DE LECTURA DEL SENSOR n568xug PARA DISTINTOS TIPOS DE CÓDIGOS            #
##################################################################################################

def test_n568xug(L):
	import random
	## Realizamos una lectura entre 1 y 500.
	lectura = random(1,500)
	if(lectura < 30):
		print("INCIDENCIA-01")
		sensor.close()
		return "INCIDENCIA-01"
	if(lectura > 470):
		print("INCIDENCIA-02")
		sensor.close()
		return "INCIDENCIA-02"
	if(lectura>210 and lectura < 290):
		sensor.close()
		return ""
	sensor.close()
	return lectura

def n568xug_Code128(L, tiempolectura):
	## AL ENTRAR EN LA FUNCIÓN SE APAGA EL LED1G VERDE, POR LO QUE VOLVEMOS A ENCENDERLO
	global LED1G
	gpio.output(LED1G, gpio.HIGH)
	## ENTRAMOS EN EL CÓDIGO PARA EL SENSOR
	if 'sensor' in locals():
		sensor.close()
	if 'sensor' in globals():
		sensor.close()
	## ESTA VARIABLE VA A MARCAR EL TIEMPO MÁXIMO PARA REALIZAR UNA LECTURA CORRECTA, Y PEDIR ALGUNA
	## ACCIÓN AL PILOTO.
	TIEMPO_INICIO_LECTURA = datetime.datetime.now()
	TIEMPO_TRANSCURRIDO_LECTURA = 0
	TIEMPO_DIFERENCIA_LECTURA = 0
	###
	## ACTIVAMOS EL SENSOR Y ESTABLECEMOS UN TIEMPO DE LECTURA (  ligado con read() :
	## timeout = none -> espera por siempre hasta completar L (nº de bytes)
	## timeout = 0 -> modo de no bloqueo, va enviando todo lo que coge.
	## timeout = x -> envia lo que coge hasta que el tiempo x ha transcurrido.
	## 
	sensor = serial.Serial('/dev/ttyACM0', baudrate = 115200, timeout = 0)
	while(True):
    	## BORRAMOS CUALQUIER INFORMACIÓN ACUMULADA EN EL BUFFER DE ENTRADA.
		sensor.flushInput()
		## CODIGO DE ACCIÓN EN EL BUFFER DE SALIDA (esto lo lee el sensor para realizar la lectura)
		sensor.write("\x16T\r")
		## REALIZAMOS LA LECTURA DE UN NÚMERO L DE BYTES
		lectura = sensor.read(L)
		## SI LA LECTURA ES MÁS LARGA DE L, SE QUEDAN UNOS BYTES EN ESPERA DE ENTRADA.
		enespera = sensor.inWaiting()
		## CUANDO LA LONGITUD LEÍDA SEA DEL TAMAÑO QUE BUSCAMOS, DEJAREMOS DE BUSCAR.
		if(len(lectura) == L and enespera == 0):
			sensor.close()
			return lectura
		TIEMPO_TRANSCURRIDO_LECTURA = datetime.datetime.now()
		TIEMPO_DIFERENCIA_LECTURA = TIEMPO_TRANSCURRIDO_LECTURA - TIEMPO_INICIO_LECTURA
		## SI HAN PASADO EN EL PROCESO DE BÚSQUEDA X SEGUNDOS, EL OPERARIO DEBE REALIZAR ALGUNA OPCIÓN.
		if(TIEMPO_DIFERENCIA_LECTURA.seconds >= tiempolectura):
    		## BORRAMOS LA INSTRUCCIÓN DE LECTURA, PERO EL SENSOR NO SE APAGA HASTA QUE NO RECIBE ALGO
			sensor.flushOutput()
			sensor.close()
			return ""

def n568xug_GS1128(tiempolectura):
    ## GS1
	## IA PALET COMPLETO: (01)123456789abcde(--)...
	## IA PALET EMPEZADO: (02)123456789abcde(37)... HASTA 8 BYTES
	## IA MATRÍCULA ÚNICA SSCC (00)123456789abcdefghi(--)... SSCC = (00) + 18 bytes A VECES NO APARECE
	## LOS () NO APARECEN EN EL CODIGO DE BARRAS, PERO TIENEN QUE APARECER COMO HUMANAMENTE LEGIBLE
	## EL NÚMERO MÁXIMO DE BYTES POR CÓDIGO GS1-128 ES DE 48 BYTES (NÚMEROS O LETRAS)
	IA01 = False
	IA02 = False
	IA00 = False
	lectura_IA00 = "-"
	lectura_IA01 = "-"
	lectura_IA02 = "-"
	LECTURA = str()
	L = 48
	## AL ENTRAR EN LA FUNCIÓN SE APAGA EL LED1G VERDE, POR LO QUE VOLVEMOS A ENCENDERLO
	global LED1G
	gpio.output(LED1G, gpio.HIGH)
	## ENTRAMOS EN EL CÓDIGO PARA EL SENSOR
	if 'sensor' in locals():
		sensor.close()
	if 'sensor' in globals():
		sensor.close()
	## ESTA VARIABLE VA A MARCAR EL TIEMPO MÁXIMO PARA REALIZAR UNA LECTURA CORRECTA, Y PEDIR ALGUNA
	## ACCIÓN AL PILOTO.
	TIEMPO_INICIO_LECTURA = datetime.datetime.now()
	TIEMPO_TRANSCURRIDO_LECTURA = 0
	TIEMPO_DIFERENCIA_LECTURA = 0
	###
	## ACTIVAMOS EL SENSOR Y ESTABLECEMOS UN TIEMPO DE LECTURA (  ligado con read() :
	## timeout = none -> espera por siempre hasta completar L (nº de bytes)
	## timeout = 0 -> modo de no bloqueo, va enviando todo lo que coge.
	## timeout = x -> envia lo que coge hasta que el tiempo x ha transcurrido.
	## 
	sensor = serial.Serial('/dev/ttyACM0', timeout = 0)
	## LEÉMOS CÓDIGOS HASTA DAR CON EL DESEADO
	#while((IA01 == False and IA02 == False) or (IA00 == False) or ()):
	while(True):
		## BORRAMOS CUALQUIER INFORMACIÓN ACUMULADA EN EL BUFFER DE ENTRADA.
		sensor.flushInput()
		## CODIGO DE ACCIÓN EN EL BUFFER DE SALIDA (esto lo lee el sensor para realizar la lectura)
		sensor.write("\x16T\r")
		## REALIZAMOS UNA LECTURA
		lectura = sensor.read(L)
		## AHORA VAMOS A PROCESAR LA LECTURA
		if(IA00 == False and lectura[0:2] == "00"):
			lectura_IA00 = lectura[2:20]
			gpio.output(LED1B, gpio.HIGH)
			IA00 = True
		if(IA01 == False and lectura[0:2] == "01"):
			lectura_IA01 = lectura[2:16]
			gpio.output(LED2B, gpio.HIGH)
			IA01 = True
		if(IA02 == False and lectura[0:2] == "02"):
			lectura_IA02 = lectura[2:16]
			gpio.output(LED2B, gpio.HIGH)
			IA02 = True
		TIEMPO_TRANSCURRIDO_LECTURA = datetime.datetime.now()
		TIEMPO_DIFERENCIA_LECTURA = TIEMPO_TRANSCURRIDO_LECTURA - TIEMPO_INICIO_LECTURA
		if(IA00 == True and (IA01 == True or IA02 == True)):
			LECTURA = lectura_IA00 + "|" + lectura_IA01 + "|" + lectura_IA02
			time.sleep(1)
			break # Nos salimos del while en cuanto tenemos lectura válida + 1 segundo		
		if(TIEMPO_DIFERENCIA_LECTURA.seconds >= tiempolectura):
			LECTURA = lectura_IA00 + "|" + lectura_IA01 + "|" + lectura_IA02
			time.sleep(1)
			break # Nos salimos del while a los 4+1 segundos			
	gpio.output(LED1B, gpio.LOW)
	gpio.output(LED2B, gpio.LOW)   
	if(LECTURA == "-|-|-"):
    	## DAREMOS POR VÁLIDA LA LECTURA CON SOLO TENER UN IA LEÍDO
		return ""
	return LECTURA

def n568xug_GS1128_noSSCC(tiempolectura):
    ## GS1
	## IA PALET COMPLETO: (01)123456789abcde(--)...
	## IA PALET EMPEZADO: (02)123456789abcde(37)... HASTA 8 BYTES
	## IA MATRÍCULA ÚNICA SSCC (00)123456789abcdefghi(--)... SSCC = (00) + 18 bytes A VECES NO APARECE
	## LOS () NO APARECEN EN EL CODIGO DE BARRAS, PERO TIENEN QUE APARECER COMO HUMANAMENTE LEGIBLE
	## EL NÚMERO MÁXIMO DE BYTES POR CÓDIGO GS1-128 ES DE 48 BYTES (NÚMEROS O LETRAS)
	IA01 = False
	IA02 = False
	lectura_IA01 = "-"
	lectura_IA02 = "-"
	LECTURA = str()
	L = 48
	## AL ENTRAR EN LA FUNCIÓN SE APAGA EL LED1G VERDE, POR LO QUE VOLVEMOS A ENCENDERLO
	global LED1G
	gpio.output(LED1G, gpio.HIGH)
	## ENTRAMOS EN EL CÓDIGO PARA EL SENSOR
	if 'sensor' in locals():
		sensor.close()
	if 'sensor' in globals():
		sensor.close()
	## ESTA VARIABLE VA A MARCAR EL TIEMPO MÁXIMO PARA REALIZAR UNA LECTURA CORRECTA, Y PEDIR ALGUNA
	## ACCIÓN AL PILOTO.
	TIEMPO_INICIO_LECTURA = datetime.datetime.now()
	TIEMPO_TRANSCURRIDO_LECTURA = 0
	TIEMPO_DIFERENCIA_LECTURA = 0
	###
	## ACTIVAMOS EL SENSOR Y ESTABLECEMOS UN TIEMPO DE LECTURA (  ligado con read() :
	## timeout = none -> espera por siempre hasta completar L (nº de bytes)
	## timeout = 0 -> modo de no bloqueo, va enviando todo lo que coge.
	## timeout = x -> envia lo que coge hasta que el tiempo x ha transcurrido.
	## 
	sensor = serial.Serial('/dev/ttyACM0', timeout = 0)
	## LEÉMOS CÓDIGOS HASTA DAR CON EL DESEADO
	#while((IA01 == False and IA02 == False) or (IA00 == False) or ()):
	while(True):
		## BORRAMOS CUALQUIER INFORMACIÓN ACUMULADA EN EL BUFFER DE ENTRADA.
		sensor.flushInput()
		## CODIGO DE ACCIÓN EN EL BUFFER DE SALIDA (esto lo lee el sensor para realizar la lectura)
		sensor.write("\x16T\r")
		## REALIZAMOS UNA LECTURA
		lectura = sensor.read(L)
		## AHORA VAMOS A PROCESAR LA LECTURA
		if(IA01 == False and lectura[0:2] == "01"):
			lectura_IA01 = lectura[2:16]
			gpio.output(LED2B, gpio.HIGH)
			IA01 = True
		if(IA02 == False and lectura[0:2] == "02"):
			lectura_IA02 = lectura[2:16]
			gpio.output(LED2B, gpio.HIGH)
			IA02 = True
		TIEMPO_TRANSCURRIDO_LECTURA = datetime.datetime.now()
		TIEMPO_DIFERENCIA_LECTURA = TIEMPO_TRANSCURRIDO_LECTURA - TIEMPO_INICIO_LECTURA
		if(IA01 == True or IA02 == True):
			LECTURA = "-|" + lectura_IA01 + "|" + lectura_IA02
			time.sleep(1)
			break # Nos salimos del while en cuanto tenemos lectura válida		
		if(TIEMPO_DIFERENCIA_LECTURA.seconds >= tiempolectura):
			LECTURA = "-|" + lectura_IA01 + "|" + lectura_IA02
			time.sleep(1)
			break # Nos salimos del while a los 4+1 segundos			
	gpio.output(LED1B, gpio.LOW)
	gpio.output(LED2B, gpio.LOW)   
	if(LECTURA == "-|-|-"):
    	## DAREMOS POR VÁLIDA LA LECTURA CON SOLO TENER UN IA LEÍDO
		return ""
	return LECTURA			

##################################################################################################
# FUNCIONES ESPECÍFICAS DE PETICIONES AL PILOTO DURANTE LA REALIZACIÓN DEL TRABAJO               #
##################################################################################################		

def peticion_piloto():
	from bluetooth import *

	global LED1G
	global LED1B
	global LED2B
	global LED34G
	global LED3R
	global LED4R

	## Informamos al técnico de que el piloto esta dando instrucciones
	print("ANALIZANDO UBICACIÓN...")

	server_socket = BluetoothSocket( RFCOMM )
	port = 1 # suponemos que solo hay un dispositivo bluetooth conectado por drone
	server_socket.bind(("",port))
	server_socket.listen(1)
	client_socket,address = server_socket.accept()

	###
	## Cuando se establece conexión se enciende el led 1 en azul y se apagan las rojas
	gpio.output(LED1B, gpio.HIGH)
	gpio.output(LED3R, gpio.LOW)
	gpio.output(LED4R, gpio.LOW)
	###
	
	print("PROCESANDO Y ESPERANDO CONFIRMACIÓN...")
	while True:
		data = client_socket.recv(1024)
		###
		 # DEFINIMOS LAS DISTINTAS POSIBILIDADES Y DAMOS UN RETURN QUE
		 # IMPLICARAN UNA SERIE DE ACCIONES. ENCENDEMOS LUCES ANTES EN CADA CASO
		 # PARA QUE EL PILOTO SEPA CUANDO OPERAR
		###
		if(data=="i"):
			print("CONFIRMACIÓN EN {0} \n".format(data))
			gpio.output(LED1B, gpio.LOW)
			return "i"

		if(data=="c"):
			print("CONFIRMACIÓN EN {0} \n".format(data))
			gpio.output(LED1B, gpio.LOW)
			return "c"
		
		if(data=="t"):
			print("CONFIRMACIÓN EN {0} \n".format(data))
			gpio.output(LED1B, gpio.LOW)
			return "t"
		
		if(data=="h"):
			print("CONFIRMACIÓN EN {0} \n".format(data))
			gpio.output(LED1B, gpio.LOW)
			return "h"
		
		if(data=="b"):
			print("CONFIRMACIÓN EN {0} \n".format(data))
			gpio.output(LED1B, gpio.LOW)
			return "b"

		if(data=="e"):
			print("CONFIRMACIÓN EN {0} \n".format(data))
			gpio.output(LED1B, gpio.LOW)
			return "e"
		
		if(data=="m"):
			print("CONFIRMACIÓN EN m. TAMAÑO DE MULTICAPA: ")
			gpio.output(LED1B, gpio.LOW)
			###
			## Parpadeamos el segundo led azul avisando de multicapa
			for aviso in range(5):
				gpio.output(LED2B, gpio.LOW)
				gpio.output(LED2B, gpio.HIGH)
				time.sleep(0.3)
				gpio.output(LED2B, gpio.LOW)
			###			
			data = client_socket.recv(1024)
			data = "m"+str(data)
			print("{0} \n".format(data[1]))
			## Dejaremos el led 2 en azul todo el tiempo hasta que terminemos la multicapa en interfaz.py
			return data #envía un numero, eso indica que es una multicapa de tamaño numero

		if(data=="a"):
			print("CONFIRMACIÓN EN a. ALTURA DE NUEVA COLUMNA: ")
			gpio.output(LED1B, gpio.LOW)
			###
			## Parpadeamos el segundo led azul avisando de multicapa
			for aviso in range(5):
				gpio.output(LED2B, gpio.LOW)
				gpio.output(LED2B, gpio.HIGH)
				time.sleep(0.3)
				gpio.output(LED2B, gpio.LOW)
			###			
			data = client_socket.recv(1024)
			data = "a"+str(data)
			print("{0} \n".format(data[1]))
			## Dejaremos el led 2 en azul todo el tiempo hasta que terminemos la multicapa en interfaz.py
			return data #envía un numero, eso indica que es una multicapa de tamaño numero		
		
		print("ERROR, PROCESANDO DE NUEVO A ESPERA DE CONFIRMACIÓN...")

def peticion_piloto_multicapa():
	from bluetooth import *

	global LED1G
	global LED1B
	global LED2B
	global LED34G
	global LED3R
	global LED4R

	## Informamos al técnico de que el piloto esta dando instrucciones
	print("ANALIZANDO MULTICAPA...")

	server_socket = BluetoothSocket( RFCOMM )
	port = 1 # suponemos que solo hay un dispositivo bluetooth conectado por drone
	server_socket.bind(("",port))
	server_socket.listen(1)
	client_socket,address = server_socket.accept()

	## Cuando se establece conexión se enciende el led 1 en azul
	gpio.output(LED3R, gpio.LOW)
	gpio.output(LED4R, gpio.LOW)
	gpio.output(LED1B, gpio.HIGH)
	
	print("PROCESANDO Y ESPERANDO CONFIRMACIÓN EN MULTICAPA...")
	while True:
		data = client_socket.recv(1024)
		## Cuando recivimos una instrucción por el piloto, led 2 en azul FIJO en interfaz.py
		###
		 # DEFINIMOS LAS DISTINTAS POSIBILIDADES Y DAMOS UN RETURN QUE
		 # IMPLICARAN UNA SERIE DE ACCIONES. ENCENDEMOS LUCES ANTES EN CADA CASO
		 # PARA QUE EL PILOTO SEPA CUANDO OPERAR
		###
		if(data=="c"):
			print("CONFIRMACIÓN EN {0} \n".format(data))
			gpio.output(LED2B, gpio.HIGH)
			time.sleep(0.3)
			gpio.output(LED2B, gpio.LOW)
			return "c"
		
		if(data=="h"):
			print("CONFIRMACIÓN EN {0} \n".format(data))
			gpio.output(LED2B, gpio.HIGH)
			time.sleep(0.3)
			gpio.output(LED2B, gpio.LOW)
			return "h"
		
		if(data=="e"):
			print("CONFIRMACIÓN EN {0} \n".format(data))
			gpio.output(LED2B, gpio.HIGH)
			time.sleep(0.3)
			gpio.output(LED2B, gpio.LOW)
			return "e"

		print("ERROR EN MULTICAPA, PROCESANDO DE NUEVO A ESPERA DE CONFIRMACIÓN...")

##################################################################################################
# FUNCIONES ESPECÍFICAS DE LA OPERATIVA DE TRABAJO NORMAL                                        #
##################################################################################################

def iniciarTrabajo_Code128(empresa, pasillo, alturamax, longitud,  tiempolectura, PIKING):
	## 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()
    ## Altura mínima depende de si existe o no zona de piking.
	if(PIKING=="True"):
		alturamin = 2
		altura = 1
	if(PIKING=="False"):
		alturamin = 1
		altura = 0
	## 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_Code128(int(longitud), tiempolectura)
		## 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 piloto_empieza, piloto_termina, lecturas_correctas, lecturas_incidencias
			###
			### 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[0] == "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[1])
				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_Code128(int(longitud), tiempolectura)
					## 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 iniciarTrabajo_GS1128(empresa, pasillo, alturamax, tiempolectura, PIKING):
    	## 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()
    ## Altura mínima depende de si existe o no zona de piking.
	if(PIKING=="True"):
		alturamin = 2
		altura = 1
	if(PIKING=="False"):
		alturamin = 1
		altura = 0
	#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_GS1128(tiempolectura)
		## 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 piloto_empieza, piloto_termina, lecturas_correctas, lecturas_incidencias
			###
			### 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[0] == "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[1])
				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_GS1128(tiempolectura)
					## 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 iniciarTrabajo_GS1128_noSSCC(empresa, pasillo, alturamax, tiempolectura, PIKING):
    	## 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()
    ## Altura mínima depende de si existe o no zona de piking.
	if(PIKING=="True"):
		alturamin = 2
		altura = 1
	if(PIKING=="False"):
		alturamin = 1
		altura = 0
	#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_GS1128_noSSCC(tiempolectura)
		## 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 piloto_empieza, piloto_termina, lecturas_correctas, lecturas_incidencias
			###
			### 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[0] == "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[1])
				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_GS1128_noSSCC(tiempolectura)
					## 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)
			###

##################################################################################################
# FUNCIONES ESPECÍFICAS DE LA OPERATIVA DE TRABAJO APILAMIENTO/ALTURAS VARIABLES                 #
##################################################################################################

def iniciarTrabajo_Code128_apilamiento(empresa, pasillo, alturamax, longitud, tiempolectura):
    	## 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)

	## EN LOS APILAMIENTOS O ALTURAS VARIABLES CAMBIA LA OPERATIVA DE VUELO
	## LEEMOS UNA COLUMNA Y AL TERMINARLA COMENZAMOS CON OTRA. SIEMPRE SUBIMOS
	SUBIENDO = True
	## Registramos la hora en la que el piloto comienza el trabajo en el pasillo.
	piloto_empieza = datetime.datetime.now()
    ## EN LOS APILAMIENTOS LA ALTURA 1 NO ESTA DESTINADA A PICKING, POR TANTO ALTURAMIN ES 1
	alturamin = 1
	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)
			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)
	indicador_columna = ""
	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))
		##
		###
		###
		## PRIMERO) VER SI HEMOS TERMINADO LA COLUMNA
		if(altura > alturamax):
			altura = 1
			columna = columna + 1
			indicador_columna = "FIN_COLUMNA"
		## SEGUNDO) TOMAMOS LECTURA PARA METER EN NUEVA POSICIÓN
		lectura = n568xug_Code128(int(longitud), tiempolectura)
		## TERCERO) PROCESAMOS LA LECTURA
		## SI EXISTE UNA LECTURA VÁLIDA LA INTEGRAMOS EN EL MAPA
		if(lectura != ultima_lectura and lectura != "" and indicador_columna != "FIN_COLUMNA"):
			item = item + 1
			ultima_lectura = lectura
			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)
			altura = altura + 1
			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 ESTE CASO TENDREMOS QUE USAR EL MANDO BLUETOOTH, SEGÚN EL BOTÓN SE REGISTRARÁ:
			# - ALTURA NUEVA COLUMNA --> introducimos un número que son las alturas de la nueva columna (aX)
			# - INCIDENCIA DESCONOCIDA --> tenemos que aumentar el numero de incidencias
			# - 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.
			## 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) 
			## a:anº: alturas de nueva columna. La altura se establece con "aX" siendo X un número que indica la altura
			### 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 piloto_empieza, piloto_termina, lecturas_correctas, lecturas_incidencias
			###
			### ERROR
			if(respuesta_piloto == "e"):
				lectura = "INCIDENCIA"
				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)
				altura = altura + 1
				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.
			## e: error.
			if(respuesta_piloto[0] == "m"):
				## En multicapa tenemos los dos led azules encendidos
				gpio.output(LED1B, gpio.HIGH)
				item_multicapa = 0
				## PEDIMOS EL TAMAÑO DE LA MULTICAPA
				item_ultimo = int(respuesta_piloto[1])
				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_Code128(int(longitud), tiempolectura)
					## 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
						###
						### 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)
				altura = altura + 1
				###
			if(respuesta_piloto[0] == "a"):
				alturamax = int(respuesta_piloto[1])
				indicador_columna = ""
			### FIN DE LA COMUNICACIÓN CON EL PILOTO
			gpio.output(LED2B, gpio.LOW)
			gpio.output(LED1G, gpio.HIGH)
			###	

def iniciarTrabajo_GS1128_apilamiento(empresa, pasillo, alturamax, tiempolectura):
	## 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
	piloto_empieza = datetime.datetime.now()
	alturamin = 1
	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))
	indicador_columna = ""
	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))
		##
		###
		###
		## PRIMERO) VER SI HEMOS TERMINADO LA COLUMNA
		if(altura > alturamax):
			altura = 1
			columna = columna + 1
			indicador_columna = "FIN_COLUMNA"
		## SEGUNDO) TOMAMOS LECTURA PARA METER EN NUEVA POSICIÓN
		lectura = n568xug_GS1128(tiempolectura)
		## TERCERO) PROCESAMOS LA LECTURA
		## SI EXISTE UNA LECTURA VÁLIDA LA INTEGRAMOS EN EL MAPA
		if(lectura != ultima_lectura and lectura != "" and indicador_columna != "FIN_COLUMNA"):
			item = item + 1
			ultima_lectura = lectura
			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)
			altura = altura + 1
			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 ESTE CASO TENDREMOS QUE USAR EL MANDO BLUETOOTH, SEGÚN EL BOTÓN SE REGISTRARÁ:
			# - ALTURA NUEVA COLUMNA --> introducimos un número que son las alturas de la nueva columna (aX)
			# - INCIDENCIA DESCONOCIDA --> tenemos que aumentar el numero de incidencias
			# - 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.
			## 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) 
			## a:anº: alturas de nueva columna. La altura se establece con "aX" siendo X un número que indica la altura
			### 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 piloto_empieza, piloto_termina, lecturas_correctas, lecturas_incidencias
			###
			### ERROR
			if(respuesta_piloto == "e"):
				lectura = "INCIDENCIA|-|-"
				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)
				altura = altura + 1
				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.
			## e: error.
			if(respuesta_piloto[0] == "m"):
				## En multicapa tenemos los dos led azules encendidos
				gpio.output(LED1B, gpio.HIGH)
				item_multicapa = 0
				## PEDIMOS EL TAMAÑO DE LA MULTICAPA
				item_ultimo = int(respuesta_piloto[1])
				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_GS1128(tiempolectura)
					## 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
						###
						### 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)
				altura = altura + 1
				###
			if(respuesta_piloto[0] == "a"):
				alturamax = int(respuesta_piloto[1])
				indicador_columna = ""
			### FIN DE LA COMUNICACIÓN CON EL PILOTO
			gpio.output(LED2B, gpio.LOW)
			gpio.output(LED1G, gpio.HIGH)
			###		

def iniciarTrabajo_GS1128_noSSCC_apilamiento(empresa, pasillo, alturamax, tiempolectura):
	## 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
	piloto_empieza = datetime.datetime.now()
	alturamin = 1
	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))
	indicador_columna = ""
	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))
		##
		###
		###
		## PRIMERO) VER SI HEMOS TERMINADO LA COLUMNA
		if(altura > alturamax):
			altura = 1
			columna = columna + 1
			indicador_columna = "FIN_COLUMNA"
		## SEGUNDO) TOMAMOS LECTURA PARA METER EN NUEVA POSICIÓN
		lectura = n568xug_GS1128_noSSCC(tiempolectura)
		## TERCERO) PROCESAMOS LA LECTURA
		## SI EXISTE UNA LECTURA VÁLIDA LA INTEGRAMOS EN EL MAPA
		if(lectura != ultima_lectura and lectura != "" and indicador_columna != "FIN_COLUMNA"):
			item = item + 1
			ultima_lectura = lectura
			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)
			altura = altura + 1
			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 ESTE CASO TENDREMOS QUE USAR EL MANDO BLUETOOTH, SEGÚN EL BOTÓN SE REGISTRARÁ:
			# - ALTURA NUEVA COLUMNA --> introducimos un número que son las alturas de la nueva columna (aX)
			# - INCIDENCIA DESCONOCIDA --> tenemos que aumentar el numero de incidencias
			# - 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.
			## 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) 
			## a:anº: alturas de nueva columna. La altura se establece con "aX" siendo X un número que indica la altura
			### 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 piloto_empieza, piloto_termina, lecturas_correctas, lecturas_incidencias
			###
			### ERROR
			if(respuesta_piloto == "e"):
				lectura = "INCIDENCIA|-|-"
				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)
				altura = altura + 1
				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.
			## e: error.
			if(respuesta_piloto[0] == "m"):
				## En multicapa tenemos los dos led azules encendidos
				gpio.output(LED1B, gpio.HIGH)
				item_multicapa = 0
				## PEDIMOS EL TAMAÑO DE LA MULTICAPA
				item_ultimo = int(respuesta_piloto[1])
				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_GS1128_noSSCC(tiempolectura)
					## 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
						###
						### 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)
				altura = altura + 1
				###
			if(respuesta_piloto[0] == "a"):
				alturamax = int(respuesta_piloto[1])
				indicador_columna = ""
			### FIN DE LA COMUNICACIÓN CON EL PILOTO
			gpio.output(LED2B, gpio.LOW)
			gpio.output(LED1G, gpio.HIGH)
			###	

##################################################################################################
# FUNCIONES ESPECÍFICAS DE ENVÍO Y PROCESADO DEL TRABAJO REALIZADO                               #
##################################################################################################

def pasarEXCEL_Code128(direccion_trabajo, direccion_excel):
	import io
	from openpyxl import Workbook
	## Creamos una lista con la informacion de archivo_trabajo
	archivo_trabajo = open(direccion_trabajo, "r") # el archivo tiene que existir
	items = archivo_trabajo.readlines() # lista creada, que tendremos que procesar
	archivo_trabajo.close()
	## Ahora procesaremos la información de items en una lista con listas
	items_procesado = list([])
	for lectura in items:
		aux_lista = lectura.split("|")
		aux_lectura = list([aux_lista[0], aux_lista[1], aux_lista[2]]) # columna, altura, lectura
		items_procesado.append(aux_lectura)
	## Tenemos que crear en memoria el contenido de nuestro archivo excel. Funciona distinto a *.txt
	#wb = openpyxl.workbook.Workbook()
	wb = Workbook()
	ws = wb.active
	ws.title = "Lecturas pasillo"
	#ws = openpyxl.workbook.Workbook.create_sheet("Lecturas pasillo")
	ws.cell(row=1, column=1, value="Columna")
	ws.cell(row=1, column=2, value="Altura")
	ws.cell(row=1, column=3, value="Contenido")
	r = 2
	for dato in items_procesado:
		ws.cell(row=r, column=1, value=dato[0]) #columna
		ws.cell(row=r, column=2, value=dato[1]) #altura
		ws.cell(row=r, column=3, value=dato[2]) #lectura
		r = r + 1
	wb.save(direccion_excel)

def pasarEXCEL_GS1128(direccion_trabajo, direccion_excel):
	import io
	from openpyxl import Workbook
	## Creamos una lista con la informacion de archivo_trabajo
	archivo_trabajo = open(direccion_trabajo, "r") # el archivo tiene que existir
	items = archivo_trabajo.readlines() # lista creada, que tendremos que procesar
	archivo_trabajo.close()
	## Ahora procesaremos la información de items en una lista con listas
	items_procesado = list([])
	for lectura in items:
		aux_lista = lectura.split("|")
		aux_lectura = list([aux_lista[0], aux_lista[1], aux_lista[2], aux_lista[3], aux_lista[4]]) # columna, altura, IA00, IA01, IA02
		items_procesado.append(aux_lectura)
	## Tenemos que crear en memoria el contenido de nuestro archivo excel. Funciona distinto a *.txt
	#wb = openpyxl.workbook.Workbook()
	wb = Workbook()
	ws = wb.active
	ws.title = "Lecturas pasillo"
	#ws = openpyxl.workbook.Workbook.create_sheet("Lecturas pasillo")
	ws.cell(row=1, column=1, value="Columna")
	ws.cell(row=1, column=2, value="Altura")
	ws.cell(row=1, column=3, value="(00)")
	ws.cell(row=1, column=4, value="(01)")
	ws.cell(row=1, column=5, value="(02)")
	r = 2
	for dato in items_procesado:
		ws.cell(row=r, column=1, value=dato[0]) #columna
		ws.cell(row=r, column=2, value=dato[1]) #altura
		ws.cell(row=r, column=3, value=dato[2]) #(00)
		ws.cell(row=r, column=4, value=dato[3]) #(01)
		ws.cell(row=r, column=5, value=dato[4]) #(02)
		r = r + 1
	wb.save(direccion_excel)

def procesar_envioTrabajo(direccion_trabajo, direccion_excel, gmail, empresa, pasillo, CODE):
	import smtplib
	## Librerias para construir el mensaje
	from email.mime.multipart import MIMEMultipart
	from email.mime.text import MIMEText
	## Librerias para adjuntar archivos
	from email.MIMEBase import MIMEBase
	from email import encoders

	## Transformamos el archivo_trabajo en un excel para el cliente
	direccion_trabajo = direccion_trabajo
	direccion_excel = direccion_excel
	if(CODE == "Code128"):
		pasarEXCEL_Code128(direccion_trabajo, direccion_excel)
	if(CODE == "GS1128" or CODE == "GS1128noSSCC"):
		pasarEXCEL_GS1128(direccion_trabajo, direccion_excel)
	
	## Ahora vamos a construir el mensaje
	## Definimos remitente y receptor
	addr_to = str(gmail)
	addr_from = "operativa.airvant@gmail.com"
	## Definimos SMTP del email
	smtp_server = "stmp.gmail.com"
	smtp_user = "operativa.airvant@gmail.com"
	smtp_pass = "#airvant.onw"
	## Construimos el email
	mensaje = MIMEMultipart()
	mensaje['From'] = addr_from
	mensaje['To'] = str(gmail)
	mensaje['Subject'] = "Airvant | Empresa: {0} Pasillo: {1}" .format(empresa, pasillo)
	# El cuerpo del mensaje se estructura en HTML
	mensaje.attach(MIMEText('<h1>Trabajo de pasillo finalizado</h1><p>Descargue el archivo EXCEL adjunto.<p>Gracias por confiar en <b>Airvant</b>.', 'HTML'))
	# Adjuntamos el archivo de direccion_trabajo
	fp = open(direccion_excel, 'rb')
	adjunto = MIMEBase('multipart', 'encrypted')
	adjunto.set_payload(fp.read())
	fp.close()
	# Encriptamos archivo.
	encoders.encode_base64(adjunto)
	nombre_archivo = empresa + " " + pasillo + ".xlsx"
	adjunto.add_header('Content-Disposition', 'attachment', filename = nombre_archivo)
	mensaje.attach(adjunto)
	
	## Script para el envío del correo electrónico a la dirección indicada
	mailServer = smtplib.SMTP('smtp.gmail.com', 587)
	mailServer.ehlo()
	mailServer.starttls()
	mailServer.ehlo()
	mailServer.login(smtp_user, smtp_pass)
	mailServer.sendmail(addr_from, addr_to, mensaje.as_string())
	mailServer.quit()
	