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): 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): """ 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): """ 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() 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 """ #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, 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, 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 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 """ 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 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 """ 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 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 self.queuedPck = [] self.receivedPck = [] self.meta = None def enable(self): """ Enable reception and transmission """ self.fisica.open() self.rx.threadStart() self.tx.threadStart() def disable(self): """ Disable reception and transmission """ self.rx.threadKill() self.tx.threadKill() time.sleep(1) self.fisica.close() ################################ # Application interface # ################################ def listenPacket(self, timeout, size): #valor -1111 desativa o timeout label = 85 packet = None dic = { 'small': 17, 'medium': 544, #signature + label + thresh + pckAmount + filenameSize + content + checksum + signature : +8 +1 +2 +3 +2 +512 +8 +8 'big': 14 + 2**10 + 16 } #header + payload + eop size = dic[size] while timeout > 0 or timeout == -1111: if (timeout != -1111): timeout -= 100 time.sleep(0.1) if (self.rx.getBufferLen() >= size): packet = self.rx.getBuffer(size) label = packet[8] break if (packet != None and (packet[0:8] != 'F.A.S.T.'.encode() or packet[-8:] != 'S.L.O.W.'.encode())): #confere as assinaturas de header e eop label = 170 if ((label == 0 or label == 131) and self.checksum(packet[0:-16]) != packet[-16:-8] ): #confere o checksum de header+payload contra o checksum no eop label = 151 if (label == 0 and self.getPayloadCounter(packet) != len(self.receivedPck)): print(self.getPayloadCounter(packet)) label = 222 dic = { 255: 'SYN', 240: 'ACK', 222: 'MISCOUNT', 170: 'MALFORMED', 151: 'CORRUPTED', 131: 'META', 85: 'TIMEOUT', 15: 'NACK', 0: 'DATA' } label = dic[label] print("Resultado do packet ouvido: " + label) self.rx.clearBufferUntilSignature('F.A.S.T.'.encode()) return (label, packet) def getMetaName(self, packet): trailingfilename = packet[16:16 + 512] filenamelength = int.from_bytes(packet[14:16], byteorder='big') filename = trailingfilename[0:filenamelength] return filename.decode( 'utf-8' ) #torcemos para que não tenhamos que nos preocupar algo que não utf-8 def getMetaPacketAmount(self, packet): return int.from_bytes(packet[11:14], byteorder='big') def getMetaThreshold(self, packet): return int.from_bytes(packet[9:11], byteorder='big') def getPayloadCounter(self, packet): return int.from_bytes(packet[11:14], byteorder='little') def collapseData(self): data = bytes(bytearray()) i = 0 while (i != len(self.receivedPck)): data += self.receivedPck[i][13:-16] print('azul ', self.getPayloadCounter(self.receivedPck[i])) i += 1 self.receivedPck = [] cut = (2**10 - self.getMetaThreshold(self.meta)) % (2**10) return data[:-cut] def sendPacket(self, label, number=0): time.sleep( 0.2 ) #pra dar tempo do outro se preparar pra receber, testar diminuir ou remover este valor depois print("Enviando packet tipo ", label) dic = { 'SYN': bytes([255]), 'ACK': bytes([240]), 'NACK': bytes([15]), 'META': bytes([131]), 'DATA': bytes([0]) } label = dic[label] if (label == bytes([255]) or label == bytes([240]) or label == bytes([15])): signature = 'F.A.S.T.'.encode() header = signature + label signature = 'S.L.O.W.'.encode() eop = signature packet = header + eop elif (label == bytes([131])): packet = self.meta elif (label == bytes([0])): packet = self.queuedPck[number] self.tx.sendBuffer(packet) def packageData(self, data, filename): self.queuedPck = [] #bytes do payload de cada packet: 2**10 payloadsize = 2**10 packetamount = ((len(data) - 1) // payloadsize) + 1 #TODO: editar o metadata para suportar mais packets por comunicação ##Fazer metadata #Para suportar o maior número possível de filesystems, suportaremos filenames de até 512 bytes #tamanho máximo de um arquivo transferido por uma sprint apenas, 4Gb = 2^32, 4 bytes signature = 'F.A.S.T.'.encode() label = bytes([131]) thresh = len(data) % payloadsize thresh = bytes([((thresh // 256) % 256), (thresh % 256)]) content = filename.encode() filenameSize = bytes([(((len(content) // 256) % 256)), (len(content) % 256)]) pckAmount = bytes([((packetamount // (256**2)) % 256), ((packetamount // 256) % 256), (packetamount % 256)]) header = signature + label + thresh + pckAmount + filenameSize content = content + bytes([0]) * (512 - len(content)) signature = 'S.L.O.W.'.encode() eop = self.checksum(header + content) + signature self.meta = (header + content + eop) #Fazer o packaging data += (((2**10) - (len(data) % 2**10)) % 2**10) * bytes([0]) #oh god counter = 0 while (counter != packetamount): thisdata = data[counter * (2**10):(counter + 1) * (2**10)] self.queuedPck.append(self.createPacket(thisdata, counter)) counter += 1 def createPacket(self, payload, counter): signature = 'F.A.S.T.'.encode() label = bytes([0]) #size= 2**10 #size do payload, constante para packets com payload size = bytes([0, 0]) #TODO: consertar counter = bytes([((counter // (256**2)) % 256), ((counter // 256) % 256), (counter % 256)]) header = signature + label + counter + size #14 bytes signature = 'S.L.O.W.'.encode() eop = self.checksum(header + payload) + signature #16 bytes return header + payload + eop def checksum(self, data): #Implementação nossa de um CRC-64 bits data = int.from_bytes(data, 'big') data = data * (2**64) #append com zeros while (data.bit_length() > 64): sumNum = 2**(data.bit_length() - 65) key = 18601846741563846107 #um int aleatoriamente selecionado de 65 bits powerkey = key * sumNum data ^= powerkey return bytes([(data // (256**7)) % 256, (data // (256**6)) % 256, (data // (256**5)) % 256, (data // (256**4)) % 256, (data // (256**3)) % 256, (data // (256**2)) % 256, (data // 256) % 256, data % 256])
class enlace(object): """ This class implements methods to the interface between Enlace and Application """ 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)
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) sync_package3 = self.tx.cria_package(payload, 3) print(sync_package) self.tx.sendBuffer(sync_package) timer = time.time() while not sync1: data, size = self.rx.getNData() payload, tipo, ok = 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 ") self.tx.sendBuffer(sync_package) print("Enviando tipo 1") timer = time.time() self.tx.sendBuffer(sync_package3) timer = time.time() while not sync2: data, size = self.rx.getNData() payload, tipo, ok = 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) sync_package40 = self.tx.cria_package(payload_nulo, 40) while not sync1: data, size = self.rx.getNData() payload, tipo, ok, = self.rx.desfaz_package(data) if tipo == 1 and ok: sync1 = True print("recebeu tipo 1") break self.tx.sendBuffer(sync_package2) timer = time.time() while not sync2: data, size = self.rx.getNData() payload, tipo, ok = 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 note received") self.tx.sendBuffer(sync_package2) print("mandou tipo 2") timer = time.time() self.tx.sendBuffer(sync_package40) def client_transmission(self, payload): payloadnulo = (0).to_bytes(1, byteorder="big") sync_package4 = self.tx.cria_package(payload, 4) self.tx.sendBuffer(sync_package4) sync1 = False timer = time.time() while not sync1: data, size = self.rx.getNData() payload, tipo, ok = 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 run_time = time.time() - timer if run_time > 5.0: print("Erro: type 5 or 6 not received") print("mandou tipo 4") 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) sync_package6 = self.tx.cria_package(payloadnulo, 6) sync1 = False while not sync1: data, size = self.rx.getNData() payload, tipo, ok = self.rx.desfaz_package(data) if tipo == 4 and ok: self.tx.sendBuffer(sync_package5) sync1 = True print("recebeu tipo 4 CORRETO, ENVIA 5") break elif tipo == 4 and not ok: self.tx.sendBuffer(sync_package6) print("Recebeu tipo 4 INCORRETO, Envia 6") return payload def client_encerramento(self): time.sleep(4) payloadnulo = (0).to_bytes(1, byteorder="big") sync_package7 = self.tx.cria_package(payloadnulo, 7) print("enviou tipo 7") self.tx.sendBuffer(sync_package7) def server_encerramento(self): encerra = False while not encerra: data, size = self.rx.getNData() payload, tipo, ok = self.rx.desfaz_package(data) if tipo == 7: print("recebeu tipo 7, conexao encerrada") break
class enlace(object): """ This class implements methods to the interface between Enlace and Application """ def __init__(self, name): """ Initializes the enlace class """ self.fisica = fisica(name) self.rx = RX(self.fisica) self.tx = TX(self.fisica) self.connected = False self.endes = endescapsulamento.Empacotamento() def enable(self): """ Enable reception and transmission """ self.fisica.open() self.rx.threadStart() self.tx.threadStart() def disable(self): """ Disable reception and transmission """ self.rx.threadKill() self.tx.threadKill() time.sleep(1) self.fisica.close() ################################ # Application interface # ################################ def sendData(self, data): """ Send data over the enlace interface """ # endes = endescapsulamento.Empacotamento() # packet = endes.buildDataPacket(data) self.tx.sendBuffer(data) def getData(self): """ Get n data over the enlace interface Return the byte array and the size of the buffer """ package = self.rx.searchForPacket() data = self.endes.unpackage(package) return (data) def receive(self): sync = False while sync == False: #iniciar timer para esperar um syn time.sleep(2) if self.rx.getBufferLen() != 0: print("recebi algo") packet = self.getData() packetType = getType.getType(packet) if packetType.getPacketType() == 'comando': if packetType.getCommandType() == 'SYN': print("é um syn") self.sendData(self.endes.buildAckPacket()) print("Enviando Ack") time.sleep(3) self.sendData(self.endes.buildSynPacket()) print("Enviando Syn") #outro timer esprando um ack do client time.sleep(2) packet2 = self.getData() if len(packet2) != 0: packetType2 = getType.getType(packet2) if packetType2.getPacketType() == 'comando': if packetType2.getCommandType() == 'ACK': print("Recebeu Ack") sync = True time.sleep(3) return True else: print("nao recebeu ultimo ack do server") continue else: print("server nao mandou ack") continue else: print( "nao recebeu nenhum ack do server, reiniciando" ) continue else: print("server nao mandou syn") continue else: print("nao recebeu") continue else: print("pacote vazio, procurar novamente") continue def conecta(self): sync = False while sync == False: time.sleep(1) synPacket = self.endes.buildSynPacket() self.sendData(synPacket) print("Mandando Syn") # start_receiving_time = time.time() # finished_receiving_time = time.time() - start_receiving_time time.sleep(2) # print("lenBuffer" + str(self.tx.getBufferLen())) #inicia timer esperando um ack e um syn bufferLen = self.rx.getBufferLen() if bufferLen != 0: packet = self.getData() packetType = getType.getType(packet) if packetType.getPacketType() == 'comando': if packetType.getCommandType() == 'ACK': print("Recebendo Ack") time.sleep(3) packet = self.getData() packetType = getType.getType(packet) if packetType.getPacketType() == 'comando': if packetType.getCommandType() == 'SYN': print('Recebendo Syn') #iniciar timer para esperar um SYN do server ackPacket = self.endes.buildAckPacket() # print(self.rx.buffer) self.sendData(ackPacket) print("Mandando Ack") # print(self.rx.buffer) sync = True time.sleep(2) return True else: print("nao recebeu SYN do server") continue else: print("nao recebeu ACK do server") continue else: print("nao é um comando") continue else: print("pacote vazio, reiniciando") def confirm_client(self): time.sleep(2) if self.rx.getBufferLen() != 0: packet = self.getData() if packet != 0: packetType = getType.getType(packet) if packetType.getPacketType() == 'comando': if packetType.getCommandType() == 'ACK': return True elif packetType.getCommandType() == 'NACK': print("Pacote não recebido, reenviando") # endes = endescapsulamento.Empacotamento() # packet = endes.buildDataPacket(txBuffer) # self.sendData(packet) return False else: print('Aguardando confirmação de recebimento de pacote') # sent = False # return True def confirm_server(self): received = False # while received == False: if self.rx.getBufferLen == 0: nackPacket = self.endes.buildNackPacket() self.sendData(nackPacket) return False else: # rxBuffer = self.getData() print("recebi pacote") ackPacket = self.endes.buildAckPacket() self.sendData(ackPacket) # received = True return True # break # received = False # return rxBuffer def parsePacket(self, payload): offset = 0 nPacotes = math.ceil(len(payload) / 2048) packetCounter = 0 while packetCounter < nPacotes: if (len(payload) - offset) >= 2048: pacote = self.endes.buildDataPacket( (payload[offset:offset + 2048]), packetCounter, nPacotes) print("Enviando pacote: " + str(packetCounter + 1) + "/" + str(nPacotes)) self.sendData(pacote) confirmacao = self.confirm_client() if confirmacao == True: print("Pacote: " + str(packetCounter + 1) + " de " + str(len(pacote) - 40) + " recebido") print("--------------------------") offset += 2048 packetCounter += 1 # time.sleep(2) else: continue else: pacote = self.endes.buildDataPacket((payload[offset:]), packetCounter, nPacotes) self.sendData(pacote) print("Enviando pacote: " + str(packetCounter + 1) + "/" + str(nPacotes)) confirmacao = self.confirm_client() if confirmacao == True: # print("confirmado") print("Pacote: " + str(packetCounter + 1) + " de " + str(len(pacote) - 40) + " bytes " + "recebido") print("--------------------------") # print(len(pacote)) packetCounter += 1 # time.sleep(2) else: continue def receive_packets(self): imagem = bytearray() n = 0 total = 1 while n < total: if self.rx.getBufferLen() != 0: pacote = self.rx.searchForPacket() # print("lenPacote " + str(len(pacote))) headParameters = self.endes.getHeadParameters(pacote) new_n = headParameters[0] + 1 total = headParameters[1] print("Recebendo pacote: " + str(new_n) + "/" + str(total)) # print("new_n " + str(new_n)) # print("Total " + str(total)) payload = self.endes.unpackage(pacote) data = payload[8:len(payload) - 8] crcClient = payload[0:8] # crcClient = self.endes.unpackage(pacote)[0:8] # crcClientPayload = self.endes.unpackage(pacote)[-8:0] crcClientPayload = payload[len(payload) - 8:] # pacotePayload = self.endes.unpackage(pacote)[14:len(pacote) - 8] # print("lenPacotePayload: " + str(len(pacotePayload))) key = self.endes.getKey() crcServer = self.endes.encodeData(str(pacote[0:6]), key) hexCrc = self.endes.stringToHex(crcServer) crcServerPayload = self.endes.encodeData(str(data), key) hexCrcPayload = self.endes.stringToHex(crcServerPayload) if hexCrc == crcClient: if hexCrcPayload == crcClientPayload: if (new_n != n): print("Pacote: " + str(new_n) + "/" + str(total) + " de " + str(len(payload) - 16) + " bytes " + "recebido") print("--------------------------") n = new_n ackPacket = self.endes.buildAckPacket() self.sendData(ackPacket) imagem += data time.sleep(2) else: print( "Pacote: " + str(new_n) + "/" + str(total) + " já foi recebido, aguardando próximo pacote") time.sleep(2) continue else: print("crc Payload não confere, mandar novamente") nackPacket = self.endes.buildNackPacket() self.sendData(nackPacket) time.sleep(2) continue else: print("crc Head não confere, mandar novamente") nackPacket = self.endes.buildNackPacket() self.sendData(nackPacket) time.sleep(2) continue else: nackPacket = self.endes.buildNackPacket() self.sendData(nackPacket) continue return imagem
class enlace(object): """ This class implements methods to the interface between Enlace and Application """ def __init__(self, name): """ Initializes the enlace class """ self.fisica = fisica(name) self.rx = RX(self.fisica) self.tx = TX(self.fisica) self.connected = False def enable(self): """ Enable reception and transmission """ self.fisica.open() self.rx.threadStart() self.tx.threadStart() def disable(self): """ Disable reception and transmission """ self.rx.threadKill() self.tx.threadKill() time.sleep(1) self.fisica.close() ################################ # Application interface # ################################ def sendData(self, data): """ Send data over the enlace interface """ #Construção do pack self.StructEop() self.StructHead() #Envio do arquivo pack = self.buildDataPacket(data) self.CalcularOverhead(pack, data) self.tx.sendBuffer(pack) def getData(self): """ Get n data over the enlace interface Return the byte array and the size of the buffer """ data, size = self.rx.unbuildDataPacket() return (data, len(data), size) #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) #Implementa o head def buildHead(self, dataLen): head = self.headStruct.build(dict(start=self.headStart, size=dataLen)) 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 def buildDataPacket(self, data): pack = self.buildHead(len(data)) print(len(data)) pack += data pack += self.buildEop() return pack def CalcularOverhead(self, pack, data): overhead = len(pack) / len(data) print("Overhead:", overhead) return overhead
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.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} 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: 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: #print(data) recievePack = data self.data, self.dataSize = self.rx.unpackage(recievePack) self.checkAcknoledgement(self.data, self.dataSize) return self.data, len(self.data), self.dataSize return data, len(data), payloadSize def findEOP(self, dados): EOPbytes = 129 EOPbytes = EOPbytes.to_bytes(4, byteorder="big") print("EOP: {}".format(EOPbytes)) achou = False for byte in dados: #print(byte) if byte == EOPbytes: achou = True print("EOPbytes encontrado no index {}".format( dados.index(byte))) if not achou: print("[ERRO] - EOPbytes NOT ENCONTRADO") print("Tamanho dos dados: {}".format(len(dados))) pass def clientSynch(self): while self.mensagemTipo2['recebida'] == False: # Cria pacote vazio com mensagem tipo 1 pack1 = self.tx.createPACKAGE(1) # Envia mensagem tipo 1 self.sendData(pack1) print("Mensagem tipo 1: Enviada") time.sleep(0.1) while self.mensagemTipo2[ 'recebida'] == False: # Acada segundos verifica se recebeu a mensagem tipo 2 data, size, payloadSize = 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) data, size, payloadSize = 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: data, size, payloadSize = self.getData(2) timeout = self.rx.timeout if timeout >= 5: print("[ERRO] - Não recebimento da mensagem tipo 3") return self.serverSynchComplete = True def clientSendFile(self, file): time.sleep(0.2) pack = self.tx.createPACKAGE(4, file) #print(pack) self.rx.unpackage(pack) self.sendData(pack) self.mensagemTipo4['enviada'] = True time.sleep(0.2) while self.mensagemTipo5['recebida'] == False: data, size, payloadSize = self.getData(4) timeout = self.rx.timeout if timeout >= 5: print("[ERRO] - Não recebimento da mensagem tipo 5 ou 6") return if self.mensagemTipo6["recebida"] == True: self.sendData(pack) print("Mensagem tipo 4 enviada novamente") def checkAcknoledgement(self, data, payloadSize): print("Len data: {} PayloadSize: {}".format(len(data), payloadSize)) if len(data) == payloadSize: mensagemTipo5 = self.tx.createPACKAGE(5) self.sendData(mensagemTipo5) self.mensagemTipo5['enviada'] = True print("Mensagem tipo 5 enviada") else: mensagemTipo6 = self.tx.createPACKAGE(6) self.sendData(mensagemTipo6) self.mensagemTipo5['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") 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 self.sendEndingMassage() 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() 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()
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 makePackages(self, msgType, filename, errorNumPackage): package = self.tx.createPackages(msgType, filename, errorNumPackage) return package def getData(self): """ Get n data over the enlace interface Return the byte array and the size of the buffer """ data = self.rx.getNData() return (data) def supposedTime(self, filesize): time = (filesize * 11 * 1024) / (self.fisica.baudrate) return time def receiveData(self): return self.rx.receivedData def getMsgType(self, data): return (self.rx.verifyMsgType(data)) def verifyFileIntegrity(self, data): return self.rx.verifyFileIntegrity(data) def getPackageNumber(self, data): return self.rx.getPackageNumber(data) def getNumberOfPackages(self, data): total = self.rx.getNumberOfPackages(data) return total def getPackageByNum(self, packageNum): return self.tx.getPackageByNum(packageNum) def getPayload(self, data): return self.rx.getPayload(data) def cleanStuffing(self, data): return self.rx.cleanStuffing(data) def getType8Addon(self, data): addon = self.rx.getType8Addon(data) return addon def crc16(self, data): return self.tx.crc16(data) def getCRCResult(self, data): return self.rx.getCRCResult(data)
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 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 """ 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.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()
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() def sendData(self, data): """ Send data over the enlace interface """ #Construção do Head self.StructEop() self.StructHead() #Encapuslamento do arquivo--> ENVIO pack = self.buildDataPacket(data) #Construção do EOP self.tx.sendBuffer(pack) def getData(self): """ Get n data over the enlace interface Return the byte array and the size of the buffer """ data, size = self.rx.unbuildDataPacket() return(data,len(data),size) #Estrutura Head def StructHead(self): self.headStart = 0xAA self.headStruct = Struct("start"/ Int16ub, "size"/ Int16ub) #Implementa o Head def buildHead(self, datalen): head = self.headStruct.build(dict(start = self.headStart, size = datalen)) return head #Estrutura EOP def StructEop(self): self.endStart = 0xFF self.endStruct = Struct("g1"/Int8ub, "g2"/Int8ub, "g3"/Int8ub,"g4"/Int8ub) #Implementa o EOP def buildEop(self): end = self.endStruct.build(dict(g1 = 0x21, g2 = 0x42, g3 = 0x63,g4 = 0x04)) return end def buildDataPacket(self, data): #Gerar Head pack = self.buildHead(len(data)) print(len(data)) # Printar o tamanho do arquivo (payload) #Concatenação do Header, payload e EOP pack += data pack += self.buildEop() return pack
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 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,atual=0): """ Send data over the enlace interface """ #print(data) pacote,quantidade,len_pays = self.tx.empacota(data,tipo) quantidade -= 1 #print("PACOTE QUE CHEGOU DO EMPACOTA") #print(pacote) print("######################################") print("VALOR DO ATUAL É {}".format(atual)) print("QUANTIDADE: {}".format(quantidade)) #print(pacote) if tipo == 4: if atual == 0: print('entrou 0') mensagem = pacote[:(8+len_pays[atual])] elif atual == quantidade: print('entrou quantidade') mensagem = pacote[(8+len_pays[atual-1]):] else: print('entrou resto') mensagem = pacote[(8+len_pays[atual-1]):(8+len_pays[atual])] else: mensagem = pacote self.tx.sendBuffer(mensagem) time.sleep(1) throughput = len(pacote)/self.fisica.tempo print("Mensagem a ser enviada") print(mensagem) 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))