######################################################################################
# Filename:
#   com1.py
# Project Author:
#	 C. Javier Vindas F. (Ti2-CAW)  
#######################################################################################
# usar pyserial con el com1 (RS232 a TTL)  ZFM default baud rate is 57600bps
#
# Serial<id=0xb76a65ac, open=True>(port='/dev/ttyS0', baudrate=57600, bytesize=8,
# parity='N', stopbits=1, timeout=2, xonxoff=False, rtscts=False, dsrdtr=False)
#######################################################################################
import serial

ser = serial.Serial('/dev/ttyS0', 57600, timeout=2)

def abrir_puerto(ser_n=1):
	global ser
	if not ser.isOpen():ser.open()

	print ser.portstr        # check which port was really used
	print ser
########
def cerrar_puerto(ser_n=1):
	global ser
	if ser.isOpen(): ser.close()  # close port
#########
	
def sendInstruction(address = 0xFFFFFFFF,data_length=4,instruction_code=0x17,datos_extra=0):
	global ser	
	if address > 0xFFFFFFFF:
		print "address mayor a 0xFFFFFFFF " 
		return -1
	if data_length > 8:
		print "data_length mayor a 8" 
		return -1
	addr_bits_hh, residuo = divmod(address, 16777216)
	addr_bits_hl, residuo2 = divmod(residuo, 65536)
	addr_bits_lh, addr_bits_ll = divmod(residuo2, 256)
	length_highbits, length_lowbits = divmod(data_length, 256) #instruct + datos + checksum
	# checksum = package identifier, package length and all package contens (byte*byte)
	checksum = 1 + length_lowbits + length_highbits + instruction_code #+ datos
	if data_length == 4:
		data1=datos_extra
		checksum = checksum + data1
	elif data_length == 5:
		data1, data2 = divmod(datos_extra, 256)
		checksum = checksum + data1 + data2
	elif data_length == 6:
		data1, residuo = divmod(datos_extra, 65536)
		data2, data3 = divmod(residuo, 256)
		checksum = checksum + data1 + data2 + data3
	elif data_length == 7:
		data1, residuo = divmod(datos_extra, 16777216)
		data2, residuo2 = divmod(residuo, 65536)
		data3, data4 = divmod(residuo2, 256)
		checksum = checksum + data1 + data2 + data3 + data4
	elif data_length == 8:
		data1, residuo = divmod(datos_extra, 4294967296)
		data2, residuo2 = divmod(residuo, 16777216)
		data3, residuo3 = divmod(residuo2, 65536)
		data4, data5 = divmod(residuo3, 256)
		checksum = checksum + data1 + data2 + data3 + data4 + data5
	else:
		datos_extra = 0x00
	checksum_highbits, checksum_lowbits = divmod(checksum, 256) #(8bytes+2 de FF = 9F6)

	print " PC:>----enviando-("+hex(instruction_code)+")--> ZFM"

	ser.write(chr(0xEF))  # header_highbits
	ser.write(chr(0x01)) # header_lowbits
	ser.write(chr(addr_bits_hh))  # byte addr 1 H
	ser.write(chr(addr_bits_hl))  # byte addr 2
	ser.write(chr(addr_bits_lh))  # byte addr 3
	ser.write(chr(addr_bits_ll))  # byte addr 4 L
	ser.write(chr(0x01)) # Package identifier 
	ser.write(chr(length_highbits))
	ser.write(chr(length_lowbits))
	ser.write(chr(instruction_code)) # Instruction code 
	if data_length > 3:
		ser.write(chr(data1)) # data1
	if data_length > 4:
		ser.write(chr(data2)) # data2 
	if data_length > 5:
		ser.write(chr(data3)) # data3 
	if data_length > 6:
		ser.write(chr(data4)) # data4
	if data_length > 7:
		ser.write(chr(data5)) # data5

	ser.write(chr(checksum_highbits))
	ser.write(chr(checksum_lowbits))

	return 0	
###  fin sendInstruction()  ###

