class enlace(object):
""" This class implements methods to the interface between Enlace and Application
"""
def __init__(self, name):
""" Initializes the enlace class
"""
self.fisica = fisica(name)
self.rx = RX(self.fisica)
self.tx = TX(self.fisica)
self.connected = False
def enable(self):
""" Enable reception and transmission
"""
self.fisica.open()
self.rx.threadStart()
self.tx.threadStart()
def disable(self):
""" Disable reception and transmission
"""
self.rx.threadKill()
self.tx.threadKill()
time.sleep(1)
self.fisica.close()
################################
# Application interface #
################################
def sendData(self, data):
""" Send data over the enlace interface
"""
package = Package(data,"data").buildPackage()
self.tx.sendBuffer(package)
def sendACK(self):
package = Package(None,"ACK").buildPackage()
self.tx.sendBuffer(package)
def sendNACK(self):
package = Package(None,"NACK").buildPackage()
self.tx.sendBuffer(package)
def sendSync(self):
package = Package(None,"sync").buildPackage()
self.tx.sendBuffer(package)
def getData(self):
""" Get n data over the enlace interface
Return the byte array and the size of the buffer
"""
package = self.rx.getHeadPayload()
print(package)
data = undoPackage(package)
#print(data)
return(data[0], data[1],(len(data[0])),data[2])
def waitConnection(self):
while self.connected == False:
response = self.getData()
print("Waiting sync...")
if response[3] == "sync":
print("Sync received")
self.sendSync()
time.sleep(0.5)
self.sendACK()
print("ACK SENT")
response = self.getData()
if response[3] == "ACK":
print("Ready to receive package")
return True
else:
return False
def establishConnection(self):
timeout = False
print("Waiting sync...")
comeco = time.time()
while self.connected == False:
if timeout:
timeout=False
comeco = time.time()
print("--Waiting sync...")
if self.rx.getIsEmpty() == False:
self.sendSync()
response = self.getData()
if response[3] == "ACK" or "sync":
print("Sync received")
response = self.getData()
if response[3] == "sync" or "ACK":
print("ACK received")
time.sleep(0.5)
self.sendACK()
return True
else:
return False
else:
if ((time.time() - comeco) > 3):
print ("Passou 3 s")
self.sendSync()
timeout = True
class enlace(object):
""" This class implements methods to the interface between Enlace and Application
"""
def __init__(self, name):
""" Initializes the enlace class
"""
self.fisica = fisica(name)
self.rx = RX(self.fisica)
self.tx = TX(self.fisica)
self.connected = False
self.enviardata = False
self.corrupt = False
self.bufferdata = bytes(bytearray())
self.sizeselect = 2048
self.datasize = 0
self.sizepack = 0
self.numberpack = 0
self.numberpackrecive = 1
self.tamanhoenviado = 0
def enable(self):
""" Enable reception and transmission
"""
self.fisica.open()
self.rx.threadStart()
self.tx.threadStart()
def disable(self):
""" Disable reception and transmission
"""
self.rx.threadKill()
self.tx.threadKill()
time.sleep(1)
self.fisica.close()
def fragment(self):
self.numberpack += 1
if (len(self.bufferdata) >= self.sizeselect):
b = self.bufferdata[:self.sizeselect]
self.bufferdata = self.bufferdata[self.sizeselect:]
else:
b = self.bufferdata[:]
self.bufferdata = b""
self.tamanhoenviado = len(b)
return self.buildDataPacket(b)
def connect(self,data):
self.constructado()
self.bufferdata = data[:]
self.datasize = len(data)
""" Estabelece um conexão confiável com o Servidor - Máquina de Estados Client """
print("Client - Iniciando Handshake")
while(self.connected == False):
print("Enviando SYN...")
self.sendData(self.buildSynPacket())
print("SYN Enviado!")
print("Esperando pelo ACK + SYN do Servidor...")
time.sleep(0.5)
if(self.getCommandType() == "ACK"):
print("Ack recebido")
time.sleep(0.15)
while(self.connected == False):
if (self.getCommandType() == "SYN"):
print("SYN Recebido!")
print("Confirmando recebimento do SYN...")
self.sendData(self.buildAckPacket())
print("Conexão estabelecida!")
self.connected = True
elif(self.getCommandType() == "Erro"):
print("Erro na transmissão de dados. Reconectando...")
else:
print("Time out")
print("Reiniciando conexão")
time.sleep(0.2)
packtotal = (len(data) // self.sizeselect) + 1
while(len(self.bufferdata)!= 0):
pack = self.fragment()
while(self.enviardata == False):
print("Enviado: pacote ",self.numberpack,"/",packtotal," : ",self.tamanhoenviado, "Bytes")
self.sendData(pack)
if (self.getCommandType() == "ACK"):
self.enviardata = True
elif(self.getCommandType() == "nACK"):
self.enviardata = False
time.sleep(1)
self.enviardata = False
time.sleep(1)
print("Proximo Pacote")
def bind(self):
self.constructado()
""" Estabelece um conexão confiável com o Client - Máquina de Estados Servidor """
print("Servidor - Iniciando Handshake")
while(self.connected == False):
print("Aguardando um Comando do Client")
if(self.getCommandType() == "SYN"):
print("SYN Recebido!")
self.sendData(self.buildAckPacket())
print("ACK Enviado")
time.sleep(0.01)
self.sendData(self.buildSynPacket())
print("SYN Enviado")
time.sleep(0.01)
cont = 0
while(self.connected == False):
cont += 1
if(self.getCommandType() == "ACK"):
print("ACK Recebido!")
self.connected = True
print("Conexão estabelecida!")
time.sleep(0.15)
if(cont == 9):
break
elif(self.getCommandType() == "nACK"):
print("Conexão não estabelecida, erro!")
self.sendData(self.buildNackPacket())
elif(self.getCommandType() == "Erro"):
print("Erro na transmissão de dados.")
self.sendData(self.buildNackPacket())
else:
print("Timeout! O Client não respondeu no tempo hábil. Reiniciando Conexão.")
self.sendData(self.buildNackPacket())
time.sleep(1)
def constructado(self):
self.StructEop()
self.StructHead()
def sendData(self, pack):
self.tx.sendBuffer(pack)
def getData(self):
""" Get n data over the enlace interface
Return the byte array and the size of the buffer
"""
byterecebido = 0
bytetotal = 1
f = bytes(bytearray())
while(byterecebido != bytetotal):
head, data = self.rx.getPacket()
size = int(binascii.hexlify(head[2:4]), 16)
CRC_Head = self.getCRC(head[:8])
CRC_Data = self.getCRC(data)
packtotal = int(binascii.hexlify(head[4:6]), 16) // self.sizeselect
if(size != len(data) or (CRC_Head != head[8]) or (CRC_Data != head[9]) ):
print("Size: ",size,"/",len(data))
print("CRC_HEAD: ",CRC_Head,"/",head[8])
print("CRC_DATA: ",CRC_Data,"/",head[9])
print("nAck (Arquivo corrompido)")
self.sendData(self.buildNackPacket())
time.sleep(0.2)
else:
print("ACK Enviado")
self.sendData(self.buildAckPacket())
if(self.numberpackrecive == head[7]):
byterecebido += len(data)
bytetotal = int(binascii.hexlify(head[4:6]), 16)
print("Recebido: pacote", head[7],"/",packtotal ," : ",byterecebido,"/",bytetotal)
f += data
self.numberpackrecive += 1
time.sleep(0.1)
else:
print("nAck Enviado")
self.sendData(self.buildNackPacket())
return f
#---------------------------------------------#
#Define a estrutura do HEAD.
def StructHead(self):
self.headStart = 0xFF
self.headStruct = Struct("start" / Int16ub, #Como é 16, o Head começará com \x00\xff + size
"size" / Int16ub,
"totaldatasize" / Int16ub,
"typecommand" / Int8ub,
"number" /Int8ub,
"crc_head" / Int8ub,
"crc_payload" / Int8ub
)
#Implementa o head
def buildHead(self, dataLen, totalsize, command, packnumber, crc_head_value, crc_payload_value):
head = self.headStruct.build(dict(
start = self.headStart,
size = dataLen,
totaldatasize = totalsize,
typecommand = command,
number = packnumber,
crc_head = crc_head_value,
crc_payload = crc_payload_value))
return head
#---------------------------------------------#
#Define a estrutura do EOP.
def StructEop(self):
self.endStart = 0xFF
self.endStruct = Struct("c1" / Int8ub,
"c2" / Int8ub,
"c3" / Int8ub,
"c4" / Int8ub)
#Implementa o EOP.
def buildEop(self):
end = self.endStruct.build(dict(
c1 = 0x01,
c2 = 0x02,
c3 = 0x03,
c4 = 0x04))
return end
#---------------------------------------------#
#Cria o Pacote de Dados.
def buildDataPacket(self,data):
size = len(data)
head = self.buildHead(size,self.datasize,0,self.numberpack,0,0)
CRC_Head = self.getCRC(head[:8])
CRC_Data = self.getCRC(data)
head = self.buildHead(size,self.datasize,0,self.numberpack,CRC_Head,CRC_Data)
pack = head + data
pack += self.buildEop()
return pack
#---------------------------------------------#
#Cria o Pacote Comando Syn
def buildSynPacket(self):
SYN = 0x10
pack = self.buildHead(0,0,SYN,0,0,0)
pack += self.buildEop()
return pack
#Cria o Pacote Comando Ack
def buildAckPacket(self):
ACK = 0x11
pack = self.buildHead(0,0,ACK,0,0,0)
pack += self.buildEop()
return pack
#Cria o Pacote Comando nAck
def buildNackPacket(self):
NACK = 0x12
pack = self.buildHead(0,0,NACK,0,0,0)
pack += self.buildEop()
return pack
#---------------------------------------------#
#Classifica o pacote em Commandos ou Dado
def getPacketType(self):
head, _= self.rx.getPacket()
if head.endswith(b'\x00'):
return ("Dado")
elif head.endswith(b'\x10') or head.endswith(b'\x11') or head.endswith(b'\x12'):
return ("Comando")
else:
return ("Buffer vazio")
#Classifica o comando em Syn, Ack ou nAck
def getCommandType(self):
if (self.rx.getIsEmpty() == False):
head, _= self.rx.getPacket()
if (len(head) > 6):
if (head[6] == 16):
return ("SYN")
elif (head[6] == 17):
return ("ACK")
elif (head[6] == 18):
return ("nACK")
else:
return ("Erro")
else:
time.sleep(0.3)
return("Erro")
#Pega o size expresso no Head
def getSize(self,data):
size = int(binascii.hexlify(data[2:4]), 16)
return (size)
#---------------------------------------------#
#CALCULAR OVERHEAD
def CalcularOverhead(self, pack, data):
overhead = len(pack)/len(data)
print("Overhead:" , overhead)
return (overhead)
#---------------------------------------------#
#Calcula CRC
def getCRC(self, data):
crc8_func = crcmod.predefined.mkCrcFun('crc-8')
crc = crc8_func(data)
return(crc)
class enlace(object):
""" This class implements methods to the interface between Enlace and Application
"""
def __init__(self, name):
""" Initializes the enlace class
"""
self.fisica = fisica(name)
self.rx = RX(self.fisica)
self.tx = TX(self.fisica)
self.connected = False
def enable(self):
""" Enable reception and transmission
"""
self.fisica.open()
self.rx.threadStart()
self.tx.threadStart()
def disable(self):
""" Disable reception and transmission
"""
self.rx.threadKill()
self.tx.threadKill()
time.sleep(1)
self.fisica.close()
################################
# Application interface #
################################
def sendData(self, data):
""" Send data over the enlace interface
"""
print("ENVIANDO DATA")
data = Pacote(data, "data").empacota()
self.tx.sendBuffer(data)
print("***ENVIANDO DATA***")
def getData(self):
""" Get n data over the enlace interface
Return the byte array and the size of the buffer
"""
package = self.rx.getHeadPayload()
print(binascii.hexlify(package), "getData", "linha 57")
data = desempacota(package)
print("***RECEBENDO DATA***")
return (data[0], data[1], (len(data[0])), data[2])
def sendACK(self):
package = Pacote(None, "ACK").empacota()
print("***ENVIANDO ACK***")
self.tx.sendBuffer(package)
def sendNACK(self):
package = Pacote(None, "NACK").empacota()
print("***ENVIANDO NACK***")
self.tx.sendBuffer(package)
def sendSync(self):
package = Pacote(None, "sync").empacota()
self.tx.sendBuffer(package)
print("***ENVIANDO SYNC***")
def waitConnection(self):
print("Preparing to receive image")
while self.connected == False:
response = self.getData()
print("Waiting sync...")
if response[3] == "sync":
print("Sync received")
self.sendSync()
print("***ENVIOU SYNC***")
time.sleep(3)
self.sendACK()
time.sleep(3)
print("ACK SENT")
response = self.getData()
time.sleep(3)
print("Waiting ACK..")
if response[3] == "ACK" or "sync":
print("***RECEBEU ACK OU SYNC***")
print("Ready to receive package")
return True
else:
print("***NÃO RECEBEU SYNC INICIAL***")
return False
def establishConnection(self):
print("Preparing to send image")
timeout = False
print("Sending sync...")
comeco = time.time()
while self.connected == False:
if timeout:
timeout = False
comeco = time.time()
print("--Waiting sync...")
if self.rx.getIsEmpty() == False:
self.sendSync()
time.sleep(0.3)
print("***ENVIOU SYNC***")
response = self.getData()
if response[3] == "sync":
print("Sync received")
response = self.getData()
print("Waiting ACK..")
if response[3] == "ACK":
print("ACK received")
time.sleep(0.3)
self.sendACK()
print("***ENVIOU ACK***")
print("Connection established")
return True
else:
print("***NÃO RECEBEU SYNC INICIAL***")
return False
else:
if ((time.time() - comeco) > 5):
print("Passou 3 s")
self.sendSync()
print("***ENVIOU SYNC timeout***")
timeout = True
class enlace(object):
""" This class implements methods to the interface between Enlace and Application
"""
def __init__(self, name):
""" Initializes the enlace class
"""
self.fisica = fisica(name)
self.rx = RX(self.fisica)
self.tx = TX(self.fisica)
self.connected = False
self.enviardata = False
def enable(self):
""" Enable reception and transmission
"""
self.fisica.open()
self.rx.threadStart()
self.tx.threadStart()
def disable(self):
""" Disable reception and transmission
"""
self.rx.threadKill()
self.tx.threadKill()
time.sleep(1)
self.fisica.close()
def connect(self, data):
self.constructado()
""" Estabelece um conexão confiável com o Servidor - Máquina de Estados Client """
print("Client - Iniciando Handshake")
while (self.connected == False):
print("Enviando SYN...")
self.sendData(self.buildSynPacket())
print("SYN Enviado!")
print("Esperando pelo ACK + SYN do Servidor...")
time.sleep(0.15)
if (self.getCommandType() == "ACK"):
time.sleep(0.15)
if (self.getCommandType() == "SYN"):
print("SYN + ACK Recebido!")
print("Confirmando recebimento do SYN...")
self.sendData(self.buildAckPacket())
print("Conexão estabelecida!")
self.connected = True
elif (self.getCommandType() == "Erro"):
print("Erro na transmissão de dados. Reconectando...")
else:
print("Time out")
print("Reiniciando conexão")
time.sleep(0.15)
pack = self.buildDataPacket(data)
while (self.enviardata == False):
self.sendData(pack)
time.sleep(0.2)
if (self.getCommandType() == "ACK"):
self.enviardata = True
elif (self.getCommandType() == "nACK"):
self.enviardata = False
def bind(self):
self.constructado()
""" Estabelece um conexão confiável com o Client - Máquina de Estados Servidor """
print("Servidor - Iniciando Handshake")
while (self.connected == False):
print("Aguardando um Comando do Client")
if (self.getCommandType() == "SYN"):
print("SYN Recebido!")
self.sendData(self.buildAckPacket())
print("ACK Enviado")
time.sleep(0.1)
self.sendData(self.buildSynPacket())
print("SYN Enviado")
if (self.getCommandType() == "ACK"):
print("ACK Recebido!")
self.connected = True
print("Conexão estabelecida!")
time.sleep(0.4)
elif (self.getCommandType() == "nACK"):
print("Conexão não estabelecida, erro!")
self.sendData(self.buildNackPacket())
elif (self.getCommandType() == "Erro"):
print("Erro na transmissão de dados.")
self.sendData(self.buildNackPacket())
else:
print(
"Timeout! O Client não respondeu no tempo hábil. Reiniciando Conexão."
)
self.sendData(self.buildNackPacket())
time.sleep(0.15)
def constructado(self):
self.StructEop()
self.StructHead()
def sendData(self, pack):
self.tx.sendBuffer(pack)
def getData(self):
""" Get n data over the enlace interface
Return the byte array and the size of the buffer
"""
_, data = self.rx.getPacket()
size = len(data)
while (size != len(data)):
print("nack enviado")
self.sendData(self.buildNackPacket())
time.sleep(0.2)
print("ack enviado")
self.sendData(self.buildAckPacket())
return (data)
#---------------------------------------------#
#Define a estrutura do HEAD.
def StructHead(self):
self.headStart = 0xFF
self.headStruct = Struct(
"start" /
Int16ub, #Como é 16, o Head começará com \x00\xff + size
"size" / Int16ub,
"typecommand" / Int8ub)
#Implementa o head
def buildHead(self, dataLen, command):
head = self.headStruct.build(
dict(start=self.headStart, size=dataLen, typecommand=command))
return head
#---------------------------------------------#
#Define a estrutura do EOP.
def StructEop(self):
self.endStart = 0xFF
self.endStruct = Struct("c1" / Int8ub, "c2" / Int8ub, "c3" / Int8ub,
"c4" / Int8ub)
#Implementa o EOP.
def buildEop(self):
end = self.endStruct.build(dict(c1=0x01, c2=0x02, c3=0x03, c4=0x04))
return end
#---------------------------------------------#
#Cria o Pacote de Dados.
def buildDataPacket(self, data):
pack = self.buildHead(len(data), 0x00)
pack += data
pack += self.buildEop()
print(len(data))
return pack
#---------------------------------------------#
#Cria o Pacote Comando Syn
def buildSynPacket(self):
SYN = 0x10
pack = self.buildHead(0, SYN)
pack += self.buildEop()
return pack
#Cria o Pacote Comando Ack
def buildAckPacket(self):
ACK = 0x11
pack = self.buildHead(0, ACK)
pack += self.buildEop()
return pack
#Cria o Pacote Comando nAck
def buildNackPacket(self):
NACK = 0x12
pack = self.buildHead(0, NACK)
pack += self.buildEop()
return pack
#---------------------------------------------#
#Classifica o pacote em Commandos ou Dado
def getPacketType(self):
head, _ = self.rx.getPacket()
if head.endswith(b'\x00'):
return ("Dado")
elif head.endswith(b'\x10') or head.endswith(b'\x11') or head.endswith(
b'\x12'):
return ("Comando")
else:
return ("Buffer vazio")
#Classifica o comando em Syn, Ack ou nAck
def getCommandType(self):
if (self.rx.getIsEmpty() == False):
head, _ = self.rx.getPacket()
if head.endswith(b'\x10'):
return ("SYN")
elif head.endswith(b'\x11'):
return ("ACK")
elif head.endswith(b'\x12'):
return ("nACK")
else:
return ("Erro")
else:
time.sleep(0.5)
return ("Erro")
#Pega o size expresso no Head
def getSize(self):
head, _ = self.rx.getPacket()
size = int(binascii.hexlify(head[2:4]), 16)
return (size)
#---------------------------------------------#
#CALCULAR OVERHEAD
def CalcularOverhead(self, pack, data):
overhead = len(pack) / len(data)
print("Overhead:", overhead)
return (overhead)
