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

######################################################################################################
 # SOFTWARE PARA DISPOSITIVO SOBRE DRON RADIOCONTROLADO.
 # DESARROLLO DE SOFTWARE E IMPLEMENTACIÓN DE HARDWARE:
 #  Juan de Dios Yáñez Ávila, CEO Onwards, Director I+D+i en Airvant.
 # EMAIL DE CONTACTO:
 #  juandediosyanez@onw4rds.com | juandediosyanez@gmail.com
 # ARCHIVO: Airvant.py
 # VERSIÓN: 2.1.
 # ENTORNO DE USO: Python 2.7.13.
 # FECHA: 2017/11/16
 # 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 datetime
import io
import os
import serial
import time
import RPi.GPIO as gpio
from bluetooth import *

##################################################################################################
# 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

picajes = list()
direccion_picajes = str()
direccion_picajes_procesados = str()


##################################################################################################
# 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):
	# 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_IA0x = "-"
    leyendo = list()
    L = 48
    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
		gpio.output(LED1B, gpio.HIGH)
		IA00 = True
		#
		print("TENEMOA 00")
		print(lectura_IA00)
		#
	if(IA01 == False and lectura[0:2] == "01"):
		lectura_IA0x = lectura
		gpio.output(LED2B, gpio.HIGH)
		IA01 = True
		#
		print("TENEMOA 01")
		print(lectura_IA0x)
		#
	if(IA02 == False and lectura[0:2] == "02"):
		lectura_IA0x = lectura
		gpio.output(LED2B, gpio.HIGH)
		IA02 = True
		#
		print("TENEMOA 02")
		print(lectura_IA0x)
		#
	TIEMPO_TRANSCURRIDO_LECTURA = datetime.datetime.now()
	TIEMPO_DIFERENCIA_LECTURA = TIEMPO_TRANSCURRIDO_LECTURA - TIEMPO_INICIO_LECTURA
	if(IA00 == True and (IA01 == True or IA02 == True)):
		leyendo.append(lectura_IA00)
		leyendo.append(lectura_IA0x)
		time.sleep(1)
		break # Nos salimos del while en cuanto tenemos lectura válida + 1 segundo		
	if(TIEMPO_DIFERENCIA_LECTURA.seconds >= tiempolectura):
		leyendo.append(lectura_IA00)
		leyendo.append(lectura_IA0x)
		time.sleep(1)
		break # Nos salimos del while a los 4+1 segundos			
    gpio.output(LED1B, gpio.LOW)
    gpio.output(LED2B, gpio.LOW)

    print(leyendo)
    print(lectura_IA00)
    print(lectura_IA0x)

   
    
    # Procesamos la lectura
    if(leyendo[0] == "-" or leyendo[1] == "-"):
        # Bien se ha producido un error o queremos alguna instruccion
        gpio.output(LED1B, gpio.LOW)
        gpio.output(LED2B, gpio.LOW)
        return ["-", "-"]
    else:
        # En este caso hemos realizado dos lecturas
        # PROCESAMIENTO DE UNA LECTURA GS1 128
        gs1 = {"00": "-", "01": "-", "02": "-", "37": "-",
            "10": "-", "11": "-", "13": "-", "15": "-", "17": "-", "310X":"-","330X":"-"}
        lectura_uno = leyendo[0]
        size_lectura_uno = len(lectura_uno)

        while(size_lectura_uno != 0):

            if(lectura_uno[0:2] == "00"):
                gs1["00"] = lectura_uno[2:20]
                lectura_uno = lectura_uno[20:]
                size_lectura_uno = len(lectura_uno)

            if(lectura_uno[0:2] == "01"):
                gs1["01"] = lectura_uno[2:16]
                lectura_uno = lectura_uno[16:]
                size_lectura_uno = len(lectura_uno)

            if(lectura_uno[0:2] == "02"):
                gs1["02"] = lectura_uno[2:16]
                lectura_uno = lectura_uno[16:]
                size_lectura_uno = len(lectura_uno)

            if(lectura_uno[0:2] == "37"):
                aux = lectura_uno.split("")  # CAMBIAR EN LINUX
		if(len(aux) == 2):
	                gs1["37"] = aux[0][2:]
        	        lectura_uno = aux[1]
                	size_lectura_uno = len(lectura_uno)
		else:
			gs1["37"] = aux[0][2:0]
			size_lectura_uno = 0

            if(lectura_uno[0:2] == "10"):
                aux = lectura_uno.split("")  # CAMBIAR EN LINUX
		if(len(aux) == 2):
	                gs1["10"] = aux[0][2:]
        	        lectura_uno = aux[1]
                	size_lectura_uno = len(lectura_uno)
		else:
			gs1["10"] = aux[0][2:]
			size_lectura_uno = 0

            if(lectura_uno[0:2] == "11"):
                gs1["11"] = lectura_uno[2:8]
                lectura_uno = lectura_uno[8:]
                size_lectura_uno = len(lectura_uno)

            if(lectura_uno[0:2] == "13"):
                gs1["13"] = lectura_uno[2:8]
                lectura_uno = lectura_uno[8:]
                size_lectura_uno = len(lectura_uno)

            if(lectura_uno[0:2] == "15"):
                gs1["15"] = lectura_uno[2:8]
                lectura_uno = lectura_uno[8:]
                size_lectura_uno = len(lectura_uno)

            if(lectura_uno[0:2] == "17"):
                gs1["17"] = lectura_uno[2:8]
                lectura_uno = lectura_uno[8:]
                size_lectura_uno = len(lectura_uno)

            if(lectura_uno[0:3] == "310"):
                gs1["310X"] = lectura_uno[4:10]
                lectura_uno = lectura_uno[10:]
                size_lectura_uno = len(lectura_uno)

            if(lectura_uno[0:3] == "330"):
                gs1["330X"] = lectura_uno[4:10]
                lectura_uno = lectura_uno[10:]
                size_lectura_uno = len(lectura_uno)

        lectura_dos = leyendo[1]
        size_lectura_dos = len(lectura_dos)

        while(size_lectura_dos != 0):

            if(lectura_dos[0:2] == "00"):
                gs1["00"] = lectura_dos[2:20]
                lectura_dos = lectura_dos[20:]
                size_lectura_dos = len(lectura_dos)

            if(lectura_dos[0:2] == "01"):
                gs1["01"] = lectura_dos[2:16]
                lectura_dos = lectura_dos[16:]
                size_lectura_dos = len(lectura_dos)

            if(lectura_dos[0:2] == "02"):
                gs1["02"] = lectura_dos[2:16]
                lectura_dos = lectura_dos[16:]
                size_lectura_dos = len(lectura_dos)

            if(lectura_dos[0:2] == "37"):
                aux = lectura_dos.split("")  # CAMBIAR EN LINUX
		if(len(aux) == 2):
	                gs1["37"] = aux[0][2:]
        	        lectura_dos = aux[1]
                	size_lectura_dos = len(lectura_dos)
		else:
			gs1["37"] = aux[0][2:0]
			size_lectura_dos = 0

            if(lectura_dos[0:2] == "10"):
                aux = lectura_dos.split("")  # CAMBIAR EN LINUX
		if(len(aux) == 2):
	                gs1["10"] = aux[0][2:]
        	        lectura_dos = aux[1]
                	size_lectura_dos = len(lectura_dos)
		else:
			gs1["10"] = aux[0][2:]
			size_lectura_dos = 0

            if(lectura_dos[0:2] == "11"):
                gs1["11"] = lectura_dos[2:8]
                lectura_dos = lectura_dos[8:]
                size_lectura_dos = len(lectura_dos)

            if(lectura_dos[0:2] == "13"):
                gs1["13"] = lectura_dos[2:8]
                lectura_dos = lectura_dos[8:]
                size_lectura_dos = len(lectura_dos)

            if(lectura_dos[0:2] == "15"):
                gs1["15"] = lectura_dos[2:8]
                lectura_dos = lectura_dos[8:]
                size_lectura_dos = len(lectura_dos)

            if(lectura_dos[0:2] == "17"):
                gs1["17"] = lectura_dos[2:8]
                lectura_dos = lectura_dos[8:]
                size_lectura_dos = len(lectura_dos)

            if(lectura_dos[0:3] == "310"):
                gs1["310X"] = lectura_dos[4:10]
                lectura_dos = lectura_dos[10:]
                size_lectura_dos = len(lectura_dos)

            if(lectura_dos[0:3] == "330"):
                gs1["330X"] = lectura_dos[4:10]
                lectura_dos = lectura_dos[10:]
                size_lectura_dos = len(lectura_dos)

	print(gs1)

        # Preparamos el return con una cadena ordenada de los parámetros del diccionario gs1
        respuesta = str(gs1["00"]) + " " + str(gs1["01"]) + " " + str(gs1["02"]) + " " + str(gs1["37"]) + " " + str(gs1["10"]) + " " + str(gs1["11"]) + " " + str(gs1["13"]) + " " + str(gs1["15"]) + " " + str(gs1["17"]) + " " + str(gs1["310X"]) + " " + str(gs1["330X"])
        
	print(respuesta)

	return respuesta


