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.payload = b'\x00'
self.package = None
self.dataSize = 0
self.headSize = 16
self.clientSynchComplete = False
self.serverSynchComplete = False
self.file = []
self.packageExpected = 1
self.mensagemTipo1 = {'enviada': False, 'recebida': False}
self.mensagemTipo2 = {'enviada': False, 'recebida': False}
self.mensagemTipo3 = {'enviada': False, 'recebida': False}
self.mensagemTipo4 = {'enviada': False, 'recebida': False}
self.mensagemTipo5 = {'enviada': False, 'recebida': False}
self.mensagemTipo6 = {'enviada': False, 'recebida': False}
self.mensagemTipo7 = {'enviada': False, 'recebida': False}
self.mensagemTipo8 = {'enviada': False, 'recebida': False}
self.mensagemTipo9 = {'enviada': False, 'recebida': False}
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 __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 __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 __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 __init__(self, name):
""" Initializes the enlace class
"""
self.tipo1 = bytearray("1", "ascii")
self.tipo2 = bytearray("2", "ascii")
self.tipo3 = bytearray("3", "ascii")
self.tipo4 = bytearray("4", "ascii")
self.fisica = fisica(name)
self.rx = RX(self.fisica)
self.tx = TX(self.fisica)
self.connected = False
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 __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 __init__(self, name):
""" Initializes the enlace class
"""
self.fisica = fisica(name)
self.rx = RX(self.fisica)
self.tx = TX(self.fisica)
self.connected = 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
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 sendData(self, data, tipo, pacotesAtual, pacotesTotal):
""" Send data over the enlace interface
"""
self.tx.sendBuffer(data, tipo, pacotesAtual, pacotesTotal)
def sendBufferAfterFragmentation(self, data, tipo, pacotesAtual,
pacotesTotal):
self.tx.sendBufferAfterFragmentation(data, tipo, pacotesAtual,
pacotesTotal)
def constructPack(self, data, tipo, pacotesAtual, pacotesTotal):
return self.tx.packMessage(data, tipo, pacotesAtual, pacotesTotal)
def getData(self):
""" Get n data over the enlace interface
Return the byte array and the size of the buffer
"""
data, tipo = self.rx.getNData()
return (data, tipo)
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
"""
self.tx.sendBuffer(data)
def getData(self, size):
""" Get n data over the enlace interface
Return the byte array and the size of the buffer
"""
print('entrou na leitura e tentara ler ' + str(size))
data = self.rx.getNData(size)
return (data, len(data))
def getDataTimerClient(self, size, timer1, timer2):
""" Get n data over the enlace interface
Return the byte array and the size of the buffer
"""
print('entrou na leitura e tentara ler ' + str(size))
data = self.rx.getNDataTimerClient(size, timer1, timer2)
return (data, len(data))
def getDataTimerCServer(self, size, timer1, timer2):
""" Get n data over the enlace interface
Return the byte array and the size of the buffer
"""
print('entrou na leitura e tentara ler ' + str(size))
data = self.rx.getNDataTimerServer(size, timer1, timer2)
return (data, len(data))
class enlace(object):
def __init__(self, name):
self.fisica = fisica(name)
self.rx = RX(self.fisica)
self.tx = TX(self.fisica)
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()
def sendData(self, data):
self.tx.sendBuffer(data)
def getData(self, size):
status, data = self.rx.getNData(size)
return(status, ( data, len(data) ))
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, msgtype):
""" Send data over the enlace interface"""
self.tx.sendBuffer(data, msgtype)
def getData(self):
""" Get n data over the enlace interface
Return the byte array and the size of the buffer
"""
data, msgtype = self.rx.getNData()
return (data, msgtype)
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, msgtype, currpart, totalpart):
""" Send data over the enlace interface"""
self.tx.sendBuffer(data, msgtype, currpart, totalpart)
def sendDataNoBuild(self, fullpack):
""" Send data over the enlace interface"""
self.tx.sendBufferNoBuild(fullpack)
def buildPackage(self, data, msgtype, currpart, totalpart):
""" Builds packet"""
return self.tx.buildDataPackage(data, msgtype, currpart, totalpart)
def getData(self):
""" Get n data over the enlace interface
Return the byte array and the size of the buffer
"""
data, msgtype, crc = self.rx.getNData()
return(data, msgtype, 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.baudrate = self.fisica.baudrate
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, tipo):
""" Send data over the enlace interface
"""
pacote = self.tx.empacota(data, tipo)
#print(pacote)
self.tx.sendBuffer(pacote)
time.sleep(1)
throughput = len(pacote) / self.fisica.tempo
print("Throughput: {} kB/s".format(throughput / 1024))
def getData(self, size):
""" Get n data over the enlace interface
Return the byte array and the size of the buffer
"""
print('entrou na leitura e tentara ler ' + str(size))
data = self.rx.getNData(size)
#dados = self.rx.desempacota(data)
return (data, len(data))
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
"""
pacote, lenPayload = self.tx.cria_package(data)
self.tx.sendBuffer(pacote)
return lenPayload
def getData(self):
""" Get n data over the enlace interface
Return the byte array and the size of the buffer
"""
print('entrou na leitura e tentara ler ')
data, size = self.rx.getNData()
payload = self.rx.desfaz_package(data)
return (payload, len(payload))
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
"""
#dataEncap = facadeEnlace.encapsulate(data, messageType)
self.tx.sendBuffer(data)
def getData(self, size):
""" Get n data over the enlace interface
Return the byte array and the size of the buffer
"""
data = self.rx.getNData(size)
resultData, txLen, messageType, ack, numeroPacote, totalPacote, crc_checked = facadeEnlace.readHeadNAll(
bytearray(data))
return (resultData, len(resultData), messageType, ack, numeroPacote,
totalPacote, crc_checked)
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, tipo, data=b'', pkgtotal=1, pkgcurrent=1):
""" Send data over the enlace interface
"""
self.tx.sendBuffer(tipo, data, pkgtotal, pkgcurrent)
def getData(self, maxTime=-1):
""" Get n data over the enlace interface
Return the byte array and the size of the buffer
"""
data, msgType, pkgtotal, pkgcurrent = self.rx.getNData(maxTime)
#print("msgtype dentro do getdata = " + str(msgType))
self.rx.clearBuffer()
return (data, len(data), msgType, pkgtotal, pkgcurrent)
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
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
"""
self.tx.sendBuffer(data)
def getData(self, size):
""" Get n data over the enlace interface
Return the byte array and the size of the buffer
"""
data = self.rx.getNData(size)
return(data, len(data))
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])
def __init__(self, name):
self.fisica = fisica(name)
self.rx = RX(self.fisica)
self.tx = TX(self.fisica)
self.connected = False
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
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
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
"""
self.client_sync()
self.client_transmission(data)
self.client_encerramento()
def getData(self):
""" Get n data over the enlace interface
Return the byte array and the size of the buffer
"""
print('entrou na leitura e tentara ler ')
self.server_sync()
payload = self.server_transmission()
self.server_encerramento()
return (payload, len(payload))
def client_sync(self):
sync1 = False
sync2 = False
payload = (0).to_bytes(1, byteorder="big")
sync_package = self.tx.cria_package(payload, 1, 0, 0, 0)
sync_package3 = self.tx.cria_package(payload, 3, 0, 0, 0)
print(sync_package)
self.tx.sendBuffer(sync_package)
timer = time.time()
while not sync1:
data, size = self.rx.getNData()
payload, tipo, ok, n_pacote, total_pacotes, pacote_esperado = self.rx.desfaz_package(
data)
if tipo == 2 and ok:
sync1 = True
print("recebeu tipo 2")
break
run_time = time.time() - timer
if run_time > 5:
print("Error: not receive type 2 ---------> Reenviando tipo 1")
self.tx.sendBuffer(sync_package)
timer = time.time()
self.tx.sendBuffer(sync_package3)
timer = time.time()
while not sync2:
data, size = self.rx.getNData()
payload, tipo, ok, n_pacote, total_pacotes, pacote_esperado = self.rx.desfaz_package(
data)
if tipo == 40 and ok:
sync2 = True
print("recebeu tipo 40")
break
run_time = time.time() - timer
if run_time > 5.0:
print("mandou tipo 3")
self.tx.sendBuffer(sync_package3)
timer = time.time()
def server_sync(self):
sync1 = False
sync2 = False
payload_nulo = (0).to_bytes(1, byteorder="big")
sync_package2 = self.tx.cria_package(payload_nulo, 2, 0, 0, 0)
sync_package40 = self.tx.cria_package(payload_nulo, 40, 0, 0, 0)
while not sync1:
data, size = self.rx.getNData()
payload, tipo, ok, n_pacote, total_pacotes, pacote_esperado = self.rx.desfaz_package(
data)
if tipo == 1 and ok:
sync1 = True
print("recebeu tipo 1")
break
self.tx.sendBuffer(sync_package2)
print("Enviou tipo 2")
timer = time.time()
while not sync2:
data, size = self.rx.getNData()
payload, tipo, ok, n_pacote, total_pacotes, pacote_esperado = self.rx.desfaz_package(
data)
if tipo == 3 and ok:
sync2 = True
print("recebeu tipo 3")
break
run_time = time.time() - timer
if run_time > 5.0:
print("Erro: Type 3 not received --------> Reenviando tipo 2")
self.tx.sendBuffer(sync_package2)
timer = time.time()
self.tx.sendBuffer(sync_package40)
def client_transmission(self, payload):
payloadnulo = (0).to_bytes(1, byteorder="big")
timer = time.time()
lista_pacotes, total_pacotes = self.separa_pacotes(payload)
for i in range(len(lista_pacotes)):
sync_package4 = self.tx.cria_package(lista_pacotes[i], 4, i + 1,
len(lista_pacotes), 0)
self.tx.sendBuffer(sync_package4)
print("Mandou o pacote {0}/{1}".format(i + 1, len(lista_pacotes)))
while True:
data, size = self.rx.getNData()
payload, tipo, ok, n_pacote, n_total, pacote_esperado = self.rx.desfaz_package(
data)
if tipo == 5 and ok:
sync1 = True
print("recebeu tipo 5")
break
elif tipo == 6 and ok:
self.tx.sendBuffer(sync_package4)
print("recebeu tipo 6")
timer = time.time
elif tipo == 8 and ok:
sync_package8 = self.tx.cria_package(
lista_pacotes[pacote_esperado], 4, pacote_esperado,
n_total, 0)
self.tx.sendBuffer(sync_package8)
run_time = time.time() - timer
if run_time > 4:
print(
"Tipo 5 ou 6 NAO recebido ------> Reenviando tipo 4 | {0} / {1} Tamanho:{2} bytes"
.format(i + 1, total_pacotes, len(lista_pacotes[i])))
self.tx.sendBuffer(sync_package4)
timer = time.time()
def server_transmission(self):
payloadnulo = (0).to_bytes(1, byteorder="big")
sync_package5 = self.tx.cria_package(payloadnulo, 5, 0, 0, 0)
sync_package6 = self.tx.cria_package(payloadnulo, 6, 0, 0, 0)
lista_fragmentada = []
pacote_davez = 1
while True:
data, size = self.rx.getNData()
payload, tipo, ok, n_pacote, total_pacotes, pacote_esperado = self.rx.desfaz_package(
data)
#if n_pacote != pacote_davez:
# print("ERRO: Deveria ter recebido {0} e recebeu {1}".format(pacote_davez, n_pacote))
# while True:
## sync_package8 = self.tx.cria_package(payloadnulo, 8, 0, 0, pacote_davez)
# self.tx.sendBuffer(sync_package8)
if tipo == 4 and ok:
if n_pacote != pacote_davez:
print(
"ERRO: Deveria ter recebido {0} e recebeu {1}".format(
pacote_davez, n_pacote))
sync_package8 = self.tx.cria_package(
payloadnulo, 8, 0, 0, pacote_davez)
self.tx.sendBuffer(sync_package8)
timer = time.time()
while True:
payload, tipo, ok, n_pacote, total_pacotes, pacote_esperado = self.rx.desfaz_package(
data)
if tipo == 4 and ok:
break
run_time = time.time() - timer
if run_time > 5:
self.tx.sendBuffer(sync_package8)
pacote_davez += 1
lista_fragmentada.append(payload)
self.tx.sendBuffer(sync_package5)
sync1 = True
print("recebeu tipo 4 | {0}/{1} CORRETO, ENVIA 5".format(
n_pacote, total_pacotes))
if n_pacote == total_pacotes:
break
elif tipo == 4 and not ok:
self.tx.sendBuffer(sync_package6)
print("Recebeu tipo 4 INCORRETO, Envia 6")
compilado = bytes.fromhex("FF")
for fragment in lista_fragmentada:
compilado += fragment
compilado = compilado[1:]
return compilado
def client_encerramento(self):
time.sleep(4)
payloadnulo = (0).to_bytes(1, byteorder="big")
sync_package7 = self.tx.cria_package(payloadnulo, 7, 0, 0, 0)
print("enviou tipo 7")
self.tx.sendBuffer(sync_package7)
def server_encerramento(self):
encerra = False
package_arbitrario = bytes.fromhex("F5 A3 AA C3 C3 B5 B4")
timer = time.time()
while not encerra:
data, size = self.rx.getNData()
payload, tipo, ok, n_pacote, total_pacotes, pacote_esperado = self.rx.desfaz_package(
data)
if tipo == 7:
print("recebeu tipo 7, conexao encerrada")
break
run_time = time.time() - timer
if run_time > 10:
break
def separa_pacotes(self, data):
lista_pacotes = []
while len(data) > 128:
pacote = data[0:128]
data = data[128:]
lista_pacotes.append(pacote)
if len(data) > 0:
pacote = data
lista_pacotes.append(pacote)
return lista_pacotes, len(lista_pacotes)
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.tipo1 = bytearray("1", "ascii")
self.tipo2 = bytearray("2", "ascii")
self.tipo3 = bytearray("3", "ascii")
self.tipo4 = bytearray("4", "ascii")
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, lista_pacotes):
""" Send data over the enlace interface
"""
for i in range(len(lista_pacotes)):
self.tx.sendBuffer(lista_pacotes[i])
print("Pacote: ", i + 1, "de", len(lista_pacotes))
time.sleep(1)
def getData(self):
""" Get n data over the enlace interface
Return the byte array and the size of the buffer
"""
print('entrou na leitura e tentara ler ')
data, overhead, pacote_esperado = self.rx.getNData()
self.rx.clearBuffer()
return (data, len(data), overhead, pacote_esperado)
def Synch_Client(self):
#Etapa 1
print("Synching1")
txLen1 = len(self.tipo1)
package = self.tx.organize_package(txLen1, self.tipo1, 1)
self.sendData(package)
while (True):
timeout = time.time() + 5
received, nRx, overhead, pacote_esperado = self.getData()
if received == self.tipo2:
txLen3 = len(self.tipo3)
package = self.tx.organize_package(txLen3, self.tipo3, 3)
self.sendData(package)
print("Synching2")
print("Synching Done")
self.rx.clearBuffer()
time.sleep(1)
return True
elif time.time() > timeout:
print("Timeout")
return False
def Synch_Server(self):
timeout = time.time() + 5
#Etapa 1
print("Synching1")
txLen2 = len(self.tipo2)
while (True):
received, nRx, overhead, pacote_esperado = self.getData()
if (received == self.tipo1):
package = self.tx.organize_package(txLen2, self.tipo2, 2)
self.sendData(package)
print("Synching2")
while (True):
timeout = time.time() + 5
received, nRx, overhead, pacote_esperado = self.getData()
if (received == self.tipo3):
print("Synching Done")
self.rx.clearBuffer()
return True
elif time.time() > timeout:
print("Timeout")
break
elif (time.time() > timeout):
print("Timeout")
break
return False
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, 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 calculaCRC(self, data):
crc16_func = crcmod.mkCrcFun(0x104c1, initCrc=0, xorOut=0xFFFF)
resto = crc16_func(data)
print("RESTO = {}".format(resto))
return resto
def sendData(self, data):
""" Send data over the enlace interface
"""
dataslice=self.tx.slicedata(data)
synch=self.synchClient()
if synch:
time.sleep(1)
print("SERAO ENVIADOS {} PACOTES".format(len(dataslice)))
for i in range(len(dataslice)):
tipo_check = False
time.sleep(1)
while not tipo_check:
# Envia tipo 4
time.sleep(1)
print("##### ENVIANDO TIPO 4 #####")
resto = self.calculaCRC(dataslice[i])
head = self.tx.makeHead(dataslice[i], 4, i, len(dataslice)-1, resto)
self.tx.sendBuffer(dataslice[i], head)
# Espera tipo 5/6
print("##### ESPERANDO TIPO 5/6 #####")
data_1, check, numero, total, check_resto= self.rx.getNData()
tipo = data_1[7]
if tipo == 5:
print("##### RECEBI TIPO 5 ######")
tipo_check = True
time.sleep(1)
break
if tipo == 6:
print("##### RECEBI TIPO 6 ######")
self.rx.clearBuffer()
time.sleep(1)
if tipo == 8:
print("##### RECEBI TIPO 8 ######")
self.rx.clearBuffer()
time.sleep(1)
if tipo == 9:
print("##### RECEBI TIPO 9 ######")
self.rx.clearBuffer()
time.sleep(1)
else:
print("##### NAO RECEBI TIPO 5 OU 6 OU 8 OU 9######")
self.rx.clearBuffer()
time.sleep(1)
print("##### ENVIANDO TIPO 7 #####")
self.sendFiller(7)
def sendFiller(self, tipo, esperado=0):
fillerData = 0
fillerBuffer = fillerData.to_bytes(1, byteorder="big")
if tipo == 8:
head = self.tx.makeHead(fillerBuffer, tipo, 0, 0, esperado)
else:
head = self.tx.makeHead(fillerBuffer, tipo)
self.tx.sendBuffer(fillerBuffer, head)
def synchClient(self):
tipo = 0
# Envia Tipo 1
self.sendFiller(1)
print("##### TIPO 1 ENVIADO #####")
# Recebe Tipo 2
data, check, numero, total, check_resto =self.rx.getNData()
tipo=data[7]
if tipo == 2:
print("##### RECEBI TIPO 2 #####")
# Envia Tipo 3
self.sendFiller(3)
print("Tipo 3 enviado")
return True
else:
print(" ###### Não recebi tipo 2 ######")
return False
def synchServer(self):
# Recebe tipo 1
tipo = 0
data, check, numero, total, check_resto = self.rx.getNData()
tipo=data[7]
if tipo == 1:
print("###### Recebi tipo 1 ######")
# Envia tipo 2
self.sendFiller(2)
print("Tipo 2 Enviado")
data, check, numero, total, check_resto =self.rx.getNData()
tipo=data[7]
if tipo == 3:
print("###### Recebi tipo 3 ######")
return True
else:
print(" ###### Não recebi tipo 3 ######")
return False
else:
print(" ###### Não recebi tipo 1 ######")
return False
def getData(self):
""" Get n data over the enlace interface
Return the byte array and the size of the buffer
"""
print('entrou na leitura e tentara ler ' )
dataList = []
count = -1
synch = self.synchServer()
if synch:
while True:
tipo_check = False
count += 1
while not tipo_check:
time.sleep(1)
print("##### ESPERANDO TIPO 4 #####")
data, check_tamanho, numero, total, check_resto = self.rx.getNData()
print("NUMERO = {}".format(numero))
print("COUNT = {}".format(count))
if count == numero:
numCheck = True
else:
numCheck = False
if check_tamanho and numCheck and check_resto:
print("##### ENVIANDO TIPO 5 #####")
time.sleep(1)
self.sendFiller(5)
tipo_check = True
break
elif check_tamanho and numCheck:
if numCheck:
print("##### ENVIANDO TIPO 6 #####")
time.sleep(1)
self.sendFiller(6)
else:
print("##### ENVIANDO TIPO 8 #####")
time.sleep(1)
self.sendFiller(8, count)
else:
print("##### ENVIANDO TIPO 9 #####")
time.sleep(1)
self.sendFiller(9)
dataList.append(data)
print("NUMERO = {}".format(numero))
print("TOTAL = {}".format(total))
if numero == total:
break
print("##### ESPERANDO TIPO 7 #####")
time.sleep(1)
data_7, check_tamanho, numero, total, check_resto = self.rx.getNData()
tipo = data_7[7]
if tipo == 7:
print("##### RECEBI TIPO 7 #####")
datafull = bytearray()
print("RECEBI {} PACOTES".format(len(dataList)))
for i in dataList:
datafull = datafull + i
return(datafull, len(data))
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
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 = Empacota(data, "data", 1, 1).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()
data = desempacota(package)
return (data[0], data[1], (len(data[0])), data[2])
def sendAck(self):
#Envia os ACKs para autorizar inicio da conexão ou confirmar recebimentoss
package = Empacota(None, "ACK", 1, 1).buildPackage()
self.tx.sendBuffer(package)
def sendNack(self):
#Avisa que pacote chegou corrompido
package = Empacota(None, "NACK", 1, 1).buildPackage()
self.tx.sendBuffer(package)
def sendSync(self):
#Para estabelecer conexão
package = Empacota(None, "sync", 1, 1).buildPackage()
self.tx.sendBuffer(package)
def waitConnection(self): #Papel do Server
#print("connected", connected)
#Fica conferindo recebimento do sync e se recebe, confirma enviando ack. Depois envia o sync e confirma se recebeu ack de confirmação.
while self.connected == False:
print("Loop waitconnection")
response = self.getData()
print("Waiting sync...")
#print("response", response)
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:
print("falhou")
time.sleep(1)
self.sendNack()
return False
else:
print("falhou")
time.sleep(1)
self.sendNack()
return False
def establishConnection(self): #Papel do Client
#Envia o Sync para iniciar e pega a resposta. Se tiver Ack (confirmação de recebimento sync), procura pelo recebimento de sync e envia ack.
while self.connected == False:
self.sendSync()
response = self.getData()
print("Waiting sync...")
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
elif response[3] == "NACK":
return False
else:
return False
def verifyPackage(self, data):
package = Package(data).buildPackage()
sizePack = len(package)
expected = len(self.getData())
if sizePack == expected:
self.sendAck()
return True
else:
self.sendNack()
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.payload = b'\x00'
self.package = None
self.dataSize = 0
self.headSize = 16
self.clientSynchComplete = False
self.serverSynchComplete = False
self.file = []
self.packageExpected = 1
self.mensagemTipo1 = {'enviada': False, 'recebida': False}
self.mensagemTipo2 = {'enviada': False, 'recebida': False}
self.mensagemTipo3 = {'enviada': False, 'recebida': False}
self.mensagemTipo4 = {'enviada': False, 'recebida': False}
self.mensagemTipo5 = {'enviada': False, 'recebida': False}
self.mensagemTipo6 = {'enviada': False, 'recebida': False}
self.mensagemTipo7 = {'enviada': False, 'recebida': False}
self.mensagemTipo8 = {'enviada': False, 'recebida': False}
self.mensagemTipo9 = {'enviada': False, 'recebida': 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
"""
self.tx.sendBuffer(data)
def getData(self, last_message=0):
""" Get n data over the enlace interface
Return the byte array and the size of the buffer
"""
# print('entrou na leitura e tentara ler ' + str(size) )
data = self.rx.getNData()
if data == 0 or data is None:
data = self.tx.createPACKAGE(0)
messageType = self.checkMessageType(data, last_message)
else:
messageType = self.checkMessageType(
data) #Verifica o tipo da mensagem no buffer
payloadSize = 1
if messageType == 4:
try:
recievePack = data
CRC16, packageNumber, packageTotal, erro8, packageExpected, dataSize, data = self.rx.unpackage(
recievePack)
self.checkAcknoledgement(CRC16, data, dataSize, packageNumber,
packageTotal, packageExpected)
return data, len(data), dataSize
except:
pass
return data, len(data), payloadSize
def clientSynch(self):
# Cria pacote vazio com mensagem tipo 1
pack1 = self.tx.createPACKAGE(1)
while self.mensagemTipo2['recebida'] == False:
# Envia mensagem tipo 1
self.sendData(pack1)
print("Mensagem tipo 1: Enviada")
time.sleep(0.1)
self.getData(1) # Le o Buffer de recebimento
timeout = self.rx.timeout
if timeout >= 5:
print("[ERRO] - Não recebimento da mensagem tipo 2")
return
#Cria pacote vazio com mensagem tipo 3
pack3 = self.tx.createPACKAGE(3)
# Envia mensagem tipo 3
self.sendData(pack3)
print("Mensagem tipo 3: Enviada")
self.mensagemTipo3['enviada'] == True
self.clientSynchComplete = True
def serverSynch(self):
while self.mensagemTipo1['recebida'] == False:
time.sleep(0.1)
self.getData()
# Cria pacote vazio com mensagem tipo 2
pack2 = self.tx.createPACKAGE(2)
self.sendData(pack2)
print("Mensagem tipo 2: Enviada") # Envia mensagem tipo 2
time.sleep(0.1)
while self.mensagemTipo3['recebida'] == False:
self.getData(2)
timeout = self.rx.timeout
if timeout >= 5:
print("[ERRO] - Não recebimento da mensagem tipo 3")
return
self.serverSynchComplete = True
def splitPack(self, payload, payloadLimit=128):
subPacks = [
payload[i:i + payloadLimit]
for i in range(0, len(payload), payloadLimit)
]
return subPacks
def clientSendPackages(self, packages):
self.packageExpected = 1
nPackages = len(packages)
for i in range(nPackages):
self.mensagemTipo5['recebida'] = False
self.mensagemTipo6['recebida'] = False
atualPack = i + 1
subPack = packages[i]
pack = self.tx.createPACKAGE(4, subPack, atualPack, nPackages)
#self.rx.printer(pack)
self.sendData(pack)
print("Pacote {}/{} enviados".format(i + 1, nPackages))
while self.mensagemTipo5['recebida'] == False:
time.sleep(0.2)
self.getData(4)
timeout = self.rx.timeout
if timeout >= 5:
print("[ERRO] - Não recebimento da mensagem tipo 5 ou 6")
return
if self.mensagemTipo8["recebida"] == True:
self.sendData(pack)
print("Pacote enviado novamente")
self.sendEndingMassage()
def checkAcknoledgement(self, CRC16, data, payloadSize, packageNumber,
packageTotal, packageExpected):
print("Len data: {} PayloadSize: {}".format(len(data), payloadSize))
if len(data) == payloadSize:
crc_isRight = self.rx.checkCRC16(data, CRC16)
print("CRC-16 HEADER: {} CRC-16 CHECK: {}".format(
CRC16, self.fisica.calculaCRC16(data)))
if packageNumber == self.packageExpected:
if ((packageNumber < packageTotal)
or (packageNumber == packageTotal)):
if crc_isRight == True:
self.packageExpected += 1
mensagemTipo5 = self.tx.createPACKAGE(5)
self.sendData(mensagemTipo5)
self.mensagemTipo5['enviada'] = True
print("Mensagem tipo 5 enviada")
self.file.append(data)
else:
mensagemTipo9 = self.tx.createPACKAGE(
9, error8=1, packageExpected=packageExpected)
self.sendData(mensagemTipo9)
self.mensagemTipo9['enviada'] = True
print("Mensagem tipo 9 enviada")
else:
mensagemTipo8 = self.tx.createPACKAGE(
8, error8=1, packageExpected=packageExpected)
self.sendData(mensagemTipo8)
self.mensagemTipo8['enviada'] = True
print("Mensagem tipo 8 enviada")
else:
mensagemTipo8 = self.tx.createPACKAGE(
8, error8=1, packageExpected=packageExpected)
self.sendData(mensagemTipo8)
self.mensagemTipo8['enviada'] = True
print("Mensagem tipo 8 enviada")
else:
mensagemTipo6 = self.tx.createPACKAGE(6)
self.sendData(mensagemTipo6)
self.mensagemTipo6['enviada'] = True
print("Mensagem tipo 6 enviada")
def checkMessageType(self, message, last_message=0):
messageType = 0
try:
messageType = message[9]
except:
print("DEU RUIM AQUI")
#print(messageType)
if messageType == 0 and last_message != 0:
if last_message == 4:
print("[ERRO] - Não recebimento da mensagem tipo 5 ou 6")
else:
print("[ERRO] - Não recebimento da mensagem tipo {}".format(
last_message + 1))
if messageType == 1:
print("Mensagem tipo 1: Recebida")
self.mensagemTipo1['recebida'] = True
elif messageType == 2:
print("Mensagem tipo 2: Recebida")
self.mensagemTipo2['recebida'] = True
elif messageType == 3:
print("Mensagem tipo 3: Recebida")
self.mensagemTipo3['recebida'] = True
elif messageType == 4:
print("Mensagem tipo 4: Recebida")
self.mensagemTipo4['recebida'] = True
return 4
elif messageType == 5:
print("Mensagem tipo 5: Recebida")
self.mensagemTipo5['recebida'] = True
return 5
elif messageType == 6:
print("Mensagem tipo 6: Recebida")
self.mensagemTipo6['recebida'] = True
return 6
elif messageType == 7:
# Encerra comunicação
print("Mensagem tipo 7: Recebida")
print("-------------------------")
print("Comunicação encerrada")
print("-------------------------")
self.mensagemTipo7['recebida'] = True
self.disable()
elif messageType == 8:
print("Mensagem tipo 8: Recebida")
self.mensagemTipo8['recebida'] = True
elif messageType == 9:
print("Mensagem tipo 9: Recebida")
self.mensagemTipo9['recebida'] = True
else:
pass
#print("ERROR: Mensagem tipo {}".format(messageType))
#print("ERROR: Ultima Mensagem {}".format(last_message))
def sendEndingMassage(self):
pack7 = self.tx.createPACKAGE(7)
self.sendData(pack7)
self.mensagemTipo7['enviada'] = True
print("Mensagem tipo 7: Enviada")
print("-------------------------")
print("Comunicação encerrada")
print("-------------------------")
self.disable()
