class enlace(object):
def __init__(self, name):
self.fisica = fisica(
name) # é o serialName - nome da porta do computador
self.rx = RX(self.fisica) #inicializa o RX
self.tx = TX(self.fisica) #inicializa o TX
self.connected = False
def enable(self):
self.fisica.open()
self.rx.threadStart()
self.tx.threadStart()
def disable(self):
self.rx.threadKill()
self.tx.threadKill()
time.sleep(1)
self.fisica.close()
# Método que recebe os dados em bytes (array) e envia os dados
#usa a funcao sendBuffer do tx(pino de envio)
def sendData(self, data):
self.tx.sendBuffer(data)
#Método que recebe o tamanho dos dados e retorna os dados e o len dos dados
def getData(self, size):
data = self.rx.getNData(size)
return (data, len(data))
#Método que recebe o tamanho dos dados e retorna os dados e o len dos dados apos um determinado tempo
def getDataTime(self, size, t):
while self.rx.getBufferLen() < size:
if t <= 0:
return False
mins, secs = divmod(t, 60) #calcula o n de min e seg
timer = '{:02d}:{:02d}'.format(int(mins), int(secs))
print(timer, end="\r") #print q sobrepoe o anterior
time.sleep(0.05) #conta 0.05 seg
t -= 0.05
return self.rx.getBuffer(size)
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.queuedPck = []
self.receivedPck = []
self.meta = None
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 listenPacket(self, timeout, size): #valor -1111 desativa o timeout
label = 85
packet = None
dic = {
'small': 17,
'medium':
544, #signature + label + thresh + pckAmount + filenameSize + content + checksum + signature : +8 +1 +2 +3 +2 +512 +8 +8
'big': 14 + 2**10 + 16
} #header + payload + eop
size = dic[size]
while timeout > 0 or timeout == -1111:
if (timeout != -1111):
timeout -= 100
time.sleep(0.1)
if (self.rx.getBufferLen() >= size):
packet = self.rx.getBuffer(size)
label = packet[8]
break
if (packet != None and
(packet[0:8] != 'F.A.S.T.'.encode() or packet[-8:] !=
'S.L.O.W.'.encode())): #confere as assinaturas de header e eop
label = 170
if ((label == 0 or label == 131)
and self.checksum(packet[0:-16]) != packet[-16:-8]
): #confere o checksum de header+payload contra o checksum no eop
label = 151
if (label == 0
and self.getPayloadCounter(packet) != len(self.receivedPck)):
print(self.getPayloadCounter(packet))
label = 222
dic = {
255: 'SYN',
240: 'ACK',
222: 'MISCOUNT',
170: 'MALFORMED',
151: 'CORRUPTED',
131: 'META',
85: 'TIMEOUT',
15: 'NACK',
0: 'DATA'
}
label = dic[label]
print("Resultado do packet ouvido: " + label)
self.rx.clearBufferUntilSignature('F.A.S.T.'.encode())
return (label, packet)
def getMetaName(self, packet):
trailingfilename = packet[16:16 + 512]
filenamelength = int.from_bytes(packet[14:16], byteorder='big')
filename = trailingfilename[0:filenamelength]
return filename.decode(
'utf-8'
) #torcemos para que não tenhamos que nos preocupar algo que não utf-8
def getMetaPacketAmount(self, packet):
return int.from_bytes(packet[11:14], byteorder='big')
def getMetaThreshold(self, packet):
return int.from_bytes(packet[9:11], byteorder='big')
def getPayloadCounter(self, packet):
return int.from_bytes(packet[11:14], byteorder='little')
def collapseData(self):
data = bytes(bytearray())
i = 0
while (i != len(self.receivedPck)):
data += self.receivedPck[i][13:-16]
print('azul ', self.getPayloadCounter(self.receivedPck[i]))
i += 1
self.receivedPck = []
cut = (2**10 - self.getMetaThreshold(self.meta)) % (2**10)
return data[:-cut]
def sendPacket(self, label, number=0):
time.sleep(
0.2
) #pra dar tempo do outro se preparar pra receber, testar diminuir ou remover este valor depois
print("Enviando packet tipo ", label)
dic = {
'SYN': bytes([255]),
'ACK': bytes([240]),
'NACK': bytes([15]),
'META': bytes([131]),
'DATA': bytes([0])
}
label = dic[label]
if (label == bytes([255]) or label == bytes([240])
or label == bytes([15])):
signature = 'F.A.S.T.'.encode()
header = signature + label
signature = 'S.L.O.W.'.encode()
eop = signature
packet = header + eop
elif (label == bytes([131])):
packet = self.meta
elif (label == bytes([0])):
packet = self.queuedPck[number]
self.tx.sendBuffer(packet)
def packageData(self, data, filename):
self.queuedPck = []
#bytes do payload de cada packet: 2**10
payloadsize = 2**10
packetamount = ((len(data) - 1) // payloadsize) + 1
#TODO: editar o metadata para suportar mais packets por comunicação
##Fazer metadata
#Para suportar o maior número possível de filesystems, suportaremos filenames de até 512 bytes
#tamanho máximo de um arquivo transferido por uma sprint apenas, 4Gb = 2^32, 4 bytes
signature = 'F.A.S.T.'.encode()
label = bytes([131])
thresh = len(data) % payloadsize
thresh = bytes([((thresh // 256) % 256), (thresh % 256)])
content = filename.encode()
filenameSize = bytes([(((len(content) // 256) % 256)),
(len(content) % 256)])
pckAmount = bytes([((packetamount // (256**2)) % 256),
((packetamount // 256) % 256),
(packetamount % 256)])
header = signature + label + thresh + pckAmount + filenameSize
content = content + bytes([0]) * (512 - len(content))
signature = 'S.L.O.W.'.encode()
eop = self.checksum(header + content) + signature
self.meta = (header + content + eop)
#Fazer o packaging
data += (((2**10) - (len(data) % 2**10)) % 2**10) * bytes([0]) #oh god
counter = 0
while (counter != packetamount):
thisdata = data[counter * (2**10):(counter + 1) * (2**10)]
self.queuedPck.append(self.createPacket(thisdata, counter))
counter += 1
def createPacket(self, payload, counter):
signature = 'F.A.S.T.'.encode()
label = bytes([0])
#size= 2**10 #size do payload, constante para packets com payload
size = bytes([0, 0]) #TODO: consertar
counter = bytes([((counter // (256**2)) % 256),
((counter // 256) % 256), (counter % 256)])
header = signature + label + counter + size
#14 bytes
signature = 'S.L.O.W.'.encode()
eop = self.checksum(header + payload) + signature
#16 bytes
return header + payload + eop
def checksum(self, data):
#Implementação nossa de um CRC-64 bits
data = int.from_bytes(data, 'big')
data = data * (2**64) #append com zeros
while (data.bit_length() > 64):
sumNum = 2**(data.bit_length() - 65)
key = 18601846741563846107 #um int aleatoriamente selecionado de 65 bits
powerkey = key * sumNum
data ^= powerkey
return bytes([(data // (256**7)) % 256, (data // (256**6)) % 256,
(data // (256**5)) % 256, (data // (256**4)) % 256,
(data // (256**3)) % 256, (data // (256**2)) % 256,
(data // 256) % 256, data % 256])
class enlace(object):
""" This class implements methods to the interface between Enlace and Application
"""
headSTART = 0xFF # 255 #super clever head start
headStruct = Struct("start" / Int8ub, "size" / Int16ub, "SYN" / Int8ub,
"ACK_NACK" / Int8ub, "P_size" / Int8ub,
"P_total" / Int8ub, "CheckSum" / Int16ub,
"CheckSum_head" / Int16ub)
ackCode = 0x9d # 157
nackCode = 0x0e # 14
synCode = 0x01 # 1
fakeAck = 0x00
fakeSyn = 0x00
maximum_Package = 2048 # determina o tamanho maximo que um pacote pode ter (*8 pois precisa ser em bits)
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.end = "s.t.o.p.".encode()
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 buildHead(self, dataLen):
head = self.headStruct.build(
dict(start=self.headSTART,
size=dataLen,
SYN=self.fakeSyn,
ACK_NACK=self.fakeAck,
P_size=0,
P_total=0,
CheckSum=0,
CheckSum_head=0))
return (head)
def buildSync(self, dataLen=0):
head = self.headStruct.build(
dict(start=self.headSTART,
size=dataLen,
SYN=self.synCode,
ACK_NACK=self.fakeAck,
P_size=0,
P_total=0,
CheckSum=0,
CheckSum_head=0))
return (head)
def buildACK_NACK(self, dataLen=0, deuCerto=False):
if deuCerto == True:
head = self.headStruct.build(
dict(start=self.headSTART,
size=dataLen,
SYN=self.synCode,
ACK_NACK=self.ackCode,
P_size=0,
P_total=0,
CheckSum=0,
CheckSum_head=0))
if deuCerto == False:
head = self.headStruct.build(
dict(start=self.headSTART,
size=dataLen,
SYN=self.synCode,
ACK_NACK=self.nackCode,
P_size=0,
P_total=0,
CheckSum=0,
CheckSum_head=0))
return (head)
def build_complete(self, dataLen, deuCerto, payload_len, total_payload_len,
CheckSum_payload, CheckSum_head):
head = self.headStruct.build(
dict(start=self.headSTART,
size=dataLen,
SYN=self.synCode,
ACK_NACK=self.ackCode,
P_size=payload_len,
P_total=total_payload_len,
CheckSum=CheckSum_payload,
CheckSum_head=CheckSum_head))
return (head)
def getheadStart(self, file):
head = file[0:11]
container = self.headStruct.parse(head)
return container["start"]
def getSize(self, file):
head = file[0:11]
container = self.headStruct.parse(head)
return container["size"]
def getSYN(self, file):
head = file[0:11]
container = self.headStruct.parse(head)
return container["SYN"]
def getACK_NACK(self, file):
head = file[0:11]
container = self.headStruct.parse(head)
return container["ACK_NACK"]
def getP_size_total(self, file):
head = file[0:11]
container = self.headStruct.parse(head)
return (container["P_size"], container["P_total"])
def CRC(self, data):
# usando crc-16-IBM aka CRC-16
crc16 = crcmod.predefined.mkCrcFun("crc-16")
CRC = (crc16(data))
#'print("CRC: ",CRC)
return CRC
def get_CRC(self, file):
head = file[0:11]
container = self.headStruct.parse(head)
return (container["CheckSum"], container["CheckSum_head"])
def compare_CRC(
self, file
): # função que retorna True Se o CRChead e CRCpayload estiverem certos
crc16 = crcmod.predefined.mkCrcFun("crc-16")
CheckSum, CheckSum_head = self.get_CRC(file)
half_head = file[0:7] # parte do head sem CRC
data, useless_trash = self.openPackage(file)
if CheckSum == crc16(data) and CheckSum_head == crc16(half_head):
return True
else:
return False
def Compare_number_package(
self, file): # compara se todos os pacotes foram recebidos
P_size, P_total = self.getP_size_total(file)
print("Compare debug: ", P_size, " ", P_total)
if P_size == P_total:
return True
else:
return False
def DataSender(self, data):
n = self.maximum_Package # tamanho maximo do pacote, so mudei de nome
quantidade_partes = math.ceil(
len(data) / n
) # acha a quantidade minima de partes que o pacote de ser dividido
timeinit = time.time()
print("Quantidade de partes necessarias : ", quantidade_partes)
print("")
print("Início do envio")
print("")
print("-------------------------")
beginning = 0
end = n
Parte_atual = 1
while Parte_atual <= quantidade_partes: # roda a quantidade de vezes minima
#print(a[beginning:end])
payload = data[beginning:end]
temp_head = self.build_complete(len(payload), True, Parte_atual,
quantidade_partes, 0, 0)
head_crc = self.CRC(temp_head[0:7]) # a parte do head sem o CRC
payload_crc = self.CRC(payload)
head = self.build_complete(len(payload), True, Parte_atual,
quantidade_partes, payload_crc,
head_crc)
file = (head + payload + self.end)
print("- Parte", Parte_atual, "de", quantidade_partes)
self.tx.sendBuffer(file)
timeout = time.time()
while time.time() - timeout <= 1.5:
ack_esperado = self.rx.getNData()
if self.getheadStart(ack_esperado) == 255:
if self.getACK_NACK(ack_esperado) == 157:
print(" - Recebeu ACK")
print("")
beginning += n
end += n
Parte_atual += 1
break
elif self.getACK_NACK(ack_esperado) == 14:
print(" - Recebeu NACK")
print(" - Reenviando pacote")
print("")
break
if time.time() - timeout >= 3.0:
print(" - TimeOut")
print(" - Reenviando pacote")
print("")
time.sleep(0.05)
timefim = time.time()
print("")
print("Tempo da transmissão:", timefim - timeinit, "segundos")
def handshake_server(self):
while True:
if self.rx.getBufferLen() > 4:
time_start_getData = time.time()
data = self.rx.getNData() # receive syn
if self.getSYN(data) == 1:
print("Syn recebido, send ack + syn")
time.sleep(0.1)
ack_nack = self.buildACK_NACK(deuCerto=True)
self.tx.sendBuffer(ack_nack + self.end) #ack + syn
print(self.getACK_NACK(ack_nack))
self.rx.clearBuffer()
data = self.rx.getNData() #receive ack
if self.getACK_NACK(data) == 157:
print("handshake completo")
break
################################
# Application interface #
################################
def sendData(self, txLen, data):
""" Send data over the enlace interface
"""
sync = (self.buildSync() + self.end)
head = self.buildHead(txLen)
time_inicio = time.time()
while True:
time.sleep(1)
self.tx.sendBuffer(sync)
self.rx.clearBuffer()
print("Mandei o Sync :3")
time_now = time.time()
if (time_now - time_inicio) < 30.0:
ack_syn = self.rx.getNData()
if self.getheadStart(ack_syn) == 255:
if self.getACK_NACK(ack_syn) == 157 and self.getSYN(
ack_syn) == 1:
print("Mandei o ACK :3")
time.sleep(1)
self.tx.sendBuffer(
self.buildACK_NACK(deuCerto=True) + self.end)
break
elif (time_now - time_inicio) > 30.0:
sys.exit()
time.sleep(1)
self.DataSender(data)
def getData(self):
""" Get n data over the enlace interface
Return the byte array and the size of the buffer
"""
self.handshake_server()
self.rx.clearBuffer()
Complete_package = b""
Current_P_size = 1
while True: #pega um pacote
data = self.rx.getNData()
self.rx.clearBuffer()
print(data)
if self.getheadStart(data) == 255: # se achar o head do pacote
payload, trash = self.openPackage(data)
P_size, P_total = self.getP_size_total(data)
print("P_size,Current_P_size : ", P_size, " ", Current_P_size)
if self.compare_CRC(data):
print("Payload : ", type(payload))
Complete_package += payload
head = self.buildACK_NACK(deuCerto=True)
print("mandei ack", head)
self.tx.sendBuffer(head + self.end)
Current_P_size += 1
if self.compare_CRC(data) == False:
head = self.buildACK_NACK(deuCerto=False)
print("A casa caiu, arquivo corrompido, mandado nack")
self.tx.sendBuffer(head + self.end)
if P_size == P_total:
break
#print("Meu debug: "+str(Complete_package))
data, head = self.openPackage(data)
"""
while True: # checa se os sizes batem
if self.getSize(head) != len(data) :
print("dataLen:",dataLen,"head size",self.getSize(head))
self.tx.sendBuffer(self.buildACK_NACK(deuCerto = False) + self.end)
time.sleep(0.2)
while True: #pega a data novamente
data = self.rx.getNData()
#self.rx.clearBuffer()
if self.getheadStart(data)==255:
break
print("Meu debug: "+str(data))
data, head = self.openPackage(data)
else:
break
"""
#print("tempo de trasmição: ",time_start_getData - time.time())
return (Complete_package, len(Complete_package))
def addHead(self, txLen, txBuffer):
return (self.buildHead(txLen) + txBuffer)
def decrypHead(self, head):
return (struct.unpack(self.headStruct, head))
def openPackage(self, file):
head = file[0:11]
file = file[11:-8]
return (file, head)
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.endes = endescapsulamento.Empacotamento()
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
"""
# endes = endescapsulamento.Empacotamento()
# packet = endes.buildDataPacket(data)
self.tx.sendBuffer(data)
def getData(self):
""" Get n data over the enlace interface
Return the byte array and the size of the buffer
"""
package = self.rx.searchForPacket()
data = self.endes.unpackage(package)
return (data)
def receive(self):
sync = False
while sync == False:
#iniciar timer para esperar um syn
time.sleep(2)
if self.rx.getBufferLen() != 0:
print("recebi algo")
packet = self.getData()
packetType = getType.getType(packet)
if packetType.getPacketType() == 'comando':
if packetType.getCommandType() == 'SYN':
print("é um syn")
self.sendData(self.endes.buildAckPacket())
print("Enviando Ack")
time.sleep(3)
self.sendData(self.endes.buildSynPacket())
print("Enviando Syn")
#outro timer esprando um ack do client
time.sleep(2)
packet2 = self.getData()
if len(packet2) != 0:
packetType2 = getType.getType(packet2)
if packetType2.getPacketType() == 'comando':
if packetType2.getCommandType() == 'ACK':
print("Recebeu Ack")
sync = True
time.sleep(3)
return True
else:
print("nao recebeu ultimo ack do server")
continue
else:
print("server nao mandou ack")
continue
else:
print(
"nao recebeu nenhum ack do server, reiniciando"
)
continue
else:
print("server nao mandou syn")
continue
else:
print("nao recebeu")
continue
else:
print("pacote vazio, procurar novamente")
continue
def conecta(self):
sync = False
while sync == False:
time.sleep(1)
synPacket = self.endes.buildSynPacket()
self.sendData(synPacket)
print("Mandando Syn")
# start_receiving_time = time.time()
# finished_receiving_time = time.time() - start_receiving_time
time.sleep(2)
# print("lenBuffer" + str(self.tx.getBufferLen()))
#inicia timer esperando um ack e um syn
bufferLen = self.rx.getBufferLen()
if bufferLen != 0:
packet = self.getData()
packetType = getType.getType(packet)
if packetType.getPacketType() == 'comando':
if packetType.getCommandType() == 'ACK':
print("Recebendo Ack")
time.sleep(3)
packet = self.getData()
packetType = getType.getType(packet)
if packetType.getPacketType() == 'comando':
if packetType.getCommandType() == 'SYN':
print('Recebendo Syn')
#iniciar timer para esperar um SYN do server
ackPacket = self.endes.buildAckPacket()
# print(self.rx.buffer)
self.sendData(ackPacket)
print("Mandando Ack")
# print(self.rx.buffer)
sync = True
time.sleep(2)
return True
else:
print("nao recebeu SYN do server")
continue
else:
print("nao recebeu ACK do server")
continue
else:
print("nao é um comando")
continue
else:
print("pacote vazio, reiniciando")
def confirm_client(self):
time.sleep(2)
if self.rx.getBufferLen() != 0:
packet = self.getData()
if packet != 0:
packetType = getType.getType(packet)
if packetType.getPacketType() == 'comando':
if packetType.getCommandType() == 'ACK':
return True
elif packetType.getCommandType() == 'NACK':
print("Pacote não recebido, reenviando")
# endes = endescapsulamento.Empacotamento()
# packet = endes.buildDataPacket(txBuffer)
# self.sendData(packet)
return False
else:
print('Aguardando confirmação de recebimento de pacote')
# sent = False
# return True
def confirm_server(self):
received = False
# while received == False:
if self.rx.getBufferLen == 0:
nackPacket = self.endes.buildNackPacket()
self.sendData(nackPacket)
return False
else:
# rxBuffer = self.getData()
print("recebi pacote")
ackPacket = self.endes.buildAckPacket()
self.sendData(ackPacket)
# received = True
return True
# break
# received = False
# return rxBuffer
def parsePacket(self, payload):
offset = 0
nPacotes = math.ceil(len(payload) / 2048)
packetCounter = 0
while packetCounter < nPacotes:
if (len(payload) - offset) >= 2048:
pacote = self.endes.buildDataPacket(
(payload[offset:offset + 2048]), packetCounter, nPacotes)
print("Enviando pacote: " + str(packetCounter + 1) + "/" +
str(nPacotes))
self.sendData(pacote)
confirmacao = self.confirm_client()
if confirmacao == True:
print("Pacote: " + str(packetCounter + 1) + " de " +
str(len(pacote) - 40) + " recebido")
print("--------------------------")
offset += 2048
packetCounter += 1
# time.sleep(2)
else:
continue
else:
pacote = self.endes.buildDataPacket((payload[offset:]),
packetCounter, nPacotes)
self.sendData(pacote)
print("Enviando pacote: " + str(packetCounter + 1) + "/" +
str(nPacotes))
confirmacao = self.confirm_client()
if confirmacao == True:
# print("confirmado")
print("Pacote: " + str(packetCounter + 1) + " de " +
str(len(pacote) - 40) + " bytes " + "recebido")
print("--------------------------")
# print(len(pacote))
packetCounter += 1
# time.sleep(2)
else:
continue
def receive_packets(self):
imagem = bytearray()
n = 0
total = 1
while n < total:
if self.rx.getBufferLen() != 0:
pacote = self.rx.searchForPacket()
# print("lenPacote " + str(len(pacote)))
headParameters = self.endes.getHeadParameters(pacote)
new_n = headParameters[0] + 1
total = headParameters[1]
print("Recebendo pacote: " + str(new_n) + "/" + str(total))
# print("new_n " + str(new_n))
# print("Total " + str(total))
payload = self.endes.unpackage(pacote)
data = payload[8:len(payload) - 8]
crcClient = payload[0:8]
# crcClient = self.endes.unpackage(pacote)[0:8]
# crcClientPayload = self.endes.unpackage(pacote)[-8:0]
crcClientPayload = payload[len(payload) - 8:]
# pacotePayload = self.endes.unpackage(pacote)[14:len(pacote) - 8]
# print("lenPacotePayload: " + str(len(pacotePayload)))
key = self.endes.getKey()
crcServer = self.endes.encodeData(str(pacote[0:6]), key)
hexCrc = self.endes.stringToHex(crcServer)
crcServerPayload = self.endes.encodeData(str(data), key)
hexCrcPayload = self.endes.stringToHex(crcServerPayload)
if hexCrc == crcClient:
if hexCrcPayload == crcClientPayload:
if (new_n != n):
print("Pacote: " + str(new_n) + "/" + str(total) +
" de " + str(len(payload) - 16) + " bytes " +
"recebido")
print("--------------------------")
n = new_n
ackPacket = self.endes.buildAckPacket()
self.sendData(ackPacket)
imagem += data
time.sleep(2)
else:
print(
"Pacote: " + str(new_n) + "/" + str(total) +
" já foi recebido, aguardando próximo pacote")
time.sleep(2)
continue
else:
print("crc Payload não confere, mandar novamente")
nackPacket = self.endes.buildNackPacket()
self.sendData(nackPacket)
time.sleep(2)
continue
else:
print("crc Head não confere, mandar novamente")
nackPacket = self.endes.buildNackPacket()
self.sendData(nackPacket)
time.sleep(2)
continue
else:
nackPacket = self.endes.buildNackPacket()
self.sendData(nackPacket)
continue
return imagem
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 comunicacao(self, data, user):
data_null = (0).to_bytes(4, byteorder="big")
while True:
if user == "client":
print("Enviada mensagem do tipo 1")
self.sendData(data_null, 0, 0, 0, 1, 0)
start_time1 = time.time()
size = self.waitLoop(2, 1)
if size != 0:
print('...')
rxBuffer = self.getData(size)
tipo_msg = self.getType(rxBuffer)
if tipo_msg == 2:
print("Mensagem tipo 2 recebida")
print('----------------------')
time.sleep(2.5)
print("Enviada mensagem do tipo 3")
self.sendData(data_null, 0, 0, 0, 3, 0)
time.sleep(1)
self.sendPackages(data)
print("Transmissao Concluida")
print("Enviando Mensagem de tipo 7 (encerramento)")
time.sleep(5)
self.sendData(data_null, 0, 0, 0, 7, 0)
break
elif tipo_msg == 7:
print("Mensagem de encerramento recebida - encerrando")
break
else:
print('--------------------')
print("Erro de mensagem recebida1")
print('--------------------')
else:
print('--------------------')
print("Mensagem tipo 2 não recebida")
print('--------------------')
if user == "server":
while True:
size = self.waitLoop(2, 0)
rxBuffer = self.getData(size)
tipo_msg = self.getType(rxBuffer)
print('tipo', tipo_msg)
if tipo_msg == 1:
print('--------------------')
print("Mensagem de tipo 1 recebida")
while True:
print("Enviada mensagem do tipo 2")
self.sendData(data_null, 0, 0, 0, 2, 0)
self.rx.clearBuffer()
size = self.waitLoop(3, 1)
#rxBuffer = self.getData(size)
if size == 0:
print('--------------------')
print("Mensagem de tipo 3 não recebida")
print('--------------------')
else:
rxBuffer = self.getData(size)
tipo_msg = self.getType(rxBuffer)
if tipo_msg == 3:
print('--------------------')
print(
"Recebida mensagem de tipo 3, esperando pacote de informações"
)
print('--------------------')
while True:
time.sleep(0.3)
size = self.waitLoop(4, 0)
rxBuffer = self.getData(size)
tipo_msg = self.getType(rxBuffer)
if tipo_msg == 7: #mensagem do tipo 7 (dados)
print(
"Mensagem de encerramento recebida - encerrando"
)
return data_null
elif tipo_msg == 4: #mensagem do tipo 4 (dados)
full_data = self.receivePackages()
print('Em Espera')
size = self.waitLoop(9, 0)
rxBuffer = self.getData(size)
tipo_msg = self.getType(rxBuffer)
if tipo_msg == 7: #mensagem do tipo 7 (dados)
print('--------------------')
print(
"Mensagem de tipo 7 recebida"
)
print('--------------------')
print("Conexao encerrando")
return full_data
else:
print('--------------------')
print("Erro de Mensagem recebida4")
print('--------------------')
elif tipo_msg == 7:
print(
"Mensagem de encerramento recebida - encerrando"
)
return data_null
else:
print('--------------------')
print("Erro de Mensagem recebida2")
print('--------------------')
elif tipo_msg == 7:
print("Mensagem de encerramento recebida - encerrando")
return data_null
else:
print("Erro de mensagem recebida3")
def sendData(self, data, numero_pacote, pacotes_totais, erro_pacote,
tipo_msg, crc):
""" Send data over the enlace interface
(self, payload, package_number, total_packages, package_error, message_type)
"""
pacote, lenPayload = self.tx.criaPackage(data, numero_pacote,
pacotes_totais, erro_pacote,
tipo_msg, crc)
self.tx.sendBuffer(pacote)
return lenPayload
def sendPackages(self, data):
print("...Inicio da transmissao dos pacotes de dados...")
total_packages = int((len(data) / 128) + 1)
lista_packages = []
i = 0
idx = 0
info = data
while len(info) > 128:
pay = info[:128]
info = info[128:]
lista_packages.append(pay)
lista_packages.append(info)
#while i<(len(data)-128):
# lista_packages.append(data[i:i+127])
# i+=128
#lista_packages.append(data[i:])
print('Pacotes totais:', total_packages)
print("{0} pacotes a serem enviados".format(len(lista_packages)))
while idx < len(lista_packages):
time.sleep(1)
val = lista_packages[idx]
while True:
print("------------------------------")
print("Pacote {0} enviado".format(idx))
print("Tamanho:", len(val))
print(self.crc16(val))
self.sendData(val, idx, total_packages, 0, 4,
self.crc16(val) + 1)
size = self.waitLoop(5, 1)
if size != 0:
break
else:
print("Resposta nao recebida")
rxBuffer = self.getData(size)
tipo_msg = self.getType(rxBuffer)
if tipo_msg == 5:
print("Mensagem tipo 5 recebida")
idx += 1
elif tipo_msg == 6:
print("Mensagem tipo 6 recebida")
elif tipo_msg == 8:
print("Mensagem tipo 8 recebida")
if self.getExpectedPackage(rxBuffer) == -1:
print("Erro de Mensagem")
else:
idx = self.getExpectedPackage(rxBuffer)
elif tipo_msg == 7:
print("Mensagem de encerramento recebida - encerrando tudo")
return
else:
print("Erro de Mensagem")
print("Transmissao dos pacotes concluida")
return
def receivePackages(self):
print("...Inicio da recepcao dos pacotes de dados...")
pacote_esperado = 0
lista_packages = bytes(0)
data_null = (0).to_bytes(4, byteorder="big")
while True:
size = self.waitLoop(9, 0)
rxBuffer = self.getData(size)
if rxBuffer == 51:
print("Erro de mensagem")
self.sendData(data_null, 0, 0, 0, 6, 0)
else:
pacotes_totais = rxBuffer[1]
tipo_msg = self.getType(rxBuffer)
if tipo_msg == 4:
if self.getPackageNumber(rxBuffer) == pacote_esperado:
if self.crcIsCorrect(rxBuffer):
print('_____________________')
print("Pacote recebido: {0}".format(
self.getPackageNumber(rxBuffer)))
print(
"Pacote esperado: {0}".format(pacote_esperado))
print("Correto! - Mensagem de tipo 5 enviada")
self.sendData(data_null, 0, 0, 0, 5, 0)
package = self.getPackage(rxBuffer)
print(self.crc16(package))
lista_packages += package
pacote_esperado += 1
print('Pacotes a serem recebidos:',
(pacotes_totais - pacote_esperado))
if pacotes_totais - pacote_esperado == 0:
print("Todos os {0} pacotes recebidos".format(
pacote_esperado))
full_data = lista_packages
print(
"Os dados recebidos tem {0} bytes".format(
len(full_data)))
break
else:
print("Pacote corrompido - CRC incorreto")
time.sleep(1)
print("Enviada mensagem de tipo 6")
self.sendData(data_null, 0, 0, 0, 6, 0)
else:
print('_____________________')
print("Pacote recebido: {0}".format(
self.getPackageNumber(rxBuffer)))
print("Pacote esperado: {0}".format(pacote_esperado))
print("Incorreto! - Mensagem de tipo 8 enviada")
time.sleep(1)
self.sendData(data_null, 0, 0, pacote_esperado, 8, 0)
elif tipo_msg == 7:
print(
'Mensagem de tipo 7 recebida - comunicacao encerrando')
break
print('Transmissao dos pacotes encerrada')
return full_data
def getData(self, size):
""" Get n data over the enlace interface
Return the byte array and the size of the buffer
"""
buffer_data = self.rx.getNData(size)
data = self.rx.desfaz_package(buffer_data)
return (data)
def getType(self, data):
#null, tipo_msg = self.rx.desfaz_package(package)
if data == 51:
return data
tipo_msg = data[9]
return tipo_msg
def getPackage(self, data):
if data == 51:
return data
package = data[10:]
return package
def getPackageNumber(self, data):
if data == -1:
return data
package_number = data[0]
return package_number
def getExpectedPackage(self, data):
if data == -1:
return data
expected_type = data[2]
return expected_type
def crcIsCorrect(self, data):
expected_crc = int.from_bytes(data[6:9], byteorder="big")
true_crc = self.crc16(self.getPackage(data))
if expected_crc == true_crc:
return True
else:
return False
def waitLoop(self, type, timed):
size = 10
start_time1 = time.time()
if timed == 1:
while (self.rx.getBufferLen() == 0 or self.rx.getBufferLen() > size
) and (time.time() - start_time1) < 5:
if (type == 9):
print('.')
else:
print("Esperando tipo {0}".format(type))
time.sleep(0.5)
size = self.rx.getBufferLen()
if timed == 0:
while self.rx.getBufferLen() == 0 or self.rx.getBufferLen() > size:
print("Recebendo")
time.sleep(0.3)
size = self.rx.getBufferLen()
return size
def crc16(self, data: bytes):
return crc16.crc16xmodem(data)