"""
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():

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

	# Informamos al técnico de que el piloto esta dando instrucciones
    print("ESPERANDO CONFIRMACIÓN...")
    # Realizamos conexión no continua por bluetooth
    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)

    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"):
            gpio.output(LED1B, gpio.LOW)
            return "i"
        if(data == "c"):
            gpio.output(LED1B, gpio.LOW)
            return "c"
        if(data == "t"):
            gpio.output(LED1B, gpio.LOW)
            return "t"
        print("ESPERANDO CONFIRMACIÓN VÁLIDA (i) (c) (t)...")

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


def iniciarTrabajo_Code128(empresa, pasillo, longitud, tiempolectura):
	# Avisamos de variables globales
    global piloto_empieza
    global piloto_termina
    global picajes
    global archivo_picajes
    global direccion_picajes

	# 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)

    # Ponemos nombre y dirección a lecturas
    fecha = datetime.datetime.now()
    nombre_picajes = "lecturas " + str(fecha.year) + str(fecha.month) + str(fecha.day) + " " + str(empresa) + " " + str(pasillo) + ".txt"
    direccion_picajes = "picajes/" + str(nombre_picajes)

    # Vemos si el archivo_picajes existe o no
    existe_picajes = False
    if(os.path.exists(direccion_picajes) == False):
        archivo_picajes = open(direccion_picajes, "w")
        archivo_picajes.close()
    else:
        archivo_picajes = open(direccion_picajes, "r")
        existe_picajes = True
        # Actualizamos nuestra variable mapa. Podremos continuar el trabajo por donde lo dejamos,
        # pero actualmente no podemos especificar el punto exacto donde lo dejamos
        picajes = archivo_picajes.readlines()
        archivo_picajes.close()
        # Si el mapa se comenzó pero no tiene nigún registro se aconseja borrarlo.
        if(len(picajes) == 0):
            archivo_mapa = open(direccion_mapa, "w")
            archivo_mapa.close()
        # else:
            # TENEMOS QUE CREAR UN AVISO DE QUE EXISTE EL TRABAJO, CON UNA VENTANA EMERGENTE. Y QUE
            # LO VAMOS A CONTINUAR
    print("** INVENTARIANDO... **\n")
    time.sleep(2)
    ultima_lectura = ""
    while(True):
		# El piloto sabe que puede comenzar a trabajar porque se enciende el sensor láser
        # Solo usando esta referencia ahorramos batería
        lectura = n568xug_Code128(int(longitud), tiempolectura)
		# Si la lectura es válida se integra en picajes
        if ((lectura != ultima_lectura) and (lectura != "")):
	    ultima_lectura = lectura
            picajes.append(lectura)
            dato = str(lectura) + "\n"
			# Guardamos en el archivo_picajes y en picajes la lectura
            archivo_picajes = open(direccion_picajes, 'a')
            archivo_picajes.write(dato)
            archivo_picajes.close()
            # Mostramos la lectura
            print(dato)
			# Lectura correcta -> leds en verde
            gpio.output(LED1G, gpio.HIGH)
            gpio.output(LED34G, gpio.HIGH)
            time.sleep(1)
            gpio.output(LED1G, gpio.LOW)
            gpio.output(LED34G, gpio.LOW)
			###
		# Si pasamos cierto tiempo sin tener una lectura válida puede ser que queramos terminar
        if(lectura == ''):
			# Ya no podemos seguir trabajando, marcamos error
            gpio.output(LED3R, gpio.HIGH)
            gpio.output(LED4R, gpio.HIGH)
			# Llamamos a respuesta_piloto para saber que hacer
            respuesta_piloto = peticion_piloto()
            # Aunque las luces se apagan al entrar en peticion_piloto(), nos aseguramos
            gpio.output(LED3R, gpio.LOW)
            gpio.output(LED4R, gpio.LOW)
			# 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.
			# INICIAR
            if(respuesta_piloto == "i"):
                gpio.output(LED1G, gpio.HIGH)
                gpio.output(LED34G, gpio.HIGH)
                print("INICIANDO PICAJE...")
                time.sleep(1)
                gpio.output(LED1G, gpio.LOW)
                gpio.output(LED34G, gpio.LOW)
			###
			# CONTINUAR
            if(respuesta_piloto == "c"):
				# Aunque este descansando el tiempo de pasillo sigue corriendo.
                gpio.output(LED1G, gpio.HIGH)
                gpio.output(LED34G, gpio.HIGH)
                print("RETOMANDO PICAJE...")
                time.sleep(1)
                gpio.output(LED1G, gpio.LOW)
                gpio.output(LED34G, gpio.LOW)
			###
			# TERMINAR
            if(respuesta_piloto == "t"):
                piloto_termina = datetime.datetime.now()
                gpio.output(LED1G, gpio.HIGH)
                gpio.output(LED34G, gpio.HIGH)
                print("PICAJE TERMINADO")
                time.sleep(1)
                gpio.output(LED1G, gpio.LOW)
                gpio.output(LED34G, gpio.LOW)
				# AQUI PODRIAMOS YA ENVIAR EL TRABAJO, PERO MEJOR LO HAGA EL TÉCNICO
                # LLAMAMOS A LA FUNCIÓN DE ENVIAR TRABAJO FTP PARA CAZARLO CON EL WBC
                return piloto_empieza, piloto_termina, len(picajes)


def iniciarTrabajo_GS1128(empresa, pasillo, tiempolectura):
    # Avisamos de variables globales
    global piloto_empieza
    global piloto_termina
    global picajes
    global archivo_picajes
    global direccion_picajes

	# 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)

    # Ponemos nombre y dirección a lecturas
    fecha = datetime.datetime.now()
    nombre_picajes = "lecturas " + \
        str(fecha.year) + str(fecha.month) + str(fecha.day) + \
            " " + empresa + " " + pasillo + ".txt"
    direccion_picajes = "picajes/" + str(nombre_picajes)

    # Vemos si el archivo_picajes existe o no
    existe_picajes = False
    if(os.path.exists(direccion_picajes) == False):
        archivo_picajes = open(direccion_picajes, "w")
        archivo_picajes.close()
    else:
        archivo_picajes = open(direccion_picajes, "r")
        existe_picajes = True
        # Actualizamos nuestra variable mapa. Podremos continuar el trabajo por donde lo dejamos,
        # pero actualmente no podemos especificar el punto exacto donde lo dejamos
        picajes = archivo_picajes.readlines()
        archivo_picajes.close()
        # Si el mapa se comenzó pero no tiene nigún registro se aconseja borrarlo.
        if(len(picajes) == 0):
            archivo_picajes = open(direccion_picajes, "w")
            archivo_picajes.close()
        # else:
            # TENEMOS QUE CREAR UN AVISO DE QUE EXISTE EL TRABAJO, CON UNA VENTANA EMERGENTE. Y QUE
            # LO VAMOS A CONTINUAR
    print("** INVENTARIANDO... **\n")
    time.sleep(2)
    ultima_lectura = ""
    while(True):
	# El piloto sabe que puede comenzar a trabajar porque se enciende el sensor láser
        # Solo usando esta referencia ahorramos batería
        lectura = n568xug_GS1128(tiempolectura)
		# Si la lectura es válida se integra en picajes

	print("LECTURA ENTREGADA")
	print(lectura)


        if ((lectura != ultima_lectura) and (lectura != ["-", "-"])):
	    ultima_lectura = lectura


	    print("DEBERIAMOS GUARDAR ESTO")

            picajes.append(lectura)
            dato = str(lectura) + "\n"
	    # Guardamos en el archivo_picajes y en picajes la lectura
            archivo_picajes = open(direccion_picajes, 'a')
            archivo_picajes.write(dato)
            archivo_picajes.close()
            # Mostramos la lectura
            print(dato)
	    # Lectura correcta -> leds en verde
            gpio.output(LED1G, gpio.HIGH)
            gpio.output(LED34G, gpio.HIGH)
            time.sleep(1)
            gpio.output(LED1G, gpio.LOW)
            gpio.output(LED34G, gpio.LOW)
			###
		# Si pasamos cierto tiempo sin tener una lectura válida puede ser que queramos terminar
        if(lectura == ["-", "-"]):
			# Ya no podemos seguir trabajando, marcamos error
            gpio.output(LED3R, gpio.HIGH)
            gpio.output(LED4R, gpio.HIGH)
			# Llamamos a respuesta_piloto para saber que hacer
            respuesta_piloto = peticion_piloto()
            # Aunque las luces se apagan al entrar en peticion_piloto(), nos aseguramos
            gpio.output(LED3R, gpio.LOW)
            gpio.output(LED4R, gpio.LOW)
			# 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.
			# INICIAR
            if(respuesta_piloto == "i"):
                gpio.output(LED1G, gpio.HIGH)
                gpio.output(LED34G, gpio.HIGH)
                print("INICIANDO PICAJE...")
                time.sleep(1)
                gpio.output(LED1G, gpio.LOW)
                gpio.output(LED34G, gpio.LOW)
			###
			# CONTINUAR
            if(respuesta_piloto == "c"):
				# Aunque este descansando el tiempo de pasillo sigue corriendo.
                gpio.output(LED1G, gpio.HIGH)
                gpio.output(LED34G, gpio.HIGH)
                print("RETOMANDO PICAJE...")
                time.sleep(1)
                gpio.output(LED1G, gpio.LOW)
                gpio.output(LED34G, gpio.LOW)
			###
			# TERMINAR
            if(respuesta_piloto == "t"):
                piloto_termina = datetime.datetime.now()
                gpio.output(LED1G, gpio.HIGH)
                gpio.output(LED34G, gpio.HIGH)
                print("PICAJE TERMINADO")
                time.sleep(1)
                gpio.output(LED1G, gpio.LOW)
                gpio.output(LED34G, gpio.LOW)
				# AQUI PODRIAMOS YA ENVIAR EL TRABAJO, PERO MEJOR LO HAGA EL TÉCNICO
                # LLAMAMOS A LA FUNCIÓN DE ENVIAR TRABAJO FTP PARA CAZARLO CON EL WBC
                return piloto_empieza, piloto_termina, len(picajes)

"""    
def iniciarTrabajo_GS1128_noSSCC(empresa, pasillo, tiempolectura):
    # Avisamos de variables globales
	global piloto_empieza
	global piloto_termina
    
    global picajes
    global archivo_picajes
	global direccion_picajes

	# 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)

    # Ponemos nombre y dirección a lecturas
    fecha = datetime.datetime.now()
    nombre_picajes = "lecturas " + str(fecha.year) + str(fecha.month) + str(fecha.day) + " " + empresa + " " + pasillo + ".txt"
    direccion_picajes = "picajes/" + str(nombre_picajes)
    
    # Vemos si el archivo_picajes existe o no
    existe_picajes = False
    if(os.path.exists(direccion_picajes) == False):
        archivo_picajes = open(direccion_picajes, "w")
        archivo_picajes.close()
    else:
        archivo_picajes = open(direccion_picajes, "r")
        existe_picajes = True
        # Actualizamos nuestra variable mapa. Podremos continuar el trabajo por donde lo dejamos,
        # pero actualmente no podemos especificar el punto exacto donde lo dejamos
        picajes = archivo_picajes.readlines()
        archivo_picajes.close()
        # Si el mapa se comenzó pero no tiene nigún registro se aconseja borrarlo.
        if(len(picajes) == 0):
            archivo_mapa = open(direccion_mapa, "w")
            archivo_mapa.close()
        # else:
            # TENEMOS QUE CREAR UN AVISO DE QUE EXISTE EL TRABAJO, CON UNA VENTANA EMERGENTE. Y QUE
            # LO VAMOS A CONTINUAR
    print("** INVENTARIANDO... **\n")
    time.sleep(2)
	while(True):
		# El piloto sabe que puede comenzar a trabajar porque se enciende el sensor láser
        # Solo usando esta referencia ahorramos batería
		lectura = n568xug_GS1128_noSSCC(tiempolectura)
		# Si la lectura es válida se integra en picajes
		if ((lectura in picajes == False) or (lectura != '')):
            picajes.append(lectura)
			dato = str(lectura)+"\n" 
			# Guardamos en el archivo_picajes y en picajes la lectura
			archivo_picajes = open(direccion_picajes, 'a')
			archivo_picajes.write(dato)
			archivo_trabajo.close()
            # Mostramos la lectura
			print(dato)
			# Lectura correcta -> leds en verde
			gpio.output(LED1G, gpio.HIGH)
            gpio.output(LED34G, gpio.HIGH)
			time.sleep(1)
            gpio.output(LED1G, gpio.LOW)
			gpio.output(LED34G, gpio.LOW)
			###
		# Si pasamos cierto tiempo sin tener una lectura válida puede ser que queramos terminar
		if(lectura == ''):
			# Ya no podemos seguir trabajando, marcamos error
			gpio.output(LED3R, gpio.HIGH)
			gpio.output(LED4R, gpio.HIGH)
			# Llamamos a respuesta_piloto para saber que hacer
			respuesta_piloto = peticion_piloto()
            # Aunque las luces se apagan al entrar en peticion_piloto(), nos aseguramos
            gpio.output(LED3R, gpio.LOW)
			gpio.output(LED4R, gpio.LOW)
			# 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.
			# INICIAR
			if(respuesta_piloto == "i"):
                gpio.output(LED1G, gpio.HIGH)
                gpio.output(LED34G, gpio.HIGH)
				print("INICIANDO PICAJE...")
				time.sleep(1)
                gpio.output(LED1G, gpio.LOW)
                gpio.output(LED34G, gpio.LOW)
			###
			# CONTINUAR
			if(respuesta_piloto == "c"):
				# Aunque este descansando el tiempo de pasillo sigue corriendo.
                gpio.output(LED1G, gpio.HIGH)
                gpio.output(LED34G, gpio.HIGH)
				print("RETOMANDO PICAJE...")
				time.sleep(1)
                gpio.output(LED1G, gpio.LOW)
                gpio.output(LED34G, gpio.LOW)
			###
			# TERMINAR
			if(respuesta_piloto == "t"):
				piloto_termina = datetime.datetime.now()
                gpio.output(LED1G, gpio.HIGH)
                gpio.output(LED34G, gpio.HIGH)
				print("PICAJE TERMINADO")
				time.sleep(1)
                gpio.output(LED1G, gpio.LOW)
                gpio.output(LED34G, gpio.LOW)
				# AQUI PODRIAMOS YA ENVIAR EL TRABAJO, PERO MEJOR LO HAGA EL TÉCNICO
                # LLAMAMOS A LA FUNCIÓN DE ENVIAR TRABAJO FTP PARA CAZARLO CON EL WBC
				return piloto_empieza, piloto_termina, len(picajes)


	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()
"""