def handshake(address = 0xFFFFFFFF):
	print "\n  --- handshake ---"
	sendInstruction(address,0x4,0x17,0x0) # (address,data_length,instruction_code,datos_extra)
	cadena = ser.read(12)        # read up to 12 bytes (timeout)
	length = len(cadena)
	if length == 12:
		for i in range(12):
			print(hex(ord(cadena[i]))), #python3 print(hex(ord(cadena[i])), end="")
		err = ord(cadena[9])
		return err
	else:
		print "handshake - No se recibe respuesta del dispositivo"	
	return -1
###  fin handshake()  ###
	
def genImg(address = 0xFFFFFFFF):
	print "\n  --- genImg ---"
	sendInstruction(address,0x3,0x1) # (address,data_length,instruction_code,datos_extra)
	cadena = ser.read(12)        # read up to 12 bytes (timeout)
	length = len(cadena)
	if length == 12:
		for i in range(12):
			print(hex(ord(cadena[i]))), 
		err = ord(cadena[9])
		return err	
	else:
		print "genImg No se recibe respuesta del dispositivo"	
		return -1 
###  fin genImg()  ###

def upImage(address = 0xFFFFFFFF): # devuelve 288 paquetes de 128bytes !
	print "\n  --- upImage ---"
	sendInstruction(address,0x3,0x0A) # (address,data_length,instruction_code,datos_extra)
	cadena = ser.read(12)        # read up to 12 bytes (timeout)
	length = len(cadena)
	if length == 12:
		for i in range(12):
			print(hex(ord(cadena[i]))), 
		if ord(cadena[9]) == 0:
			print "\n upImage, listo para enviar paquetes:"

			for j in range(288):
				print "\n upImage, paquete: "+str(j) +" "
				cadena = ser.read(139)   #139
				length = len(cadena)
				if not length == 139:
					print "\n fin \n"
					break
				for i in range(139):
					print(hex(ord(cadena[i]))),
	else:
		print "upImage - No se recibe respuesta del dispositivo"	
		return -1 
###  fin upImage()  ###

def downImage(address = 0xFFFFFFFF): # no la utilize
	print "\n  --- downImage ---"
	sendInstruction(address,0x3,0x0B) # (address,data_length,instruction_code,datos_extra)
	cadena = ser.read(12)        # read up to 12 bytes (timeout)
	length = len(cadena)
	if length == 12:
		for i in range(12):
			print(hex(ord(cadena[i]))), 
	else:
		print "upImage - No se recibe respuesta del dispositivo"	

""" 		por defecto los paquetes son de 128 (+formato)
 Despues de la respuesta correcta  es necesario enviar 288 paquetes de datos
 de 139bytes (128bytes de datos + formato
Formato de cada paquete: 0xef 0x1 adress(4bytes) 0x2 0x0 0x82 (128bytes) checksum(2bytes) 
"""
###  fin downImage()  ###

def img2Tz(address = 0xFFFFFFFF,buffer_id=0x2):  # dato extra = buffer id
	print "\n  --- img2Tz ---"
	sendInstruction(address,0x4,0x02,buffer_id) # (address,data_length,instruction_code,datos_extra)
	cadena = ser.read(12)        # read up to 12 bytes (timeout)
	length = len(cadena)
	if length == 12:
		for i in range(12):
			print(hex(ord(cadena[i]))), 
		err = ord(cadena[9])
		return err	
	else:
		print "img2Tz - No se recibe respuesta del dispositivo"
		return -1
###  fin img2Tz()  ###

def regModel(address = 0xFFFFFFFF):
	print "\n  --- regModel ---"
	sendInstruction(address,0x3,0x05) # (address,data_length,instruction_code,datos_extra)
	cadena = ser.read(12)        # read up to 12 bytes (timeout)
	length = len(cadena)
	if length == 12:
		for i in range(12):
			print(hex(ord(cadena[i]))), 
		if ord(cadena[9]) == 0: #byte 10 (9)
			print " regModel, template creado correctamente"
			return 0
		else:
			err = ord(cadena[9])
			print "\n regModel Error creando template " + (hex(err))
			return err
	else:
		print "regModel - No se recibe respuesta del dispositivo"	
		return -1 
###  fin regModel()  ###


