def init_comm(self):
try:
print("-------------------------")
print("Server Started")
print("-------------------------")
# Declaramos um objeto do tipo enlace com o nome "com". Essa é a camada inferior à aplicação. Observe que um parametro
# para declarar esse objeto é o nome da porta.
self.STX = enlace(self.comTX, self.Baud_Rate)
self.SRX = enlace(self.comRX, self.Baud_Rate)
# Ativa comunicacao. Inicia os threads e a comunicação serial
self.STX.enable()
self.SRX.enable()
# Se chegamos até aqui, a comunicação foi aberta com sucesso. Faça um print para informar.
server_init_msg1 = "Server TX iniciado na porta: {}.".format(
self.comTX)
server_init_msg2 = "Server RX iniciado na porta: {}.".format(
self.comRX)
print(server_init_msg1)
print(server_init_msg2)
print("-------------------------")
return ([server_init_msg1, server_init_msg2])
except Exception as erro:
print("ops! :-\\")
print(erro)
self.STX.disable()
self.SRX.disable()
def main():
# Inicializa enlace ... variavel com possui todos os metodos e propriedades do enlace, que funciona em threading
com = enlace(serialName)
com2 = enlace(serialName2)
# Ativa comunicacao
com.enable()
# Endereco da imagem a ser transmitida
imageR = "./imgs/imageC.png"
# Endereco da imagem a ser salva
imageW = "./imgs/recebidaTeste.png"
def main():
# Inicializa enlace ... variavel com possui todos os metodos e propriedades do enlace, que funciona em threading
com = enlace(serialName)
# Ativa comunicacao
com.enable()
#verificar que a comunicação foi aberta
print("Comunicação aberta")
print('--------------------')
# a seguir ha um exemplo de dados sendo carregado para transmissao
# voce pode criar o seu carregando os dados de uma imagem. Tente descobrir
#como fazer isso
# print ("gerando dados para transmissao :")
# Atualiza dados da transmissão
txSize = com.tx.getStatus()
data_null = (0).to_bytes(4, byteorder="big")
rxBuffer = com.comunicacao(data_null, "server")
nRx = len(rxBuffer)
x = open('NovaImg.png', 'wb')
x.write(rxBuffer)
x.close()
# log
#print ("Lido {0} bytes ".format(nRx))
#print("Tempo esperado: {0} segundos ".format(tempo_teorico(nRx,baudrate)))
# Encerra comunicação
print("-------------------------")
print("Comunicação encerrada")
print("-------------------------")
com.disable()
def main():
# Inicializa enlace ... variavel com possui todos os metodos e propriedades do enlace, que funciona em threading
com = enlace(serialName) # repare que o metodo construtor recebe um string (nome)
# Ativa comunicacao
com.enable()
com.rx.clearBuffer()
# Log
print("-------------------------")
print("Comunicação inicializada")
print(" porta : {}".format(com.fisica.name))
print("-------------------------")
# Carrega dados
print ("gerando dados para transmissao :")
tempo = time.time()
#txBuffer, tamanho, overhead, tamanho_total = forma_envio()
forma_envio(com)
tempo2 = time.time() - tempo
print("Tempo:", tempo2, "segundos")
# Encerra comunicação
print("-------------------------")
print("Comunicação encerrada")
print("-------------------------")
com.disable()
def main():
# Inicializa enlace ... variavel com possui todos os metodos e propriedades do enlace, que funciona em threading
com = enlace(serialName)
# Ativa comunicacao
com.enable()
#verificar que a comunicação foi aberta
print("comunicação aberta")
# a seguir ha um exemplo de dados sendo carregado para transmissao
# voce pode criar o seu carregando os dados de uma imagem. Tente descobrir
#como fazer isso
# Faz a recepção dos dados
print ("Recebendo dados .... ")
while not com.rx.getIsEmpty:
pass
rxBuffer = com.rx.getNData()
# Criando imagem nova
print ("Testando rxbuffer...")
print (rxBuffer)
# Encerra comunicação
print("-------------------------")
print("Comunicação encerrada")
print("-------------------------")
com.disable()
def main():
# Inicializa enlace ... variavel com possui todos os metodos e propriedades do enlace, que funciona em threading
com = enlace(serialName)
# Ativa comunicacao
com.enable()
# Log
print("-------------------------")
print("Inicializando comunicação")
print("porta : {}".format(com.fisica.name))
print("-------------------------")
rxBuffer, rxLen = com.getData(8)
# Transmite dado
print("Transmitindo {} bytes".format(rxLen))
com.sendData(rxLen)
# espera o fim da transmissão
while (com.tx.getIsBussy()):
txSize = com.tx.getStatus()
print("Transmitido {} bytes ".format(txSize))
# Encerra comunicação
print("-------------------------")
print("Comunicação encerrada")
print("-------------------------")
com.disable()
def main():
img = Image.open('dragon.jpg', mode='r')
imgByteArr = io.BytesIO()
img.save(imgByteArr, format='JPEG')
imgByteArr = imgByteArr.getvalue()
# Inicializa enlace ... variavel com possui todos os metodos e propriedades do enlace, que funciona em threading
com = enlace(serialName)
# Ativa comunicacao
com.enable()
#verificar que a comunicação foi aberta
print("comunicação aberta")
# a seguir ha um exemplo de dados sendo carregado para transmissao
# voce pode criar o seu carregando os dados de uma imagem. Tente descobrir
#como fazer isso
print ("gerando dados para transmissao :")
txBuffer = imgByteArr
txLen = len(txBuffer)
print(txLen)
# Transmite dado
print("tentado transmitir .... {} bytes".format(txLen))
com.sendData(txBuffer)
# Atualiza dados da transmissão
txSize = com.tx.getStatus()
# Faz a recepção dos dados
print ("Recebendo dados .... ")
bytesSeremLidos=com.rx.getBufferLen()
rxBuffer, nRx = com.getData(txLen)
# log
print ("Lido {} bytes ".format(nRx))
print (rxBuffer)
print(len(rxBuffer))
# Encerra comunicação
print("-------------------------")
print("Comunicação encerrada")
print("-------------------------")
com.disable()
rxBuff = io.BytesIO(rxBuffer)
img = Image.open(rxBuff)
draw = ImageDraw.Draw(img)
img.save('/home/francisco/Documentos/Insper /Semestre4/Camada Física da Computação/Aula01/SalvarArquivo/ImagemEnviadaFinal.jpg')
def main():
# Inicializa enlace ... variavel com possui todos os metodos e propriedades do enlace, que funciona em threading
com = enlace(
serialName) # repare que o metodo construtor recebe um string (nome)
# Ativa comunicacao
com.enable()
# if s_or_r == "r":
dataLen, aa_ = com.getData(5)
# print(int.from_bytes(dataLen, "big"))
com.sendData(dataLen)
dataLen_int = int.from_bytes(dataLen, "big")
print(dataLen_int)
image, imageLen = com.getData(dataLen_int)
imageLen_bytes = imageLen.to_bytes(5, "big")
com.sendData(imageLen_bytes)
with open("ULTRAbatata.jpg", "wb") as foto:
foto.write(image)
# Encerra comunicação
print("-------------------------")
print("Comunicação encerrada")
print("-------------------------")
com.disable()
def main():
# Inicializa enlace ... variavel com possui todos os metodos e propriedades do enlace, que funciona em threading
com = enlace(serialName)
# Ativa comunicacao
com.enable()
com.rx.clearBuffer()
#verificar que a comunicação foi aberta
print("comunicação aberta")
# Atualiza dados da transmissão
# txSize = com.tx.getStatus()
# Faz a recepção dos dados
print("-------------------------------")
print("-----Começou o server Synch----")
com.serverSynch()
print("----Terminou o server Synch----")
print("-------------------------------")
# Faz a recepção dos dados
print("Recebendo dados... ")
while com.mensagemTipo7['recebida'] == False:
time.sleep(0.2)
com.getData()
print("-------------------------------")
print("----Terminou a transmissão----")
print("-------------------------------")
file = b''.join(com.file)
print("Lido {} bytes ".format(len(file)))
newFile = open("novoarquivo.jpg", "wb")
newFile.write(file)
newFile.close()
def main(fileName):
# Inicializa enlace ... variavel com possui todos os metodos e propriedades do enlace, que funciona em threading
com = enlace(serialName)
# Ativa comunicacao
com.enable()
com.rx.clearBuffer()
#verificar que a comunicação foi aberta
print("comunicação aberta")
# Faz a etapa Synch do client
print("-------------------------------")
print("-----Começou o client Synch----")
com.clientSynch()
print("----Terminou o client Synch----")
print("-------------------------------")
img = open(imgName, "rb").read()
#print(img)
imgLen = len(img)
sub_pack = com.splitPack(img)
# Transmite dado
print("tentado transmitir .... {} bytes".format(imgLen))
time.sleep(0.3)
com.clientSendPackages(sub_pack)
print("----Terminou a transmissão----")
print("-------------------------------")
def main():
# Inicializa enlace ... variavel com possui todos os metodos e propriedades do enlace, que funciona em threading
com = enlace(serialName)
# Ativa comunicacao
com.enable()
#verificar que a comunicação foi aberta
print("comunicação aberta")
# a seguir ha um exemplo de dados sendo carregado para transmissao
# voce pode criar o seu carregando os dados de uma imagem. Tente descobrir
#como fazer isso
print("gerando dados para transmissao :")
'''
teste
ListTxBuffer =list()
for x in range(0,20):
ListTxBuffer.append(x)
txBuffer = bytes(ListTxBuffer)
txLen = len(txBuffer)
print(txLen)
'''
# Enviando imagem para arduino
with open(findimg, "rb") as imageFile:
baby = imageFile.read()
txBuffer = bytearray(baby)
txLen = len(txBuffer)
# Transmite dado
print("tentado transmitir .... {} bytes".format(txLen))
com.sendData(txBuffer)
# Atualiza dados da transmissão
txSize = com.tx.getStatus()
# Faz a recepção dos dados
print("Recebendo dados .... ")
bytesSeremLidos = com.rx.getBufferLen()
rxBuffer, nRx = com.getData(txLen)
# log
print("Lido {} bytes ".format(nRx))
print(rxBuffer)
# Le a imagem retornada do loop
new = open("imagens/newimg.jpg", "wb")
new.write(rxBuffer)
new.close()
# Encerra comunicação
print("-------------------------")
print("Comunicação encerrada")
print("-------------------------")
com.disable()
def main():
try:
com2 = enlace('COM2') #Arduino 2
com2.enable()
imageW = "recebidaCopia.png"
#Recebe o tamanho da imagem
print("Recebendo o tamanho da imagem...")
image_size_bytes, nRx = com2.getData(4)
print("Tamanho em bytes: ", image_size_bytes)
image_size_int = int.from_bytes(image_size_bytes, byteorder='big')
print("Tamanho em inteiros: ", image_size_int)
print("-------------------------------------")
print("Recebendo a imagem...")
rxBuffer, nRxServer = com2.getData(image_size_int)
sizeServer = nRxServer
sizeServerBytes = nRxServer.to_bytes(4, byteorder='big')
com2.sendData(sizeServerBytes)
f = open(imageW, 'wb')
f.write(rxBuffer)
f.close()
time.sleep(0.1)
print("-------------------------------------")
print("Comunicação encerrada")
print("-------------------------------------")
com2.disable()
except:
print("ops! :-\\")
com2.disable()
def __init__(self, port):
self.com = enlace(port)
try:
print("---------------")
print("Começou com: {}".format(port))
print("---------------")
self.com.enable()
time.sleep(2)
except:
print("Porta Errada")
self.bytecode = None
self.head = None
self.eopIn = [0, 5, 0, 7, 0, 8, 0, 9, 0]
self.eop = [5, 7, 8, 9]
self.port = port
self.all = None
self.start_time = None
self.position = 0
self.download = None
self.eopState = False
self.bytesVsHeadState = False
self.CurrentPackage = None
self.AllPackages = None
self.AllFile = None
self.final_time = None
def __init__(self):
self.serialName = "/dev/ttyACM0"
self.com = enlace(self.serialName)
self.com.enable()
print("-------------------------")
print("Comunicação inicializada")
print(" porta : {}".format(self.com.fisica.name))
print("-------------------------")
self.headLenght = 12
self.eopLenght = 3
self.eop = b'\xff\xd8\xff'
self.packagesReceived = list()
self.packagesWithoutBS = list()
self.firstPackage = True
self.nPackagesNumber = 0
self.lazy = True
self.callerID = 0
self.headMessageType = 0
self.counter = 0
self.numberOfPackages = 0
self.timer1Start = 0
self.timer2Start = 0
self.timer1End = 0
self.timer2End = 0
self.packageIndex = 0
self.crcReceived = 0
self.setLog()
def main():
# Inicializa enlace ... variavel com possui todos os metodos e propriedades do enlace, que funciona em threading
com = enlace(serialName)
# Ativa comunicacao
com.enable()
#verificar que a comunicação foi aberta
print("comunicação aberta")
# Atualiza dados da transmissão
txSize = com.tx.getStatus()
# Faz a recepção dos dados
print("Recebendo dados .... ")
bytesSeremLidos = com.rx.getBufferLen()
rxBuffer, nRx = com.getData()
with open("recebida", "wb+") as imageFile:
imagemrecebida = imageFile.write(rxBuffer)
# log
print("Lido {} bytes ".format(nRx))
print(rxBuffer)
# Encerra comunicação
print("-------------------------")
print("Comunicação encerrada")
print("-------------------------")
com.disable()
def __init__(self, serialName):
self.serialName = serialName
self.com = enlace(serialName)
self.com.enable()
self.eop = (78).to_bytes(4, byteorder="big")
self.complete_payload = b""
self.lastPackage = -1
def main():
com = enlace(
serialName) # repare que o metodo construtor recebe um string (nome)
# Ativa comunicacao
com.enable()
print("Comunicação inicializada")
txSize = com.tx.getStatus()
txLen, nRxLen = com.getData(3)
txLen = int.from_bytes(txLen, 'big')
rxBuffer, nRx = com.getData(txLen)
com.sendData(nRx.to_bytes(3, "big"))
with open("received_image" + str(testNumber) + ".png", "wb") as image:
image.write(rxBuffer)
# Encerra comunicação
print("-------------------------")
print("Comunicação encerrada")
print("-------------------------")
com.disable()
def send(filename="sent_image.png"):
com = enlace(serialName)
com.enable()
print("comunicação aberta")
print("gerando dados para transmissao :")
ListTxBuffer = list()
with open(filename, "rb") as imageFile:
f = imageFile.read()
txBuffer = bytearray(f)
txLen = len(txBuffer)
tempo_teorico = str((txLen * 10) / (com.fisica.baudrate))
print("Tempo teorico: " + tempo_teorico + " segundos")
print("tentado transmitir .... {} bytes".format(txLen))
com.sendData(txBuffer)
txSize = com.tx.getStatus()
print("-------------------------")
print("Comunicação TX encerrada")
print("-------------------------")
com.disable()
def main():
try:
com1 = enlace(serialName)
com1.enable()
imagem = open(imageR, 'rb').read()
lista_payload = divide_pacotes(imagem)
for i in lista_payload:
print(i, "\n")
lista_pacotes = cria_pacotes(lista_payload)
for pacotes in lista_pacotes:
print(pacotes, "\n")
print(len(pacotes))
handshake = cria_handshake(len(lista_payload))
print(f"ESSE É O HANDSHAKE: {handshake}")
# Encerra comunicação
print("-------------------------")
print("Comunicação encerrada")
print("-------------------------")
com1.disable()
except Exception as erro:
print("ops! :-\\")
print(erro)
com1.disable()
def receiveInfo():
# Inicializa enlace ... variavel com possui todos os metodos e propriedades do enlace, que funciona em threading
com = enlace(serialName)
# Ativa comunicacao
com.enable()
#verificar que a comunicação foi aberta
print("comunicaçao aberta")
# Faz a recepção dos dados
print("Recebendo dados .... ")
bytesSeremLidos = com.rx.getBufferLen()
rxBuffer = com.getData()
# log
# print ("Lido {} bytes ".format(nRx))
# rxBuffer= list(rxBuffer)
# print ("rxbuffer",rxBuffer)
# print(f"Tamanho da imagem: {nRx} bytes")
# print(f"Tempo suposto de envio: {com.supposedTime(nRx)} ms")
with open("./ImageRecebida.jpg", "wb") as f:
f.write(rxBuffer)
# Encerra comunicação
print("-------------------------")
print("Comunicaçao encerrada")
print("-------------------------")
com.disable()
def main():
# Inicializa enlace ... variavel com possui todos os metodos e propriedades do enlace, que funciona em threading
com = enlace(serialName)
# Ativa comunicacao
com.enable()
# Faz a recepção dos dados
print("Recebendo dados .... ")
rxBuffer, nRx = com.getData()
print("Tempo estimado: " +
str(((nRx * 10 * 2) + 10 + 3) / com.fisica.baudrate) + " segundos.")
# log
print("Lido {} bytes ".format(nRx))
'''img = open('MEC.jpg', 'wb')
img.write(bytearray(rxBuffer))
img.close()'''
print(rxBuffer)
# Encerra comunicação
print("-------------------------")
print("Comunicação encerrada")
print("-------------------------")
com.disable()
def main():
# Inicializa enlace ... variavel com possui todos os metodos e propriedades do enlace, que funciona em threading
com = enlace(serialName)
# Ativa comunicacao
com.enable()
#verificar que a comunicação foi aberta
print("comunicação aberta")
# a seguir ha um exemplo de dados sendo carregado para transmissao
# voce pode criar o seu carregando os dados de uma imagem. Tente descobrir
#como fazer isso
print ("gerando dados para transmissao :")
ListTxBuffer =list()
#for x in range(0,20):
# ListTxBuffer.append(x)
#txBuffer = bytes(ListTxBuffer)
with open("cat-icon.png", "rb") as imageFile:
f = imageFile.read()
txBuffer = bytearray(f)
txLen = len(txBuffer)
print(txLen)
# Transmite dado
print("tentado transmitir .... {} bytes".format(txLen))
com.sendData(txBuffer)
# Atualiza dados da transmissão
txSize = com.tx.getStatus()
# Faz a recepção dos dados
print ("Recebendo dados .... ")
bytesSeremLidos=com.rx.getBufferLen()
rxBuffer, nRx = com.getData(txLen)
# log
print ("Lido {} bytes ".format(nRx))
#print (rxBuffer)
with open("cat-icon-received.png", "wb") as imageFile2:
f_image = imageFile2.write(rxBuffer)
# Encerra comunicação
print("-------------------------")
print("Comunicação encerrada")
print("-------------------------")
com.disable()
def main():
# Inicializa enlace ... variavel com possui todos os metodos e propriedades do enlace, que funciona em threading
com = enlace(
serialName) # repare que o metodo construtor recebe um string (nome)
# Ativa comunicacao
com.enable()
# Log
print("-------------------------")
print("Comunicação inicializada")
print(" porta : {}".format(com.fisica.name))
print("-------------------------")
# Carrega dados
print("gerando dados para transmissao :")
#no exemplo estamos gerando uma lista de bytes ou dois bytes concatenados
imagem = input("Nome do arquivo: ")
with open(imagem, "rb") as image:
f = image.read()
imgBytes = bytearray(f)
imgSize = bytes(str(len(imgBytes)), "UTF-8")
txBuffer = imgSize + bytearray(b"end") + imgBytes
#print(txBuffer)
txLen = len(txBuffer)
print(txLen)
# Transmite dado
print("tentado transmitir .... {} bytes".format(txLen))
start = time.time()
com.sendData(txBuffer)
#espera o fim da transmissão
while (com.tx.getIsBussy()):
pass
# Atualiza dados da transmissão
txSize = com.tx.getStatus()
print("Transmitido {} bytes ".format(txSize))
rxBuffer2, nRx2 = com.getData(len(imgSize))
if nRx2 == len(imgSize):
print("Igual")
end = time.time()
delta = end - start
taxa = len(imgBytes) / delta
print("Tempo: {} s".format(delta))
print("Bytes por segundo: {} b/s".format(taxa))
# Encerra comunicação
print("-------------------------")
print("Comunicação encerrada")
print("-------------------------")
com.disable()
def __init__(self, path):
self.com1 = enlace(serialName)
self.com1.enable()
self.img_array = open_image(path)
self.l_bytes_img = separate_packages(self.img_array)
self.l_packages = []
self.str_log = ''
self.start_execution_time = 0
def main():
try:
#declaramos um objeto do tipo enlace com o nome "com". Essa é a camada inferior à aplicação. Observe que um parametro
#para declarar esse objeto é o nome da porta.
com1 = enlace(serialName)
# Ativa comunicacao. Inicia os threads e a comunicação seiral
com1.enable()
#Se chegamos até aqui, a comunicação foi aberta com sucesso. Faça um print para informar.
print('A comunicação foi aberta com sucesso!')
#aqui você deverá gerar os dados a serem transmitidos.
#seus dados a serem transmitidos são uma lista de bytes a serem transmitidos. Gere esta lista com o
#nome de txBuffer. Esla sempre irá armazenar os dados a serem enviados.
#txBuffer = imagem em bytes!
#faça aqui uma conferência do tamanho do seu txBuffer, ou seja, quantos bytes serão enviados.
#finalmente vamos transmitir os tados. Para isso usamos a funçao sendData que é um método da camada enlace.
#faça um print para avisar que a transmissão vai começar.
print('A transmição vai começar')
#tente entender como o método send funciona!
#Cuidado! Apenas trasmitimos arrays de bytes! Nao listas!
txBuffer = open(imageR, 'rb').read()
com1.sendData(np.asarray(txBuffer))
# A camada enlace possui uma camada inferior, TX possui um método para conhecermos o status da transmissão
# Tente entender como esse método funciona e o que ele retorna
txSize = com1.tx.getStatus()
#Agora vamos iniciar a recepção dos dados. Se algo chegou ao RX, deve estar automaticamente guardado
#Observe o que faz a rotina dentro do thread RX
#print um aviso de que a recepção vai começar.
print('A recepção vai começar')
#Será que todos os bytes enviados estão realmente guardadas? Será que conseguimos verificar?
#Veja o que faz a funcao do enlaceRX getBufferLen
#acesso aos bytes recebidos
txLen = len(txBuffer)
rxBuffer, nRx = com1.getData(txLen)
print("recebeu {}".format(rxBuffer))
print('Salvando dados dos arquivos: ')
f = open(imageW, 'wb')
f.write(rxBuffer)
# Encerra comunicação
print("-------------------------")
print("Comunicação encerrada")
print("-------------------------")
com1.disable()
except Exception as erro:
print("ops! :-\\")
print(erro)
com1.disable()
def main():
# Inicializa enlace
com = enlace(serialName)
# Ativa comunicacao
com.enable()
# Endereco da imagem a ser transmitida
# imageR = "./imgs/imageE.png"
# Endereco da imagem a ser salva
imageW = "./imgs/recebida.png"
# Log
print("-------------------------")
print("Comunicação inicializada")
print(" porta : {}".format(com.fisica.name))
print("-------------------------")
#txLen = 3093
# Faz a recepção dos dados
print("Recebendo dados .... ")
if com.waitConnection():
time.sleep(12)
response = com.getData()
rxBuffer, nRx, real_nRx, package_type = response
while package_type != "data":
response = com.getData()
rxBuffer, nRx, real_nRx, package_type = response
inicio = time.time()
print("Data received")
print(rxBuffer)
# lost_b= int(nRx) - int(real_nRx)
fim = time.time()
# print ("Lido {} bytes ".format(int(nRx)))
# Salva imagem recebida em arquivo
print("-------------------------")
print("Salvando dados no arquivo :")
print(" - {}".format(imageW))
f = open(imageW, 'wb')
f.write(
rxBuffer
) # Fecha arquivo de imagem f.close() print("Tempo de recepção: {}".format(fim - inicio)) # Encerra comunicação print("-------------------------")
print("Comunicação encerrada")
print("-------------------------")
com.disable()
return "Received"
else:
return "Error"
f.close()
print("-------------------------")
print("Comunicação encerrada")
print("-------------------------")
com.disable()
def main():
# Inicializa enlace ... variavel com possui todos os metodos e propriedades do enlace, que funciona em threading
com = enlace(
serialName) # repare que o metodo construtor recebe um string (nome)
# Ativa comunicacao
com.enable()
# Log
print("-------------------------")
print("Comunicação inicializada")
print(" porta : {}".format(com.fisica.name))
print("-------------------------")
# Carrega dados
print("gerando dados para transmissao :")
#no exemplo estamos gerando uma lista de bytes ou dois bytes concatenados
#exemplo 1
#ListTxBuffer =list()
#for x in range(1,10):
# ListTxBuffer.append(x)
#txBuffer = bytes(ListTxBuffer)
#exemplo2
txBuffer = bytes([2]) + bytes([3]) + bytes("teste", 'utf-8')
txLen = len(txBuffer)
print(txLen)
# Transmite dado
print("tentado transmitir .... {} bytes".format(txLen))
com.sendData(txBuffer)
# espera o fim da transmissão
#while(com.tx.getIsBussy()):
# pass
# Atualiza dados da transmissão
txSize = com.tx.getStatus()
print("Transmitido {} bytes ".format(txSize))
# Faz a recepção dos dados
print("Recebendo dados .... ")
#repare que o tamanho da mensagem a ser lida é conhecida!
rxBuffer, nRx = com.getData(txLen)
# log
print("Lido {} bytes ".format(nRx))
print(rxBuffer)
# Encerra comunicação
print("-------------------------")
print("Comunicação encerrada")
print("-------------------------")
com.disable()
def __init__(self, serialPort):
self.portName = serialPort
self.comPort = enlace(self.portName)
self.comPort.enable()
self.eop = (420).to_bytes(4, byteorder="big")
self.fullArchive = b""
self.header = b""
self.payload = b""
self.eopReceived = b""
def main():
# Inicializa enlace ... variavel com possui todos os metodos e propriedades do enlace, que funciona em threading
com = enlace(serialName)
# Ativa comunicacao
com.enable()
#verificar que a comunicação foi aberta
print("comunicaçao aberta")
# a seguir ha um exemplo de dados sendo carregado para transmissao
# voce pode criar o seu carregando os dados de uma imagem. Tente descobrir
#como fazer isso
print("gerando dados para transmissao :")
with open(fileName, "rb") as img:
f = img.read()
b = bytearray(f)
# print(f"joviro{b}")
# ListTxBuffer =list()
# for x in range(0,20):
# ListTxBuffer.append(x)
txBuffer = b
txLen = len(txBuffer)
print(txLen)
# print(f"TxBuffer {txBuffer}")
# Transmite dado
print("tentado transmitir .... {} bytes".format(txLen))
com.sendData(txBuffer)
# # Atualiza dados da transmissão
# txSize = com.tx.getStatus()
# # Faz a recepção dos dados
# print ("Recebendo dados .... ")
# bytesSeremLidos=com.rx.getBufferLen()
# rxBuffer, nRx = com.getData(0)
# # log
# print ("Lido {} bytes ".format(nRx))
# # rxBuffer= list(rxBuffer)
# # print ("rxbuffer",rxBuffer)
# with open("./ImageRecebida.jpg","wb") as f:
# f.write((rxBuffer))
# # Encerra comunicação
# print("-------------------------")
# print("Comunicaçao encerrada")
# print("-------------------------")
com.disable()
def main():
nasme = fdlg.askopenfilename()
img = Image.open(nasme, mode='r')
imgByteArr = io.BytesIO()
img.save(imgByteArr, format='JPEG')
imgByteArr = imgByteArr.getvalue()
# Inicializa enlace ... variavel com possui todos os metodos e propriedades do enlace, que funciona em threading
com = enlace(serialName)
# Ativa comunicacao
com.enable()
#verificar que a comunicacao foi aberta
print("comunicacao aberta")
# a seguir ha um exemplo de dados sendo carregado para transmissao
# voce pode criar o seu carregando os dados de uma imagem. Tente descobrir
#como fazer isso
print("gerando dados para transmissao :")
txLen = len(imgByteArr)
infoArray = int_to_byte(txLen, 5)
print(len(infoArray))
txBuffer = imgByteArr
print(txLen)
print(bytes(infoArray))
estTx = (txLen / 550) - 5
print(estTx, " segundo(s) restantes (", (estTx / 60), " minuto(s))")
# Transmite dado
print("tentado transmitir .... {} bytes".format(txLen))
com.sendData(bytes(infoArray))
time.sleep(5)
startTx = time.time()
print("Acordou")
com.sendData(txBuffer)
# Atualiza dados da transmissao
txSize = com.tx.getStatus()
# Encerra comunicacao
print("-------------------------")
print("Comunicacao encerrada")
print("-------------------------")
com.disable()
endTx = time.time()
print("\n\n\nTransmitido em ", (endTx - startTx), " segundo(s). (",
((endTx - startTx) / 60),
" minuto(s)) \n\n\nTamanho do arquivo transmitido: ", txLen,
"bytes (", (txLen / 1048576), " MB).\n\n\n")
def main():
# Inicializa enlace
com = enlace(serialName)
# Ativa comunicacao
com.enable()
# Arquivo a ser recebido
dadoW = "./recebido/recebido.png"
# Log
print("__________________________________________________")
print("Comunicação inicializada")
print(" porta : {}".format(com.fisica.name))
print("__________________________________________________")
# Faz a recepção dos dados
print("Recebendo dados .... ")
rxBuffer = com.getData()
# log
#print("Lido {} bytes".format(nRx))
# print(rxBuffer)
# Salva o dado recebido em arquivo
print("__________________________________________________")
print("Salvando dados no arquivo :")
print("{}".format(dadoW))
f = open(dadoW, 'wb')
f.write(rxBuffer)
# Fecha arquivo de imagem
f.close()
# Encerra comunicação
print("__________________________________________________")
print("Comunicação encerrada")
print("__________________________________________________")
com.disable()
def main():
# Inicializa enlace
com = enlace(serialName)
# Ativa comunicacao
com.enable()
# Fazendo o arquivo a ser transmitido
dado = "./enviar/Screenshot.png"
# Log
print("__________________________________________________")
print("Comunicação inicializada")
print(" porta : {}".format(com.fisica.name))
print("__________________________________________________")
# Código handshake (msgtype):
# Error = 8
# Sync 1 = 1
# Ack 1 = 2
# Sync 2 = 3
# Ack 2 = 4
# Payload = 5
while (True):
print("Iniciando handshake")
print("Enviando Sync 1...")
data = (8).to_bytes(1, byteorder='big')
msgtype = (1).to_bytes(1, byteorder='big')
com.sendData(data, msgtype)
print("...enviado Sync 1\n")
print("Esperando Ack 1")
rxBuffer, msgtype = com.getData()
msgtype = (int.from_bytes(msgtype, byteorder='big'))
print("Recebido Ack 1\n")
print("Esperando Sync 2")
rxBuffer, msgtype = com.getData()
msgtype = (int.from_bytes(msgtype, byteorder='big'))
if msgtype == 3:
print("Recebido Sync 2\n")
print("Enviando Ack 2...")
data = (8).to_bytes(1, byteorder='big')
msgtype = (4).to_bytes(1, byteorder='big')
com.sendData(data, msgtype)
print("...enviado Ack 2")
print("Conexão estabelecida\n")
time.sleep(2)
break
else:
print("Erro, refazendo handshake...\n")
continue
print("__________________________________________________")
# Carrega imagem
print("Arquivo para transmissão:")
print("{}".format(dado))
print("__________________________________________________")
txBuffer = open(dado, 'rb').read()
# descobre a quantidade de bytes a ser enviada
# (importante porque so fará a leitura quando todos os bytes já foram transmitidos.)
txLen = len(txBuffer)
# Transmite imagem
print("Transmitindo {} bytes de payload".format(txLen))
start = time.time() # Começa contagem do tempo de transmissão
msgtype = (5).to_bytes(1, byteorder='big')
com.sendData(txBuffer, msgtype)
# espera o fim da transmissão
while(com.tx.getIsBussy()):
pass
# Atualiza dados da transmissão
end = time.time()
print("Tempo real de transmissão: ", "%.2f" % (end-start), "segundos")
txSize = com.tx.getStatus()
print("Transmitido {} bytes ".format(txSize))
# Encerra comunicação
print("__________________________________________________")
print("Comunicação encerrada")
print("__________________________________________________")
com.disable()
def main():
# Inicializa enlace
com = enlace(serialName)
# Ativa comunicação
com.enable()
# Arquivo a ser recebido
dadoW = "./recebido/recebido.jpeg"
# Log
print("__________________________________________________")
print("Comunicação inicializada")
print(" porta : {}\n".format(com.fisica.name))
print("__________________________________________________")
print("Iniciando handshake")
# Código handshake (msgtype):
# Error = 8
# Sync 1 = 1
# Ack 1 = 2
# Sync 2 = 3
# Ack 2 = 4
# Payload = 5
while (True):
currpart = (1).to_bytes(1, byteorder='big')
totalpart = (1).to_bytes(1, byteorder='big')
print("Esperando sync 1...")
rxBuffer, msgtype, rescrc = com.getData()
if msgtype == 1:
print("Recebido Sync 1\n")
print("Enviando Ack 1...")
data = (8).to_bytes(1, byteorder='big')
msgtype = (2).to_bytes(1, byteorder='big')
com.sendData(data, msgtype, currpart, totalpart)
print("...enviado Ack 1\n")
time.sleep(2)
print("Enviando Sync 2...")
data = (8).to_bytes(1, byteorder='big')
msgtype = (3).to_bytes(1, byteorder='big')
com.sendData(data, msgtype, currpart, totalpart)
print("...enviado Sync 2\n")
else:
print("Erro, refazendo handshake...\n")
continue
print("Esperando Ack 2...")
rxBuffer, msgtype, rescrc = com.getData()
if msgtype == 4:
print("Ack 2 recebido\n")
print("Conexão estabelecida, encerrando handshake\n")
break
else:
print("Erro, refazendo handshake...\n")
continue
print("__________________________________________________")
# Faz a recepção dos dados
print("Recebendo pacote com payload... ")
rxBuffer, msgtype, rescrc = com.getData()
if rescrc == -1:
# Salva o dado recebido em arquivo
print("__________________________________________________")
print("CRC checado com sucesso, salvando em arquivo:")
print("{}".format(dadoW))
f = open(dadoW, 'wb')
f.write(rxBuffer)
# Fecha arquivo de imagem
f.close()
# Encerra comunicação
print("__________________________________________________")
print("Comunicação encerrada")
print("__________________________________________________")
com.disable()
else:
print("__________________________________________________")
print("Payload corrupto no pacote:", rescrc)
print("__________________________________________________")
print("Comunicação encerrada")
print("__________________________________________________")
com.disable()
def main():
# Inicializa enlace
com = enlace(serialName)
# Ativa comunicacao
com.enable()
# # Fazendo o arquivo a ser transmitido
# dado = list(range(0,256))
# print(dado)
# print(type(dado[1]))
# dado = bytes(dado)
# print(dado)
#Arquivo a ser recebido
dadoW = "./recebido/recebido.png"
# Endereco do arquivo a ser salvo
#dado = "./imgs/dado.txt"
# Log
print("__________________________________________________")
print("Comunicação inicializada")
print(" porta : {}".format(com.fisica.name))
print("__________________________________________________")
# # Carrega imagem
# print ("Carregando dado para transmissão :")
# print (" - {}".format(dado))
# print("-----------------------------------------------")
# #txBuffer = open(dado, 'rb').read()
# txBuffer = dado
# txLen = len(txBuffer) #descobre a quantidade de bytes a ser enviada (importante porque so fará a leitura quando todos os bytes ja foram transmitidos.)
# print(txLen)
# # Transmite imagem
# print("Transmitindo .... {} bytes".format(txLen))
# com.sendData(txBuffer)
# espera o fim da transmissão
# while(com.tx.getIsBussy()):
# pass
# # Atualiza dados da transmissão
# txSize = com.tx.getStatus()
# print ("Transmitido {} bytes ".format(txSize))
# Faz a recepção dos dados
print ("Recebendo dados .... ")
rxBuffer, nRx = com.getData(1)
# log
print ("Lido {} bytes ".format(nRx))
print (rxBuffer)
# Salva o dado recebido em arquivo
print____________________________
print ("Salvando dados no arquivo :")
print (" - {}".format(dadoW))
f = open(dadoW, 'wb')
f.write(rxBuffer)
# Fecha arquivo de imagem
f.close()
# Encerra comunicação
print____________________________
print("Comunicação encerrada")
print____________________________
com.disable()
def main():
# Inicializa enlace
com = enlace(serialName)
# Ativa comunicacao
com.enable()
# Fazendo o arquivo a ser transmitido
dado = "./enviar/Screenshot.gif"
# Log
print("__________________________________________________")
print("Comunicação inicializada")
print(" porta : {}".format(com.fisica.name))
print("__________________________________________________")
# Código handshake (msgtype):
# Error = 8
# Sync 1 = 1
# Ack 1 = 2
# Sync 2 = 3
# Ack 2 = 4
# Payload = 5
while (True):
currpart = (1).to_bytes(1, byteorder='big')
totalpart = (1).to_bytes(1, byteorder='big')
print("Iniciando handshake")
time.sleep(1)
print("Enviando Sync 1...")
data = (8).to_bytes(1, byteorder='big')
msgtype = (1).to_bytes(1, byteorder='big')
com.sendData(data, msgtype, currpart, totalpart)
print("...enviado Sync 1\n")
print("Esperando Ack 1")
rxBuffer, msgtype = com.getData()
print("Recebido Ack 1\n")
print("Esperando Sync 2")
rxBuffer, msgtype = com.getData()
if msgtype == 3:
print("Recebido Sync 2\n")
print("Enviando Ack 2...")
data = (8).to_bytes(1, byteorder='big')
msgtype = (4).to_bytes(1, byteorder='big')
com.sendData(data, msgtype, currpart, totalpart)
print("...enviado Ack 2")
print("Conexão estabelecida, encerrando handshake\n")
time.sleep(2)
break
else:
print("Erro, refazendo handshake...\n")
continue
print("__________________________________________________")
# Carrega imagem
print("Arquivo para transmissão:")
print("{}".format(dado))
print("__________________________________________________")
dado = open(dado, 'rb').read()
# descobre a quantidade de bytes a ser enviada
# (importante porque so fará a leitura quando todos os bytes já foram transmitidos.)
txLen = len(dado)
# Transmite imagem
print("Transmitindo {} bytes de payload".format(txLen))
start = time.time() # Começa contagem do tempo de transmissão
msgtype = (5).to_bytes(1, byteorder='big')
# Dividindo payload em partes menores
if txLen > 1000:
n = (txLen//1000) + 1
totalpart = (n).to_bytes(1, byteorder='big')
# txBuffer = np.array_split(txBuffer, n) # TxBuffer está dividido em n partes
print("Pacote dividido em ", n, "partes")
i = 0
fullpack = b""
while i < n:
txBuffer = dado[i*1000 : (i*1000 + 1000)]
currpart = (i).to_bytes(1, byteorder='big')
fullpack += com.buildPackage(txBuffer, msgtype, currpart, totalpart)
i += 1
com.sendDataNoBuild(fullpack, msgtype, currpart, totalpart)
else:
n = 1
totalpart = (n).to_bytes(1, byteorder='big')
print("Não foi necessário dividir o payload")
com.sendData(dado, msgtype, currpart, totalpart)
# espera o fim da transmissão
while(com.tx.getIsBussy()):
pass
# Atualiza dados da transmissão
end = time.time()
print("Tempo real de transmissão: ", "%.2f" % (end-start), "segundos")
# txSize = com.tx.getStatus()
# print("Transmitido {} bytes ".format(txSize))
print("Pacote transmitido")
# Encerra comunicação
print("__________________________________________________")
print("Comunicação encerrada")
print("__________________________________________________")
com.disable()
def main():
# Inicializa enlace
com = enlace(serialName)
# Ativa comunicação
com.enable()
# Arquivo a ser recebido
dadoW = "./recebido/recebido.png"
# Log
print("__________________________________________________")
print("Comunicação inicializada")
print(" porta : {}".format(com.fisica.name))
print("__________________________________________________")
print("Iniciando handshake")
# Código handshake (msgtype):
# Error = 8
# Sync 1 = 1
# Ack 1 = 2
# Sync 2 = 3
# Ack 2 = 4
# Payload = 5
while (True):
print("Esperando sync 1...")
rxBuffer, msgtype = com.getData()
msgtype = int.from_bytes(msgtype, byteorder='big')
if msgtype == 1:
print("Recebido Sync 1\n")
print("Enviando Ack 1...")
data = (8).to_bytes(1, byteorder='big')
msgtype = (2).to_bytes(1, byteorder='big')
com.sendData(data, msgtype)
print("...enviado Ack 1\n")
time.sleep(2)
print("Enviando Sync 2...")
data = (8).to_bytes(1, byteorder='big')
msgtype = (3).to_bytes(1, byteorder='big')
com.sendData(data, msgtype)
print("...enviado Sync 2\n")
else:
print("Erro, refazendo handshake...\n")
continue
print("Esperando Ack 2...")
rxBuffer, msgtype = com.getData()
msgtype = (int.from_bytes(msgtype, byteorder='big'))
if msgtype == 4:
print("Ack 2 recebido, comunicação estabelecida\n")
break
else:
print("Erro, refazendo handshake...\n")
continue
print("__________________________________________________")
# Faz a recepção dos dados
print("Recebendo pacote com payload... ")
rxBuffer, msgtype = com.getData()
# Salva o dado recebido em arquivo
print("__________________________________________________")
print("Salvando dados no arquivo :")
print("{}".format(dadoW))
f = open(dadoW, 'wb')
f.write(rxBuffer)
# Fecha arquivo de imagem
f.close()
# Encerra comunicação
print("__________________________________________________")
print("Comunicação encerrada")
print("__________________________________________________")
com.disable()
