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):
""" 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
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.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
"""
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
"""
synch = self.synchClient()
if synch:
time.sleep(1)
tipo_check = False
while not tipo_check:
# Envia tipo 4
print("##### ENVIANDO TIPO 4 #####")
head = self.tx.makeHead(data, 4)
self.tx.sendBuffer(data, head)
# Espera tipo 5/6
print("##### ESPERANDO TIPO 5/6 #####")
data_1, check = self.rx.getNData()
tipo = data_1[7]
if tipo == 5:
print("##### RECEBI TIPO 5 ######")
tipo_check = True
break
if tipo == 6:
print("##### RECEBI TIPO 6 ######")
self.rx.clearBuffer()
else:
print("##### NAO RECEBI TIPO 5 OU 6 ######")
self.rx.clearBuffer()
print("##### ENVIANDO TIPO 7 #####")
self.sendFiller(7)
def sendFiller(self, tipo):
fillerData = 0
fillerBuffer = fillerData.to_bytes(1, byteorder="big")
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 = 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 = 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 = 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 ')
synch = self.synchServer()
if synch:
tipo_check = False
while not tipo_check:
print("##### ESPERANDO TIPO 4 #####")
data, check_tamanho = self.rx.getNData()
if check_tamanho:
print("##### ENVIANDO TIPO 5 #####")
self.sendFiller(5)
tipo_check = True
break
else:
print("##### ENVIANDO TIPO 6 #####")
self.sendFiller(6)
print("##### ESPERANDO TIPO 7 #####")
data_7, check_tamanho = self.rx.getNData()
tipo = data_7[7]
if tipo == 7:
print("##### RECEBI TIPO 7 #####")
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 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)