def upChar(address = 0xFFFFFFFF,buffer_id=0x2):  # dato extra = buffer id
	print "\n  --- upChar ---"

	sendInstruction(address,0x4,0x08,buffer_id) #(address,data_length,instruction_code,datos_extra)
	cadena = ser.read(12)        # read up to 12 bytes (timeout)
	length = len(cadena)
	if length == 12:
		for i in range(12):
			print(hex(ord(cadena[i]))), 
		if ord(cadena[9]) == 0: #byte 10 (9)
			print " \n upChar, listo para enviar paquetes:"

			cadena1 = ser.read(139)   # read up to 139 bytes (timeout) 
			if not len(cadena1) == 139:
				return -1
			cadena2 = ser.read(139)   # read up to 139 bytes (timeout)
			if not len(cadena1) == 139:
				return -1
			cadena3 = ser.read(139)   # read up to 139 bytes (timeout) 
			if not len(cadena1) == 139:
				return -1
			cadena4 = ser.read(139)   # read up to 139 bytes (timeout)
			if not len(cadena1) == 139:
				return -1
			return 0,cadena1,cadena2,cadena3,cadena4
	else:
		print "upChar - No se recibe respuesta del dispositivo"	
		return -1 

###  fin upChar()  ###


def downChar(address = 0xFFFFFFFF,buffer_id=2,cadena1="",cadena2="",cadena3="",cadena4=""): # 
	print "\n  --- downChar ---"
	sendInstruction(address,0x4,0x09,buffer_id) # (address,data_length,instruction_code,datos_extra)
	cadena = ser.read(12)        # read up to 139 bytes (timeout)
	length = len(cadena)
	if length == 12:
		for i in range(12):
			print(hex(ord(cadena[i]))), 
		print "\n Recibiendo ........\n "
		for i in range(139):
			ser.write(cadena1[i])  # header_highbits
		for i in range(139):
			ser.write(cadena2[i])  # header_highbits
		for i in range(139):
			ser.write(cadena3[i])  # header_highbits
		for i in range(139):
			ser.write(cadena4[i])  # header_highbits
		print "\n  "
	else: print " downChar error "
###  fin downChar()  ###

def store(address = 0xFFFFFFFF,buffer_id=2,page_id=0x0000):# datos extra = BufferID(1byte), PageID (2bytes H,L) 
	print "\n  --- store ---"	
	datos_extra = (buffer_id * 0x10000) + page_id
	sendInstruction(address,0x6,0x06,datos_extra) # (address,data_length,instruction_code,datos_extra)
	cadena = ser.read(12)        # read up to 12 bytes (timeout)
	length = len(cadena)
	if length == 12:
		for i in range(12):
			print(hex(ord(cadena[i]))),
		err = ord(cadena[9])
		return err
	else:
		print " store - No se recibe respuesta del dispositivo"	
		return -1
###  fin store()  ###

def loadChar(address = 0xFFFFFFFF,buffer_id=2,page_id=0x0000): # 
	print "\n  --- loadChar ---"
	datos_extra = (buffer_id * 0x10000) + page_id
	sendInstruction(address,0x6,0x07,datos_extra) # (address,data_length,instruction_code,datos_extra)
	cadena = ser.read(12)        # read up to 12 bytes (timeout)
	length = len(cadena)
	if length == 12:
		for i in range(12):
			print(hex(ord(cadena[i]))),
		err = ord(cadena[9])
		return err
	else:
		print " loadChar - No se recibe respuesta del dispositivo"	
		return -1
###  fin loadChar()  ###

def deletChar(address = 0xFFFFFFFF,page_id=0,cuantas="0"):#PageID(2bytes H,L),#templ to delete(2bytes H,L) 
	print "\n  --- deletChar ---"
	datos_extra = (page_id * 0x10000) + cuantas
	sendInstruction(address,0x7,0x0c,datos_extra) # (address,data_length,instruction_code,datos_extra)
	cadena = ser.read(12)        # read up to 12 bytes (timeout)
	length = len(cadena)
	if length == 12:
		for i in range(12):
			print(hex(ord(cadena[i]))),
		err = ord(cadena[9])
		return err
	else:
		print " deletChar - No se recibe respuesta del dispositivo"	
		return -1
