def createDatagrams(txBuffer, txLen):
#preciso add o id do meu pacote no head e o n total no head
datagramas = [] #vou salvar todos meus pacotes aq
id = 0 #id do meu primeiro pacote
lenPackages = ceil(txLen / 114) #n de pacotes arredondando pra cima
print(f"Tamanho da msg: {txLen}")
print(f"Numero de pacotes: {lenPackages}")
print(
f"Tamanho do payload do ultimo datagrama: {txLen-(114*(lenPackages-1))}\n"
)
#preciso separar o txBuffer em n pacotes de tam 114
for i in range(0, txLen, 114):
if txLen - i >= 114: #se o tamanho da msg for maior ou igual a 114 preencho td o payload
payload = txBuffer[0 + i:114 + i]
payloadLen = len(payload)
else:
payload = txBuffer[
0 + i:] # vai do inicio ate o final se o tam for menor que 114
payloadLen = len(payload)
datagrama = protocolo(payload, payloadLen, id, lenPackages, 1)
datagramas.append(datagrama)
id += 1
print(f'Foram criados {len(datagramas)}\n')
return datagramas
def createMsg(type, lenPackages):
'''
PROTOCOLO: protocolo(type, lenPackages, idPackage, txLen, restartPackage, successPackage, txBuffer)
TYPE:
tipo 1 - handshake client-server
tipo 2 - hanshake server-client
tipo 3 - dados
tipo 4 - verificacao server-client para msg tipo 3
tipo 5 - timeout, quando o limite de espera excede
tipo 6 - erro, server-client quando recebe uma msg do tipo 3 invalida
'''
txBuffer = 0
txLen = 0
datagrama = protocolo(type, lenPackages, 0, 0, 0, 0, 0).datagrama
#total de bytes = 14
return datagrama
def acknowledge(type):
'''
PROTOCOLO: protocolo(txBuffer, txLen, idPackage, lenPackages, type)
TYPE:
0 - handshake
1 - envio dados
2 - erro
3 - td certo
4 - mandar dnv
5 - sucesso na transmissao
6 - falha na transmissao
'''
txBuffer = (0).to_bytes(1, byteorder='big')
txLen = len(txBuffer)
datagrama = protocolo(txBuffer, txLen, 0, 1, type).datagrama
#total de bytes = 15
return datagrama
def main():
try:
com1 = enlace(serialName)
# Ativa comunicacao. Inicia os threads e a comunicação serial
com1.enable()
print('\nComunicação com SUCESSO\n')
print('------------------------------------------')
print('Carregando dados para a transmissão')
print('------------------------------------------\n')
#carregando img para transmissao
imageR = image_picker()
#bytes da img
txBuffer = open(imageR, 'rb').read()
#len dos bytes da imagem
txLen = len(txBuffer)
#criando os datagramas
datagramas = createDatagrams(txBuffer, txLen)
#numero total de pacotes a serem enviados
numPckg = len(datagramas)
# marca o tempo do inicio da transmissao
inicio = time.time()
#ENVIANDO HANDSHAKE--------------------------------
print('------------------------------------------')
print('Conectando ao servidor')
print('------------------------------------------\n')
handshake = protocolo(1, numPckg, 0, 0, 0, 0, 0)
inicia = False
client = True
while not inicia:
com1.sendData(handshake.datagrama)
#typeAction, typeMsg, lenMsg, idPckg, numberPckg
type = int.from_bytes(handshake.h0, byteorder='big')
idPckg = int.from_bytes(handshake.h4, byteorder='big')
writeLog(client, 'envio', type, len(handshake.datagrama), idPckg,
numPckg)
response = com1.getDataTime(14, 5) #retorna falso se passar de 5s
if not isinstance(response, bool):
type = int.from_bytes(response[0:1], byteorder='big')
idPckg = int.from_bytes(response[4:5], byteorder='big')
writeLog(client, 'recebimento', type, len(response), idPckg,
numPckg)
if response == False:
user = input("Servidor inativo. Tentar novamente? S/N: \n")
if user == 'N':
raise Exception("Falha ao comunicar com o servidor")
elif type == 2:
print("Servidor Ativo!")
print("Pronto para iniciar a transmissão\n")
cont = 1
inicia = True
#cont precisa ser sempre igual ao numero de id do pacote
print('------------------------------------------')
print('Enviando Pacotes')
print('------------------------------------------\n\n')
while cont <= numPckg:
datagrama = datagramas[cont - 1]
print(
"................................................................"
)
print(f"PACOTE {cont}")
print(
f"Payload: {int.from_bytes(datagrama.h5, byteorder='big')}\nÚltimo pacote recebido com sucesso: {cont-1}\n"
)
datagrama.h7 = cont - 1 #ultimo pacote recebido com sucesso
com1.sendData(datagrama.datagrama)
#typeAction, typeMsg, lenMsg, idPckg, numberPckg
type = int.from_bytes(datagrama.h0, byteorder='big')
idPckg = int.from_bytes(datagrama.h4, byteorder='big')
writeLog(client, 'envio', type, len(datagrama.datagrama), idPckg,
numPckg)
print(
f"Enviando pacote {idPckg} para o servidor..\nEsperando resposta do servidor\n"
)
timer1 = time.time()
timer2 = time.time()
head = com1.getDataTime(10, 1)
if not isinstance(head, bool):
type = int.from_bytes(head[0:1], byteorder='big')
idPckg = int.from_bytes(head[4:5], byteorder='big')
writeLog(client, 'recebimento head', type, len(head), idPckg,
numPckg)
getType4 = False
while not getType4: #ainda nao recebeu msg tipo 4
if not isinstance(head, bool) and int.from_bytes(
head[0:1], byteorder='big') == 4:
getType4 = True
print(f"Pacote {cont} enviado com SUCESSO!\n\n")
else: #se nao recebeu a msg 4 ainda
if (time.time() - timer1) > 5:
print(f"timer1 > 5\nReenviando o pacote {cont}\n")
com1.sendData(datagrama.datagrama)
type = int.from_bytes(datagrama.h0, byteorder='big')
idPckg = int.from_bytes(datagrama.h4, byteorder='big')
writeLog(client, 'envio', type,
len(datagrama.datagrama), idPckg, numPckg)
timer1 = time.time()
if (time.time() - timer2) > 20:
print("timer2 > 20\nTempo máximo de espera excedido\n")
error = protocolo(5, 0, 0, 0, 0, 0, 0)
com1.sendData(error.datagrama)
#typeAction, typeMsg, lenMsg, idPckg, numberPckg
type = int.from_bytes(error.h0, byteorder='big')
idPckg = int.from_bytes(error.h4, byteorder='big')
writeLog(client, 'envio', type, len(error.datagrama),
idPckg, numPckg)
raise Exception("Falha ao comunicar com o servidor\n")
if not head:
print("Nada foi recebido\n")
elif not isinstance(head, bool):
#print(f"recebi uma msg q n era do tipo 4\nTipo:{int.from_bytes(head[0:1], byteorder='big')}\n")
eop, nEop = com1.getData(4)
if int.from_bytes(head[0:1], byteorder='big') == 6:
cont = int.from_bytes(
head[6:7], byteorder='big'
) #pega o pacote que devo reiniciar
datagrama = datagramas[cont - 1]
datagrama.h7 = cont #last sent successfully
com1.sendData(datagrama.datagrama)
#typeAction, typeMsg, lenMsg, idPckg, numberPckg
type = int.from_bytes(datagrama.h0,
byteorder='big')
idPckg = int.from_bytes(datagrama.h4,
byteorder='big')
writeLog(client, 'envio', type,
len(datagrama.datagrama), idPckg, numPckg)
print(
f"Houve um erro no envio. Reenviando o pacote {cont} ao servidor"
)
timer1 = time.time()
timer2 = time.time()
head = com1.getDataTime(10, 1)
if not isinstance(head, bool):
type = int.from_bytes(head[0:1], byteorder='big')
idPckg = int.from_bytes(head[4:5], byteorder='big')
writeLog(client, 'recebimento head', type, len(head),
idPckg, numPckg)
eop, nEop = com1.getData(4)
cont += 1
print("TODOS OS DADOS FORAM ENVIADOS COM SUCESSO\n")
# Encerra comunicação
print("-------------------------")
print("Comunicação encerrada")
print("-------------------------\n")
#marca o tempo do fim da comunicacao
fim = time.time()
#calcula a taxa de transmissao
baudrate = calculate_baudrate(inicio, fim, txLen)
print('Tempo de transmissao = {} segundos'.format(
round(fim - inicio, 2)))
print('BaudRate = {} bytes/segundo '.format(round(baudrate, 2)))
com1.disable()
except Exception as erro:
print("ops! :-\\")
print(erro)
com1.disable()
def main():
try:
com2 = enlace(serialName)
# Ativa comunicacao. Inicia os threads e a comunicação serial
com2.enable()
#Agora vamos iniciar a recepção dos dados. Se algo chegou ao RX, deve estar automaticamente guardado
print('Comunicação com SUCESSO \n')
# RECEBENDO HANDSHAKE---------------------------------------------
teste = 0
ocioso = True
server = 111
client = False
print('------------------------------------------')
print('Conectando ao Client')
print('------------------------------------------\n')
while ocioso:
handshake = com2.getDataTime(14, 1) #timesleep 1s
if not isinstance(handshake, bool):
type = int.from_bytes(handshake[0:1], byteorder='big')
idPckg = int.from_bytes(handshake[4:5], byteorder='big')
numPckg = int.from_bytes(handshake[3:4], byteorder='big')
writeLog(client, 'recebimento head', type, len(handshake),
idPckg, numPckg)
if handshake == False:
pass
elif type == 1:
idServer = int.from_bytes(handshake[1:2], byteorder='big')
if idServer == server:
ocioso = False
numPckg = int.from_bytes(handshake[3:4], byteorder='big')
print(
"Handshake recebido!\nPronto para iniciar a transmissão\n"
)
response = protocolo(2, numPckg, 0, 0, 0, 0, 0)
com2.sendData(response.datagrama)
#typeAction, typeMsg, lenMsg, idPckg, numberPckg
type = int.from_bytes(response.h0, byteorder='big')
idPckg = int.from_bytes(response.h4, byteorder='big')
writeLog(client, 'envio', type, len(response.datagrama), idPckg,
numPckg)
cont = 1
payloadImg = bytearray()
successPckg = 0
print('------------------------------------------')
print('Recebendo Pacotes')
print('------------------------------------------\n\n')
while cont <= numPckg:
timer1 = time.time()
timer2 = time.time()
head = com2.getDataTime(10, 1) #pegando so o head
if not isinstance(head, bool):
type = int.from_bytes(head[0:1], byteorder='big')
idPckg = int.from_bytes(head[4:5], byteorder='big')
writeLog(client, 'recebimento head', type, len(head), idPckg,
numPckg)
getType3 = False
while not getType3:
if not isinstance(head, bool) and int.from_bytes(
head[0:1], byteorder='big') == 3:
getType3 = True
print(
"................................................................"
)
print(f"PACOTE de dados recebido!")
else: #se nao recebeu a msg 3 ainda
if (time.time() - timer2) > 20:
print("timer2 > 20\nTempo máximo de espera excedido\n")
timeOut = protocolo(5, 0, 0, 0, 0, 0, 0)
com2.sendData(timeOut.datagrama)
#typeAction, typeMsg, lenMsg, idPckg, numberPckg
type = int.from_bytes(timeOut.h0, byteorder='big')
idPckg = int.from_bytes(timeOut.h4, byteorder='big')
writeLog(client, 'envio', type, len(timeOut.datagrama),
idPckg, numPckg)
raise Exception("Falha ao comunicar com o servidor")
elif (time.time() - timer1) > 2:
print(
"timer1 > 2\nEnviando mensagem do tipo 4 ao client\n"
)
verify = protocolo(4, 0, 0, 0, 0, 0, 0)
com2.sendData(verify.datagrama)
#typeAction, typeMsg, lenMsg, idPckg, numberPckg
type = int.from_bytes(verify.h0, byteorder='big')
idPckg = int.from_bytes(verify.h4, byteorder='big')
writeLog(client, 'envio', type, len(verify.datagrama),
idPckg, numPckg)
timer1 = time.time()
if not head:
print("Nada foi recebido\n")
elif not isinstance(head, bool):
print(
f"Recebi um pacote, mas nao era do tipo 3\nTipo:{int.from_bytes(head[0:1], byteorder='big')}"
)
type = int.from_bytes(head[0:1], byteorder='big')
idPckg = int.from_bytes(head[4:5], byteorder='big')
eop, nEop = com1.getData(4)
writeLog(client, 'recebimento eop', type, lenPayload,
idPckg, numPckg)
head = com2.getDataTime(10, 1)
if not isinstance(head, bool):
type = int.from_bytes(head[0:1], byteorder='big')
idPckg = int.from_bytes(head[4:5], byteorder='big')
writeLog(client, 'recebimento head', type, len(head),
idPckg, numPckg)
#verifica erros
erro = False
h0 = int.from_bytes(head[0:1], byteorder='big')
h1 = int.from_bytes(head[1:2], byteorder='big')
h2 = int.from_bytes(head[2:3], byteorder='big')
h3 = int.from_bytes(head[3:4], byteorder='big')
h4 = int.from_bytes(head[4:5], byteorder='big')
h5 = int.from_bytes(head[5:6], byteorder='big')
h6 = int.from_bytes(head[6:7], byteorder='big')
h7 = int.from_bytes(head[7:8], byteorder='big')
h8 = int.from_bytes(head[8:9], byteorder='big')
h9 = int.from_bytes(head[9:10], byteorder='big')
print(f"Tipo de mensagem: {h0}")
print(f"Id do sensor: {h1}")
print(f"Id do servidor: {h2}")
print(f"Número total de pacotes do arquivo: {h3}")
print(f"Pacote atual: {h4}")
print(f"Tamanho do payload {h5}")
print(f"Pacote solicitado para recomeço: {h6}")
print(f"Último pacote recebido com sucesso: {h7}")
print(f"CRC: {h8}")
print(f"CRC: {h9}\n")
payload, lenPayload = com2.getData(h5)
writeLog(client, 'recebimento payload', type, lenPayload, idPckg,
numPckg)
eop, lenEop = com2.getData(4)
writeLog(client, 'recebimento eop', type, lenEop, idPckg, numPckg)
#verificando erros
print("Verificando possíveis erros\n")
if cont == 7 and teste == 0:
#h4 = 27 #verificar se esta fora de ordem
#h5 = 100 #verificar se payload esta correto
#eop = (1).to_bytes(4, byteorder='big') #verificar se eop ta certo
teste += 1
if lenPayload != h5:
print('Tamanho do payload recebido é diferente do esperado')
erro = True
elif cont != h4:
print(
f'Id do pacote é diferente do esperado. Fora de ordem. Esperava {cont}, mas recebi {h4}'
)
erro = True
elif eop != (0).to_bytes(4, byteorder='big'):
print('EOP não esta correto')
erro = True
# Enviando resposta ao client...............................
if erro:
print(
'ERRO - Algo deu errado :( Enviando mensagem de erro ao client e aguardando reenvio do pacote...\n'
)
error = protocolo(6, 0, 0, 0, restartPckg, successPckg, 0)
com2.sendData(error.datagrama)
#typeAction, typeMsg, lenMsg, idPckg, numberPckg
type = int.from_bytes(error.h0, byteorder='big')
idPckg = int.from_bytes(error.h4, byteorder='big')
writeLog(client, 'envio', type, len(error.datagrama), idPckg,
numPckg)
else:
print(
f'Pacote {cont} recebido com SUCESSO :)\nEnviando ok ao client...\n\n'
)
restartPckg = cont + 1
successPckg = cont
correct = protocolo(4, 0, 0, 0, 0, 0, 0)
com2.sendData(correct.datagrama)
#typeAction, typeMsg, lenMsg, idPckg, numberPckg
type = int.from_bytes(correct.h0, byteorder='big')
idPckg = int.from_bytes(correct.h4, byteorder='big')
writeLog(client, 'envio', type, len(correct.datagrama), idPckg,
numPckg)
cont += 1
payloadImg += payload
print("TODOS OS DADOS FORAM ENVIADOS COM SUCESSO\n")
print('Salvando os dados recebidos como cópia da img... \n')
f = open(imageW, 'wb')
f.write(payloadImg)
# Encerra comunicação
print("-------------------------")
print("Comunicação encerrada")
print("-------------------------")
com2.disable()
except Exception as erro:
print("\n ops! :-\\")
print(erro)
com2.disable()