class enlace(object):
""" This class implements methods to the interface between Enlace and Application
"""
max_pkt = 2048
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
construtor = packet.packet()
nada = bytearray([])
self.SYN = construtor.buildPacket(0, nada, 0, 0, 0, 0, 0)
self.ACK = construtor.buildPacket(0, nada, 1, 0, 0, 0, 0)
self.nACK = construtor.buildPacket(0, nada, 2, 0, 0, 0, 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()
################################
# Application interface #
################################
def Handshake(self):#client
print("Estabelecendo conexao...")
timeout=2.0
while self.connected == False:
time.sleep(0.1)
self.sendCmd(0)
tempacote= self.getData(timeout)[2]
if tempacote == 4:
print("Nao recebi o Syn ainda")
if tempacote == 0:
print("Recebi o Syn!")
tempacote= self.getData(timeout)[2]
#print(tempacote)
if tempacote == 4:
print("Recebi o Syn e ainda não recebi o Ack")
time.sleep(0.1)
self.sendCmd(2) #manda o nAck enquanto o Ack nao chega
if tempacote == 1:
print("Recebi o Ack")
self.sendCmd(1)
print("Mandei o ultimo Ack")
self.connected = True
print("Conectado com sucesso!")
def waitingHandshake(self): #SERVER
timeout= 2.0
while True:
print("Esperando o Syn...")
while(self.getData(timeout)[2] != 0):
print("...")
continue
print("Recebi o Syn")
time.sleep(0.1)
self.sendCmd(0)
print("enviei o Syn")
time.sleep(0.1)
self.sendCmd(1)
print("enviei o Ack")
time.sleep(0.1)
print("Aguardando o Ack")
tempacote= self.getData(timeout)[2]
print("tempacote: "+str(tempacote))
if tempacote == 4:
print("Não recebi nada (timeout)")
if tempacote == 2:
print("Recebi nAck")
if tempacote == 1:
print("Recebi o ultimo Ack")
print("Handshake ENCERRADO")
break
print("----")
def sendData(self, data):
""" Send data over the enlace interface
"""
construtor = packet.packet()
max_pkt = self.max_pkt
qtdpartes = math.ceil(len(data)/max_pkt)
atual = 1
x = 0
y = max_pkt
while atual <= qtdpartes:
data_cortada = data[x:y]
pacote = construtor.buildPacket(len(data_cortada), data_cortada, 3, atual, qtdpartes, 0, 0) #constroi pacote falso
crc_head = self.CRC(pacote[0:5]) #calcula crc pro pacote falso
crc_payload = self.CRC(data_cortada)
pacote_final = construtor.buildPacket(len(data_cortada), data_cortada, 3, atual, qtdpartes, crc_head, crc_payload)
time.sleep(0.05)
self.tx.sendBuffer(pacote_final) #envia pacote verdadeiro
tmp= self.getData(0.5)
if tmp[2] == 1: #10 é valor do timeout
print("Recebi o Ack, vou enviar o proximo pacote")
atual += 1
x += max_pkt
y += max_pkt
print("Checagem pacote: "+str(len(pacote_final)))
if tmp[2] == 2:
print("Recebi um nAck, vou reenviar o ultimo pacote")
def sendCmd(self, tipo):
if tipo == 0:
self.tx.sendBuffer(self.SYN)
if tipo == 1:
self.tx.sendBuffer(self.ACK)
if tipo == 2:
self.tx.sendBuffer(self.nACK)
#
def getData(self, timeout):
""" Get n data over the enlace interface
Return the byte array and the size of the buffer
"""
print("Chamei o Get Data")
payload = bytearray([])
while True:
pacote = self.rx.getPacket(timeout)
construtor = packet.packet()
data, tipo, atual, total, crc_head, crc_payload = construtor.unpack(pacote)
if data != None:
print("Atual: ", atual)
print("Total: ", total)
crc_payload_2 = self.CRC(data)
crc_head_2 = self.CRC(pacote[0:5])
if crc_payload_2 == crc_payload and crc_head_2 == crc_head:
#comparação de crcs, se der certo, envia Ack
payload += data
time.sleep(0.05)
self.sendCmd(1)
print("Recebi o pacote, mandando o Ack")
else:
time.sleep(0.1)
self.sendCmd(2)
print("Recebi o pacote corrompido, mandando nAck")
last= atual
ptotal=total
while atual < ptotal:
pacote = self.rx.getPacket(timeout)
data, tipo, atual, total, crc_head, crc_payload = construtor.unpack(pacote)
print("Recebi um pacote tipo: ", tipo)
if (tipo!=3):
continue
print("Atual: ", atual)
print("Total: ", total)
crc_payload_2 = self.CRC(data)
crc_head_2 = self.CRC(pacote[0:5])
if crc_payload_2 == crc_payload and crc_head_2 == crc_head and atual==(last+1):
#comparação de crcs, se der certo, envia Ack
last=atual
payload += data
time.sleep(0.1)
self.sendCmd(1)
print("Recebi o pacote, mandando o Ack")
elif(last==atual):
print("Recebi um pacote repetido")
else:
time.sleep(0.05)
self.sendCmd(2)
print("Last: ", last)
print("Atual: ", atual)
print("Recebi o pacote corrompido, mandando nAck")
return(payload, len(payload), 3)
else:
return(None, 0, tipo)
def CRC(self,data):
crc8 = crcmod.predefined.mkCrcFun("crc-8")
CRC = (crc8(data))
return CRC
class enlace(object):
""" This class implements methods to the interface between Enlace and Application
"""
def __init__(self, app):
""" Initializes the enlace class
"""
self.app = app
self.fisica = fisica(app.serialName)
self.rx = RX(self.fisica)
self.tx = TX(self.fisica)
self.connected = False
self.ph = PacketHandler()
self.label = '[ENLACE]'
self.idle = True
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, client):
""" Bloqueia a execução do programa até que uma conexão confiável
com o servidor seja estabelecida """
print(self.label, "Iniciando Handshake como Cliente")
while client.handshake == False:
if client.state == 'INICIAL':
client.setState('ENVIANDO_SYN')
elif client.state == 'ENVIANDO_SYN':
self.sendSyn()
client.setState('AGUARDANDO_SYN')
elif client.state == 'AGUARDANDO_SYN':
data = self.getData()
if data != False:
p = self.ph.unpack(data)
if p['type'] == 'SYN':
client.setState('AGUARDANDO_ACK')
else:
client.setState('ENVIANDO_SYN')
else:
client.setState('ENVIANDO_SYN')
elif client.state == 'AGUARDANDO_ACK':
data = self.getData()
if data != False:
p = self.ph.unpack(data)
if p['type'] == 'ACK':
client.setState('ENVIANDO_ACK')
self.sendAck()
print(self.label, '\n ~~~ HANDSHAKE EFETUADO ~~~ \n')
client.setState('CONECTADO')
client.handshake = True
else:
client.setState('INICIAL')
def bind(self, server):
""" Bloqueia a execução do programa até que uma conexão confiável
com o cliente seja estabelecida """
print(self.label, "Iniciando Handshake como Servidor")
while server.handshake == False:
if server.state == 'INICIAL':
server.setState('AGUARDANDO_SYN')
elif server.state == 'AGUARDANDO_SYN':
print(self.label, 'Aguardando pedidos SYN...')
data = self.getData()
if data:
p = self.ph.unpack(data)
if p['type'] == 'SYN':
server.setState('ENVIANDO_SYN')
elif server.state == 'ENVIANDO_SYN':
self.sendSyn()
time.sleep(0.05)
server.setState('ENVIANDO_ACK')
elif server.state == 'ENVIANDO_ACK':
self.sendAck()
time.sleep(0.05)
server.setState('AGUARDANDO_ACK')
elif server.state == 'AGUARDANDO_ACK':
data = self.getData()
if data:
p = self.ph.unpack(data)
if p['type'] == 'ACK':
print(self.label, '\n ~~~ HANDSHAKE EFETUADO ~~~ \n')
server.setState('CONECTADO')
server.handshake = True
def startServerStateMachine(self, server):
"""Máquina de Estados para envio de ACK e NACK ao receber payloads"""
currentSize = 0
while server.stateMachineRunning:
# Checa se o handshake já foi efetuado, caso contrário, o faz
if server.handshake == False:
server.setState('INICIAL')
server.app.com.bind(server)
elif server.state == 'CONECTADO':
time.sleep(0.05)
server.setState('AGUARDANDO_PACOTE')
elif server.state == 'AGUARDANDO_PACOTE':
file = self.getData()
if file != False:
self.idle = False
p = server.ph.unpack(file)
headchecksum = server.ph.generateHeadChecksum(p['head'])
payloadchecksum = server.ph.generatePayloadChecksum(
p['payload'])
# print('HOLYYYYYYYYY', p['headchecksum'],'\n',headchecksum)
if (p['headchecksum']
== headchecksum) and (p['payloadchecksum']
== payloadchecksum):
index = p['index']
currentSize += p['slicesize']
print(
'[ServerStateMachine] Recebido pacote {}/{} com {} bytes | Recebido : {}/{} bytes'
.format(index[0], index[1], p['slicesize'],
currentSize, p['size']))
server.setState('ENVIANDO_ACK')
if index[0] == index[1] and currentSize == p['size']:
self.sendAck()
currentSize = 0
print(
'[ServerStateMachine] Arquivo recebido com sucesso! '
)
server.ph.writeFile()
self.idle = True
server.setState('CONECTADO')
else:
server.setState('ENVIANDO_NACK')
else:
server.setState('ENVIANDO_NACK')
elif server.state == 'ENVIANDO_ACK':
self.sendAck()
server.setState('AGUARDANDO_PACOTE')
elif server.state == 'ENVIANDO_NACK':
self.sendNack()
server.setState('AGUARDANDO_PACOTE')
def startClientStateMachine(self, client):
"""Máquina de Estados para envio e recepcao de ACKS e NACKS ao enviar
payloads"""
packets = client.filePackets
currentPacket = 0
while client.stateMachineRunning:
# Checa se o handshake já foi efetuado, caso contrário, o faz
if client.handshake == False:
client.setState('INICIAL')
client.app.com.connect(client)
elif client.state == 'CONECTADO':
time.sleep(0.05)
client.setState('ENVIANDO_PACOTE')
elif client.state == 'ENVIANDO_PACOTE':
print(
'[ClientStateMachine] Enviando pacote {}/{} com {} bytes'.
format(currentPacket + 1, len(packets),
packets[currentPacket]['packetSize']))
self.sendData(packets[currentPacket]['packet'])
client.setState('AGUARDANDO_ACK')
elif client.state == 'AGUARDANDO_ACK':
data = client.app.com.getData()
if data != False:
p = client.app.ph.unpack(data)
if p['type'] == 'ACK':
print('[ClientStateMachine] -> Pacote {}/{} -> ACK'.
format(currentPacket + 1, len(packets)))
currentPacket += 1
if currentPacket == len(packets):
client.setState('ENCERRANDO_COMUNICACAO')
else:
client.setState('ENVIANDO_PACOTE')
elif p['type'] == 'NACK':
print(
'[ClientStateMachine] -> Pacote {}/{} -> NACK !!!'.
format(currentPacket + 1, len(packets)))
client.setState('ENVIANDO_PACOTE')
else:
print(
'[ClientStateMachine] -> Pacote {}/{} -> TIMEOUT !!!'.
format(currentPacket + 1, len(packets)))
client.setState('ENVIANDO_PACOTE')
elif client.state == 'ENCERRANDO_COMUNICACAO':
print('[Client] Sucesso no envio, encerrando comunicação')
print('Fim de Transmissão. Arquivo enviado com sucesso!')
client.setState('CONECTADO')
currentPacket = 0
client.stateMachineRunning = False
def sendSyn(self):
p = self.ph.buildCommandPacket("SYN")
self.sendData(p)
def sendAck(self):
p = self.ph.buildCommandPacket("ACK")
self.sendData(p)
def sendNack(self):
p = self.ph.buildCommandPacket("NACK")
if self.app.role == 'server' and self.idle == False:
self.sendData(p)
################################
# Application interface #
################################
def sendData(self, data):
""" Send data over the enlace interface
"""
self.tx.sendBuffer(data)
def getData(self):
""" Get n data over the enlace interface
"""
packet = self.rx.getPacket()
# print('--> DATA RECEIVED : ', packet)
if packet != False:
p = PacketHandler().unpack(packet)
# if p['type'] == 'PAYLOAD' and p['slicesize'] != len(p['payload']):
# print(self.label,'Pacote corrompido, enviando NACK')
# self.sendNack()
# return False
return packet
else:
return False
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
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)