""" Al borrar un Template se corren los valores mayores hacia abajo """
###  fin deletChar()  ###

def empty(address = 0xFFFFFFFF):
	print " \n --- empty --- "
	sendInstruction(address,0x3,0x0D) # (address,data_length,instruction_code,datos_extra)
	cadena = ser.read(12)        # read up to 12 bytes (timeout)
	length = len(cadena)
	if length == 12:
		for i in range(12):
			print(hex(ord(cadena[i]))),
		err = ord(cadena[9])
		return err
	else:
		print " empty - No se recibe respuesta del dispositivo"	
		return -1
###  fin empty()  ###

def match(address = 0xFFFFFFFF): # matching of templates from CharBuffer1 & CharBuffer2
	print " \n --- match --- "
	sendInstruction(address,0x3,0x03) # (address,data_length,instruction_code,datos_extra)
	cadena = ser.read(14)        # read up to 12 bytes (timeout)
	length = len(cadena)
	if length == 14:
		for i in range(14):
			print(hex(ord(cadena[i]))), 
		err = ord(cadena[9])
		score_h = ord(cadena[10])
		score_l = ord(cadena[11])
		score = (score_h * 256) + score_l
		return err,score
	else:
		print "\n match Error de comparacion " + (hex(ord(cadena[9])))
		return -1
###  fin match()  ###

def search(address = 0xFFFFFFFF,buffer_id=2,start_page=0,few_pages = 0x0): # datos extra= BufferID(1By),startPage(2bytes H,L),cuantasPgs(2bytes H,L) 
	print " \n --- search --- "
	datos_extra = (buffer_id * 0x100000000) + (start_page * 0x10000) + few_pages
	sendInstruction(address,0x8,0x04,datos_extra) # (address,data_length,instruction_code,datos_extra)
	cadena = ser.read(16)        # read up to 12 bytes (timeout)
	length = len(cadena)
	if length == 16:
		for i in range(16):
			print(hex(ord(cadena[i]))), 
		err = ord(cadena[9])
		pageId_h = ord(cadena[10])
		pageId_l = ord(cadena[11])
		pageId = (pageId_h * 256) + pageId_l
		score_h = ord(cadena[12])
		score_l = ord(cadena[13])
		score = (score_h * 256) + score_l
		return err,pageId,score
	else:
		print "search - No se recibe respuesta del dispositivo"	
		return -1
###  fin search()  ###

def SetPwd(address = 0xFFFFFFFF,pwd=0):  # pwd FF FF FF FF (0 a 4294967295)
	print " \n --- SetPwd --- "
	sendInstruction(address,0x7,0x12,pwd)
	cadena = ser.read(12)
	length = len(cadena)
	if length == 12:
		for i in range(12):
			print(hex(ord(cadena[i]))),
		err = ord(cadena[9])
		return err
	else:
		print " SetPwd - No se recibe respuesta del dispositivo"	
		return -1
###  fin SetPwd()  ###

def VfyPwd(address = 0xFFFFFFFF,pwd=0):  # pwd FF FF FF FF (0 a 4294967295)
	print " \n --- VfyPwd --- "
	sendInstruction(address,0x7,0x13,pwd) # (address,data_length,instruction_code,datos_extra)
	cadena = ser.read(12)        # read up to 12 bytes (timeout)
	length = len(cadena)
	if length == 12:
		for i in range(12):
			print(hex(ord(cadena[i]))),
		if ord(cadena[9]) ==0: print " PassWord correcto !"
		elif ord(cadena[9]) ==0x13: print " PassWord Incorrecto !"
		err = ord(cadena[9])
		return err
	else:
		print " VfyPwd - No se recibe respuesta del dispositivo"	
		return -1
###  fin VfyPwd()  ### 

############################## otros #######
def getRandomCode(address = 0xFFFFFFFF):
	print " \n --- getRandomCode --- "
	sendInstruction(address,0x3,0x14) # (address,data_length,instruction_code,datos_extra)
	cadena = ser.read(16)        # read up to 12 bytes (timeout)
	length = len(cadena)
	if length == 16:
		for i in range(16):
			print(hex(ord(cadena[i]))), 
		err = ord(cadena[9])
		random_h = ord(cadena[10])
		random_l = ord(cadena[11])
		random = (random_h * 256) + random_l
		return err,random
	else:
		print "getRandomCode - No se recibe respuesta del dispositivo"	
		return -1
