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, 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): def __init__(self, name, baudrate): self.fisica = fisica(name, baudrate) 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): data = self.rx.getNData(size) return (data, len(data))
class enlace(object): """ This class implements methods to the interface between Enlace and Application """ def __init__(self, name): """ Initializes the enlace class """ self.fisica = fisica(name) self.rx = RX(self.fisica) self.tx = TX(self.fisica) self.connected = False self.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.fisica = fisica(name) self.rx = RX(self.fisica) self.tx = TX(self.fisica) self.connected = False def enable(self): """ Enable reception and transmission """ self.fisica.open() self.rx.threadStart() self.tx.threadStart() def disable(self): """ Disable reception and transmission """ self.rx.threadKill() self.tx.threadKill() time.sleep(1) self.fisica.close() ################################ # Application interface # ################################ def sendData(self, data): """ Send data over the enlace interface """ self.client_sync() self.client_transmission(data) self.client_encerramento() def getData(self): """ Get n data over the enlace interface Return the byte array and the size of the buffer """ print('entrou na leitura e tentara ler ') self.server_sync() payload = self.server_transmission() self.server_encerramento() return (payload, len(payload)) def client_sync(self): sync1 = False sync2 = False payload = (0).to_bytes(1, byteorder="big") sync_package = self.tx.cria_package(payload, 1, 0, 0, 0) sync_package3 = self.tx.cria_package(payload, 3, 0, 0, 0) print(sync_package) self.tx.sendBuffer(sync_package) timer = time.time() while not sync1: data, size = self.rx.getNData() payload, tipo, ok, n_pacote, total_pacotes, pacote_esperado = self.rx.desfaz_package( data) if tipo == 2 and ok: sync1 = True print("recebeu tipo 2") break run_time = time.time() - timer if run_time > 5: print("Error: not receive type 2 ---------> Reenviando tipo 1") self.tx.sendBuffer(sync_package) timer = time.time() self.tx.sendBuffer(sync_package3) timer = time.time() while not sync2: data, size = self.rx.getNData() payload, tipo, ok, n_pacote, total_pacotes, pacote_esperado = self.rx.desfaz_package( data) if tipo == 40 and ok: sync2 = True print("recebeu tipo 40") break run_time = time.time() - timer if run_time > 5.0: print("mandou tipo 3") self.tx.sendBuffer(sync_package3) timer = time.time() def server_sync(self): sync1 = False sync2 = False payload_nulo = (0).to_bytes(1, byteorder="big") sync_package2 = self.tx.cria_package(payload_nulo, 2, 0, 0, 0) sync_package40 = self.tx.cria_package(payload_nulo, 40, 0, 0, 0) while not sync1: data, size = self.rx.getNData() payload, tipo, ok, n_pacote, total_pacotes, pacote_esperado = self.rx.desfaz_package( data) if tipo == 1 and ok: sync1 = True print("recebeu tipo 1") break self.tx.sendBuffer(sync_package2) print("Enviou tipo 2") timer = time.time() while not sync2: data, size = self.rx.getNData() payload, tipo, ok, n_pacote, total_pacotes, pacote_esperado = self.rx.desfaz_package( data) if tipo == 3 and ok: sync2 = True print("recebeu tipo 3") break run_time = time.time() - timer if run_time > 5.0: print("Erro: Type 3 not received --------> Reenviando tipo 2") self.tx.sendBuffer(sync_package2) timer = time.time() self.tx.sendBuffer(sync_package40) def client_transmission(self, payload): payloadnulo = (0).to_bytes(1, byteorder="big") timer = time.time() lista_pacotes, total_pacotes = self.separa_pacotes(payload) for i in range(len(lista_pacotes)): sync_package4 = self.tx.cria_package(lista_pacotes[i], 4, i + 1, len(lista_pacotes), 0) self.tx.sendBuffer(sync_package4) print("Mandou o pacote {0}/{1}".format(i + 1, len(lista_pacotes))) while True: data, size = self.rx.getNData() payload, tipo, ok, n_pacote, n_total, pacote_esperado = self.rx.desfaz_package( data) if tipo == 5 and ok: sync1 = True print("recebeu tipo 5") break elif tipo == 6 and ok: self.tx.sendBuffer(sync_package4) print("recebeu tipo 6") timer = time.time elif tipo == 8 and ok: sync_package8 = self.tx.cria_package( lista_pacotes[pacote_esperado], 4, pacote_esperado, n_total, 0) self.tx.sendBuffer(sync_package8) run_time = time.time() - timer if run_time > 4: print( "Tipo 5 ou 6 NAO recebido ------> Reenviando tipo 4 | {0} / {1} Tamanho:{2} bytes" .format(i + 1, total_pacotes, len(lista_pacotes[i]))) self.tx.sendBuffer(sync_package4) timer = time.time() def server_transmission(self): payloadnulo = (0).to_bytes(1, byteorder="big") sync_package5 = self.tx.cria_package(payloadnulo, 5, 0, 0, 0) sync_package6 = self.tx.cria_package(payloadnulo, 6, 0, 0, 0) lista_fragmentada = [] pacote_davez = 1 while True: data, size = self.rx.getNData() payload, tipo, ok, n_pacote, total_pacotes, pacote_esperado = self.rx.desfaz_package( data) #if n_pacote != pacote_davez: # print("ERRO: Deveria ter recebido {0} e recebeu {1}".format(pacote_davez, n_pacote)) # while True: ## sync_package8 = self.tx.cria_package(payloadnulo, 8, 0, 0, pacote_davez) # self.tx.sendBuffer(sync_package8) if tipo == 4 and ok: if n_pacote != pacote_davez: print( "ERRO: Deveria ter recebido {0} e recebeu {1}".format( pacote_davez, n_pacote)) sync_package8 = self.tx.cria_package( payloadnulo, 8, 0, 0, pacote_davez) self.tx.sendBuffer(sync_package8) timer = time.time() while True: payload, tipo, ok, n_pacote, total_pacotes, pacote_esperado = self.rx.desfaz_package( data) if tipo == 4 and ok: break run_time = time.time() - timer if run_time > 5: self.tx.sendBuffer(sync_package8) pacote_davez += 1 lista_fragmentada.append(payload) self.tx.sendBuffer(sync_package5) sync1 = True print("recebeu tipo 4 | {0}/{1} CORRETO, ENVIA 5".format( n_pacote, total_pacotes)) if n_pacote == total_pacotes: break elif tipo == 4 and not ok: self.tx.sendBuffer(sync_package6) print("Recebeu tipo 4 INCORRETO, Envia 6") compilado = bytes.fromhex("FF") for fragment in lista_fragmentada: compilado += fragment compilado = compilado[1:] return compilado def client_encerramento(self): time.sleep(4) payloadnulo = (0).to_bytes(1, byteorder="big") sync_package7 = self.tx.cria_package(payloadnulo, 7, 0, 0, 0) print("enviou tipo 7") self.tx.sendBuffer(sync_package7) def server_encerramento(self): encerra = False package_arbitrario = bytes.fromhex("F5 A3 AA C3 C3 B5 B4") timer = time.time() while not encerra: data, size = self.rx.getNData() payload, tipo, ok, n_pacote, total_pacotes, pacote_esperado = self.rx.desfaz_package( data) if tipo == 7: print("recebeu tipo 7, conexao encerrada") break run_time = time.time() - timer if run_time > 10: break def separa_pacotes(self, data): lista_pacotes = [] while len(data) > 128: pacote = data[0:128] data = data[128:] lista_pacotes.append(pacote) if len(data) > 0: pacote = data lista_pacotes.append(pacote) return lista_pacotes, len(lista_pacotes)
class enlace(object): """ This class implements methods to the interface between Enlace and Application """ headSTART = 0xFF # 255 #super clever head start headStruct = Struct("start" / Int8ub, "size" / Int16ub, "SYN" / Int8ub, "ACK_NACK" / Int8ub, "P_size" / Int8ub, "P_total" / Int8ub, "CheckSum" / Int16ub, "CheckSum_head" / Int16ub) ackCode = 0x9d # 157 nackCode = 0x0e # 14 synCode = 0x01 # 1 fakeAck = 0x00 fakeSyn = 0x00 maximum_Package = 2048 # determina o tamanho maximo que um pacote pode ter (*8 pois precisa ser em bits) def __init__(self, name): """ Initializes the enlace class """ self.fisica = fisica(name) self.rx = RX(self.fisica) self.tx = TX(self.fisica) self.connected = False self.end = "s.t.o.p.".encode() def enable(self): """ Enable reception and transmission """ self.fisica.open() self.rx.threadStart() self.tx.threadStart() def disable(self): """ Disable reception and transmission """ self.rx.threadKill() self.tx.threadKill() time.sleep(1) self.fisica.close() def buildHead(self, dataLen): head = self.headStruct.build( dict(start=self.headSTART, size=dataLen, SYN=self.fakeSyn, ACK_NACK=self.fakeAck, P_size=0, P_total=0, CheckSum=0, CheckSum_head=0)) return (head) def buildSync(self, dataLen=0): head = self.headStruct.build( dict(start=self.headSTART, size=dataLen, SYN=self.synCode, ACK_NACK=self.fakeAck, P_size=0, P_total=0, CheckSum=0, CheckSum_head=0)) return (head) def buildACK_NACK(self, dataLen=0, deuCerto=False): if deuCerto == True: head = self.headStruct.build( dict(start=self.headSTART, size=dataLen, SYN=self.synCode, ACK_NACK=self.ackCode, P_size=0, P_total=0, CheckSum=0, CheckSum_head=0)) if deuCerto == False: head = self.headStruct.build( dict(start=self.headSTART, size=dataLen, SYN=self.synCode, ACK_NACK=self.nackCode, P_size=0, P_total=0, CheckSum=0, CheckSum_head=0)) return (head) def build_complete(self, dataLen, deuCerto, payload_len, total_payload_len, CheckSum_payload, CheckSum_head): head = self.headStruct.build( dict(start=self.headSTART, size=dataLen, SYN=self.synCode, ACK_NACK=self.ackCode, P_size=payload_len, P_total=total_payload_len, CheckSum=CheckSum_payload, CheckSum_head=CheckSum_head)) return (head) def getheadStart(self, file): head = file[0:11] container = self.headStruct.parse(head) return container["start"] def getSize(self, file): head = file[0:11] container = self.headStruct.parse(head) return container["size"] def getSYN(self, file): head = file[0:11] container = self.headStruct.parse(head) return container["SYN"] def getACK_NACK(self, file): head = file[0:11] container = self.headStruct.parse(head) return container["ACK_NACK"] def getP_size_total(self, file): head = file[0:11] container = self.headStruct.parse(head) return (container["P_size"], container["P_total"]) def CRC(self, data): # usando crc-16-IBM aka CRC-16 crc16 = crcmod.predefined.mkCrcFun("crc-16") CRC = (crc16(data)) #'print("CRC: ",CRC) return CRC def get_CRC(self, file): head = file[0:11] container = self.headStruct.parse(head) return (container["CheckSum"], container["CheckSum_head"]) def compare_CRC( self, file ): # função que retorna True Se o CRChead e CRCpayload estiverem certos crc16 = crcmod.predefined.mkCrcFun("crc-16") CheckSum, CheckSum_head = self.get_CRC(file) half_head = file[0:7] # parte do head sem CRC data, useless_trash = self.openPackage(file) if CheckSum == crc16(data) and CheckSum_head == crc16(half_head): return True else: return False def Compare_number_package( self, file): # compara se todos os pacotes foram recebidos P_size, P_total = self.getP_size_total(file) print("Compare debug: ", P_size, " ", P_total) if P_size == P_total: return True else: return False def DataSender(self, data): n = self.maximum_Package # tamanho maximo do pacote, so mudei de nome quantidade_partes = math.ceil( len(data) / n ) # acha a quantidade minima de partes que o pacote de ser dividido timeinit = time.time() print("Quantidade de partes necessarias : ", quantidade_partes) print("") print("Início do envio") print("") print("-------------------------") beginning = 0 end = n Parte_atual = 1 while Parte_atual <= quantidade_partes: # roda a quantidade de vezes minima #print(a[beginning:end]) payload = data[beginning:end] temp_head = self.build_complete(len(payload), True, Parte_atual, quantidade_partes, 0, 0) head_crc = self.CRC(temp_head[0:7]) # a parte do head sem o CRC payload_crc = self.CRC(payload) head = self.build_complete(len(payload), True, Parte_atual, quantidade_partes, payload_crc, head_crc) file = (head + payload + self.end) print("- Parte", Parte_atual, "de", quantidade_partes) self.tx.sendBuffer(file) timeout = time.time() while time.time() - timeout <= 1.5: ack_esperado = self.rx.getNData() if self.getheadStart(ack_esperado) == 255: if self.getACK_NACK(ack_esperado) == 157: print(" - Recebeu ACK") print("") beginning += n end += n Parte_atual += 1 break elif self.getACK_NACK(ack_esperado) == 14: print(" - Recebeu NACK") print(" - Reenviando pacote") print("") break if time.time() - timeout >= 3.0: print(" - TimeOut") print(" - Reenviando pacote") print("") time.sleep(0.05) timefim = time.time() print("") print("Tempo da transmissão:", timefim - timeinit, "segundos") def handshake_server(self): while True: if self.rx.getBufferLen() > 4: time_start_getData = time.time() data = self.rx.getNData() # receive syn if self.getSYN(data) == 1: print("Syn recebido, send ack + syn") time.sleep(0.1) ack_nack = self.buildACK_NACK(deuCerto=True) self.tx.sendBuffer(ack_nack + self.end) #ack + syn print(self.getACK_NACK(ack_nack)) self.rx.clearBuffer() data = self.rx.getNData() #receive ack if self.getACK_NACK(data) == 157: print("handshake completo") break ################################ # Application interface # ################################ def sendData(self, txLen, data): """ Send data over the enlace interface """ sync = (self.buildSync() + self.end) head = self.buildHead(txLen) time_inicio = time.time() while True: time.sleep(1) self.tx.sendBuffer(sync) self.rx.clearBuffer() print("Mandei o Sync :3") time_now = time.time() if (time_now - time_inicio) < 30.0: ack_syn = self.rx.getNData() if self.getheadStart(ack_syn) == 255: if self.getACK_NACK(ack_syn) == 157 and self.getSYN( ack_syn) == 1: print("Mandei o ACK :3") time.sleep(1) self.tx.sendBuffer( self.buildACK_NACK(deuCerto=True) + self.end) break elif (time_now - time_inicio) > 30.0: sys.exit() time.sleep(1) self.DataSender(data) def getData(self): """ Get n data over the enlace interface Return the byte array and the size of the buffer """ self.handshake_server() self.rx.clearBuffer() Complete_package = b"" Current_P_size = 1 while True: #pega um pacote data = self.rx.getNData() self.rx.clearBuffer() print(data) if self.getheadStart(data) == 255: # se achar o head do pacote payload, trash = self.openPackage(data) P_size, P_total = self.getP_size_total(data) print("P_size,Current_P_size : ", P_size, " ", Current_P_size) if self.compare_CRC(data): print("Payload : ", type(payload)) Complete_package += payload head = self.buildACK_NACK(deuCerto=True) print("mandei ack", head) self.tx.sendBuffer(head + self.end) Current_P_size += 1 if self.compare_CRC(data) == False: head = self.buildACK_NACK(deuCerto=False) print("A casa caiu, arquivo corrompido, mandado nack") self.tx.sendBuffer(head + self.end) if P_size == P_total: break #print("Meu debug: "+str(Complete_package)) data, head = self.openPackage(data) """ while True: # checa se os sizes batem if self.getSize(head) != len(data) : print("dataLen:",dataLen,"head size",self.getSize(head)) self.tx.sendBuffer(self.buildACK_NACK(deuCerto = False) + self.end) time.sleep(0.2) while True: #pega a data novamente data = self.rx.getNData() #self.rx.clearBuffer() if self.getheadStart(data)==255: break print("Meu debug: "+str(data)) data, head = self.openPackage(data) else: break """ #print("tempo de trasmição: ",time_start_getData - time.time()) return (Complete_package, len(Complete_package)) def addHead(self, txLen, txBuffer): return (self.buildHead(txLen) + txBuffer) def decrypHead(self, head): return (struct.unpack(self.headStruct, head)) def openPackage(self, file): head = file[0:11] file = file[11:-8] return (file, head)
class enlace(object): """ This class implements methods to the interface between Enlace and Application """ def __init__(self, name): """ Initializes the enlace class """ self.fisica = fisica(name) self.rx = RX(self.fisica) self.tx = TX(self.fisica) self.connected = False def enable(self): """ Enable reception and transmission """ self.fisica.open() self.rx.threadStart() self.tx.threadStart() def disable(self): """ Disable reception and transmission """ self.rx.threadKill() self.tx.threadKill() time.sleep(1) self.fisica.close() ################################ # Application interface # ################################ def calculaCRC(self, data): crc16_func = crcmod.mkCrcFun(0x104c1, initCrc=0, xorOut=0xFFFF) resto = crc16_func(data) print("RESTO = {}".format(resto)) return resto def sendData(self, data): """ Send data over the enlace interface """ dataslice=self.tx.slicedata(data) synch=self.synchClient() if synch: time.sleep(1) print("SERAO ENVIADOS {} PACOTES".format(len(dataslice))) for i in range(len(dataslice)): tipo_check = False time.sleep(1) while not tipo_check: # Envia tipo 4 time.sleep(1) print("##### ENVIANDO TIPO 4 #####") resto = self.calculaCRC(dataslice[i]) head = self.tx.makeHead(dataslice[i], 4, i, len(dataslice)-1, resto) self.tx.sendBuffer(dataslice[i], head) # Espera tipo 5/6 print("##### ESPERANDO TIPO 5/6 #####") data_1, check, numero, total, check_resto= self.rx.getNData() tipo = data_1[7] if tipo == 5: print("##### RECEBI TIPO 5 ######") tipo_check = True time.sleep(1) break if tipo == 6: print("##### RECEBI TIPO 6 ######") self.rx.clearBuffer() time.sleep(1) if tipo == 8: print("##### RECEBI TIPO 8 ######") self.rx.clearBuffer() time.sleep(1) if tipo == 9: print("##### RECEBI TIPO 9 ######") self.rx.clearBuffer() time.sleep(1) else: print("##### NAO RECEBI TIPO 5 OU 6 OU 8 OU 9######") self.rx.clearBuffer() time.sleep(1) print("##### ENVIANDO TIPO 7 #####") self.sendFiller(7) def sendFiller(self, tipo, esperado=0): fillerData = 0 fillerBuffer = fillerData.to_bytes(1, byteorder="big") if tipo == 8: head = self.tx.makeHead(fillerBuffer, tipo, 0, 0, esperado) else: head = self.tx.makeHead(fillerBuffer, tipo) self.tx.sendBuffer(fillerBuffer, head) def synchClient(self): tipo = 0 # Envia Tipo 1 self.sendFiller(1) print("##### TIPO 1 ENVIADO #####") # Recebe Tipo 2 data, check, numero, total, check_resto =self.rx.getNData() tipo=data[7] if tipo == 2: print("##### RECEBI TIPO 2 #####") # Envia Tipo 3 self.sendFiller(3) print("Tipo 3 enviado") return True else: print(" ###### Não recebi tipo 2 ######") return False def synchServer(self): # Recebe tipo 1 tipo = 0 data, check, numero, total, check_resto = self.rx.getNData() tipo=data[7] if tipo == 1: print("###### Recebi tipo 1 ######") # Envia tipo 2 self.sendFiller(2) print("Tipo 2 Enviado") data, check, numero, total, check_resto =self.rx.getNData() tipo=data[7] if tipo == 3: print("###### Recebi tipo 3 ######") return True else: print(" ###### Não recebi tipo 3 ######") return False else: print(" ###### Não recebi tipo 1 ######") return False def getData(self): """ Get n data over the enlace interface Return the byte array and the size of the buffer """ print('entrou na leitura e tentara ler ' ) dataList = [] count = -1 synch = self.synchServer() if synch: while True: tipo_check = False count += 1 while not tipo_check: time.sleep(1) print("##### ESPERANDO TIPO 4 #####") data, check_tamanho, numero, total, check_resto = self.rx.getNData() print("NUMERO = {}".format(numero)) print("COUNT = {}".format(count)) if count == numero: numCheck = True else: numCheck = False if check_tamanho and numCheck and check_resto: print("##### ENVIANDO TIPO 5 #####") time.sleep(1) self.sendFiller(5) tipo_check = True break elif check_tamanho and numCheck: if numCheck: print("##### ENVIANDO TIPO 6 #####") time.sleep(1) self.sendFiller(6) else: print("##### ENVIANDO TIPO 8 #####") time.sleep(1) self.sendFiller(8, count) else: print("##### ENVIANDO TIPO 9 #####") time.sleep(1) self.sendFiller(9) dataList.append(data) print("NUMERO = {}".format(numero)) print("TOTAL = {}".format(total)) if numero == total: break print("##### ESPERANDO TIPO 7 #####") time.sleep(1) data_7, check_tamanho, numero, total, check_resto = self.rx.getNData() tipo = data_7[7] if tipo == 7: print("##### RECEBI TIPO 7 #####") datafull = bytearray() print("RECEBI {} PACOTES".format(len(dataList))) for i in dataList: datafull = datafull + i return(datafull, len(data))
class enlace(object): """ This class implements methods to the interface between Enlace and Application """ def __init__(self, name): """ Initializes the enlace class """ self.tipo1 = bytearray("1", "ascii") self.tipo2 = bytearray("2", "ascii") self.tipo3 = bytearray("3", "ascii") self.tipo4 = bytearray("4", "ascii") self.fisica = fisica(name) self.rx = RX(self.fisica) self.tx = TX(self.fisica) self.connected = False def enable(self): """ Enable reception and transmission """ self.fisica.open() self.rx.threadStart() self.tx.threadStart() def disable(self): """ Disable reception and transmission """ self.rx.threadKill() self.tx.threadKill() time.sleep(1) self.fisica.close() ################################ # Application interface # ################################ def sendData(self, lista_pacotes): """ Send data over the enlace interface """ for i in range(len(lista_pacotes)): self.tx.sendBuffer(lista_pacotes[i]) print("Pacote: ", i + 1, "de", len(lista_pacotes)) time.sleep(1) def getData(self): """ Get n data over the enlace interface Return the byte array and the size of the buffer """ print('entrou na leitura e tentara ler ') data, overhead, pacote_esperado = self.rx.getNData() self.rx.clearBuffer() return (data, len(data), overhead, pacote_esperado) def Synch_Client(self): #Etapa 1 print("Synching1") txLen1 = len(self.tipo1) package = self.tx.organize_package(txLen1, self.tipo1, 1) self.sendData(package) while (True): timeout = time.time() + 5 received, nRx, overhead, pacote_esperado = self.getData() if received == self.tipo2: txLen3 = len(self.tipo3) package = self.tx.organize_package(txLen3, self.tipo3, 3) self.sendData(package) print("Synching2") print("Synching Done") self.rx.clearBuffer() time.sleep(1) return True elif time.time() > timeout: print("Timeout") return False def Synch_Server(self): timeout = time.time() + 5 #Etapa 1 print("Synching1") txLen2 = len(self.tipo2) while (True): received, nRx, overhead, pacote_esperado = self.getData() if (received == self.tipo1): package = self.tx.organize_package(txLen2, self.tipo2, 2) self.sendData(package) print("Synching2") while (True): timeout = time.time() + 5 received, nRx, overhead, pacote_esperado = self.getData() if (received == self.tipo3): print("Synching Done") self.rx.clearBuffer() return True elif time.time() > timeout: print("Timeout") break elif (time.time() > timeout): print("Timeout") break return False
class enlace(object): """ This class implements methods to the interface between Enlace and Application """ def __init__(self, name): """ Initializes the enlace class """ self.fisica = fisica(name) self.rx = RX(self.fisica) self.tx = TX(self.fisica) self.connected = False 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 """ 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.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))
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 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 """ tipo = 1 data0 = bytes(1) print("data", data0) dataR = data resposta = False while not resposta: if tipo == 1: self.tx.sendBuffer(data0, 1) data, tipobyte = self.rx.getNData() tipo = int.from_bytes(tipobyte, byteorder="big") print("tipo 1") if tipo == 2: print("tipo 2") self.tx.sendBuffer(data0, 3) resposta = True time.sleep(1) resposta = False while not resposta: self.tx.sendBuffer(dataR, 4) data, tipo = self.rx.getNData() tipo = int.from_bytes(tipo, byteorder="big") if tipo == 5: print("Mensagem enviada corretamente") print("Tipo 5") tipo = 7 resposta = True if tipo == 6: print("Erro na mensagem - tipo 6") print("Reiniciando") 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) ) resposta = False while not resposta: data, tipo = self.rx.getNData() tipo = int.from_bytes(tipo, byteorder="big") if tipo == 1: self.tx.sendBuffer(data, 2) if tipo == 3: resposta = True resposta = False while not resposta: data, tipo = self.rx.getNData() if tipo == 5: self.tx.sendBuffer(data, 5) print("Mensagem recebida corretamente") resposta = True if tipo == 6: self.tx.sendBuffer(data, 6) print("Erro na mensagem - tipo 6") return (data, len(data))