###  fin getRandomCode()  ###

def readSysPara(address = 0xFFFFFFFF):
	print " \n readSysPara: "
	sendInstruction(address,0x3,0x0F,0x0) # (address,data_length,instruction_code,datos_extra)
	cadena = ser.read(28)        # read up to 14 bytes (timeout)
	length = len(cadena)
	if length == 28:
		for i in range(28):
			print(hex(ord(cadena[i]))),
		err = ord(cadena[9])
		sys_status_reg = (ord(cadena[10])*256) + ord(cadena[11])
		sys_ide_code = (ord(cadena[12])*256) + ord(cadena[13])
		library_size = (ord(cadena[14])*256) + ord(cadena[15])
		security_level = (ord(cadena[16])*256) + ord(cadena[17])
		device_address_H = (ord(cadena[18])*256) + ord(cadena[19])
		device_address_L = (ord(cadena[20])*256) + ord(cadena[21])
		packet_size = (ord(cadena[22])*256) + ord(cadena[23])
		baud_settings = (ord(cadena[24])*256) + ord(cadena[25])

		print "\n sys_status_reg: " + hex(sys_status_reg)
		print " sys_ide_code: " + hex(sys_ide_code)
		print " library_size: " + hex(library_size) +" = "+ str(library_size) +" pags."
		print " security_level: " + hex(security_level)
		print " device_address_H: " + hex(device_address_H)
		print " device_address_L: " + hex(device_address_L)
		print " packet_size: " + hex(packet_size), 
		print "   0=32, 1=64, 2=128, 3=256  bytes por paquete  pc <> zfm"
		print " baud_settings: " + hex(baud_settings) + " *9600 = "+str(baud_settings * 9600)+" bps."

		return err #,parametros
	else:
		print " readSysPara - No se recibe respuesta del dispositivo"	
		return -1
###  fin readSysPara()  ###

def templateNum(address = 0xFFFFFFFF):
	print " \n templateNum: "
	sendInstruction(address,0x3,0x1D) # (address,data_length,instruction_code,datos_extra)
	cadena = ser.read(14)        # read up to 14 bytes (timeout)
	length = len(cadena)
	if length == 14:
		for i in range(14):
			print(hex(ord(cadena[i]))),
		err = ord(cadena[9])
		template_h = ord(cadena[10])
		template_l = ord(cadena[11])
		template_num = (template_h * 256) + template_l
		return err,template_num
	else:
		print " templateNum No se recibe respuesta del dispositivo"	
		return -1
###  fin TemplateNum()  ###


#def writeNotepad(address = 0xFFFFFFFF): # page#(1byte),cadena de 32 bytes 
#	print " \n --- writeNotepad --- "
#	sendInstruction(address,0x24,0x18,0x0) # (address,data_length,instruction_code,datos_extra)
###  fin writeNotepad()  ###

#def readNotepad(address = 0xFFFFFFFF): # dato extra = page#(1byte)
#	print " \n --- readNotepad --- "
#	sendInstruction(address,0x4,0x19,0x0) # (address,data_length,instruction_code,datos_extra)
###  fin readNotepad()  ###

#def setAdder(address = 0xFFFFFFFF): # dato extra = new address(4bytes H L)
#	print " \n --- setAdder --- "
#	sendInstruction(address,0x7,0x15,0xFFFFFFFF) # (address,data_length,instruction_code,datos_extra)
###  fin setAdder()  ### 

#def setSysPara(address = 0xFFFFFFFF):  # datos extra = parm#4-5o6(1byte),contenido a colocar(1byte)
#	print " \n --- setSysPara --- "
#	sendInstruction(address,0x5,0x0E,0x0000) # (address,data_length,instruction_code,datos_extra)
###  fin setSysPara()  ### 


## ReadConList 0x1f ??? ##

##################################################################################################