def unpack_data(self, modules: list):
logging.debug('UNPACKING:')
for module in modules:
project_path = self.WORKING_DIR / (
"%s%s" % (module['filename'], self.PROJECT_SUFFIX))
sample_path = project_path / 'samples'
try:
project_path.mkdir(exist_ok=True)
sample_path.mkdir(exist_ok=True)
except (IOError, OSError):
msg = "Cannot create folders %s, %s at the working dir %s" % (
project_path.resolve(), sample_path.resolve(),
self.WORKING_DIR.resolve())
logging.error(msg)
return
try:
Unpacker.unpack(module, project_path, sample_path)
except Unpacker.ModuleUnpackerError:
msg = "Cannot unpack module: %s" % module.name
logging.error(msg)
def main():
try:
parser = optparse.OptionParser(
usage=
'%prog -a <Device_address> -z <Zip_file>\n\nExample:\n\tupdate.py -a cd:e3:4a:47:1c:e4 -z application.zip'
)
parser.add_option('-a',
'--address',
action='store',
dest="deviceAddr",
type="string",
default=None)
parser.add_option('-z',
'--zip',
action='store',
dest="zipfile",
type="string",
default=None)
options, args = parser.parse_args()
except Exception as e:
print(e)
print("For help use --help")
try:
if (not options.deviceAddr):
print("Error: Device address not passed in")
print("For help use --help")
elif (not options.zipfile):
print("Error: Zip file not passed in")
print("For help use --help")
elif not os.path.isfile(options.zipfile):
print("Error: Zip file not found")
print("For help use --help")
unpacker = Unpacker()
binfile, datfile = unpacker.unpack(options.zipfile)
bleClient = BleClient(options.deviceAddr.upper())
bleClient.updateDevice(binfile, datfile)
except Exception as e:
print(e)
print("For help use --help")
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()
my_server = Protocol.sever_number
packer = Packer()
unpacker = Unpacker()
file_num = 1
try_num = 1
# Log
print("-------------------------")
print("Comunicação inicializada")
print(" porta : {}".format(com.fisica.name))
print("-------------------------")
ocioso = True
serverReady_message_sent = False
count = 1
while(True):
# Server está ocioso
if ocioso:
dataRx = com.getData(Protocol.max_size, time.time())
data, code, kind, total, server, client = unpacker.unpack(dataRx, first=True)
# Server checa se o código e número de server da mensagem estão certos
if code == Protocol.type_client_call and server == my_server:
# Log do server é inicializado
log = open("log/fille{:02}log_try{:02}.txt".format(file_num, try_num),"w+")
# Server deixa de estar ocioso
ocioso = False
client_number = client
print("-------------------------")
print("Server chamado pelo client")
print("-------------------------")
log.write("Msg: {} – recebida: {} – remetente: {}\n".format(code, time.ctime(time.time()), client))
# Server não está mais ociono mas ainda não mandou uma mensagem com Código 2
elif serverReady_message_sent == False:
message = packer.pack_message(Protocol.type_server_ready, total, total, my_server, client_number)
com.sendData(message)
while(com.tx.getIsBussy()):
pass
serverReady_message_sent = True
log.write("Msg: {} – enviada: {} – destinatário: {}\n".format(Protocol.type_server_ready, time.ctime(time.time()), client_number))
print("-------------------------")
print("Total de pacotes a receber : {}".format(total))
print("Tipo de arquivo : {}".format(Protocol.from_kind[kind]))
print("-------------------------")
# Variáveis são iniciadas aqui para que não sejam mudadas indevidamente no loop de envio
recieved = bytes()
start = time.time()
time_out_time = time.time()
# Server recebe os pacotes e checa seus conteúdos
else:
# Enquanto todos os pacotes ainda não foram recebido, é checado se ainda não ocorreu um timeout
if count <= total and (time.time() - time_out_time) < Protocol.great_timeout:
dataRx = com.getData(Protocol.max_size, time.time())
data, code, atual, client = unpacker.unpack(dataRx)
print("-------------------------")
print("Pacote aberto")
print("Contador {} e atual {} e código {}".format(count, atual, code))
print("-------------------------")
log.write("Msg: {} – recebida: {} – remetente: {}\n".format(code, time.ctime(time.time()), client))
# Se o pacote recebido conter o código certo e seu número bater com o esperado,
# seu conteúdo é adicionado e uma mensagem de confirmação é enviada
if code == Protocol.type_package_delivery and atual == count and client == client_number:
print("-------------------------")
print("Pacote {} de {} recebido".format(atual, total))
print("-------------------------")
recieved += data
message = packer.pack_message(Protocol.type_package_ok, count, total, Protocol.sever_number, client_number)
com.sendData(message)
while(com.tx.getIsBussy()):
pass
count += 1
time_out_time = time.time()
log.write("Msg: {} – enviada: {} – destinatário: {}\n".format(Protocol.type_package_ok, time.ctime(time.time()), client_number))
# Se o pacote recebido não conter o código certo eou seu número não bater com o esperado,
# seu conteúdo é ignorado e uma mensage de erro com o pacote esperado é enviada
else:
print("-------------------------")
print("Erro")
print("Aguardando reenvio")
print("-------------------------")
message = packer.pack_message(Protocol.type_error, count, total, Protocol.sever_number, client_number)
com.sendData(message)
while(com.tx.getIsBussy()):
pass
log.write("Msg: {} – enviada: {} – destinatário: {}\n".format(Protocol.type_error, time.ctime(time.time()), client_number))
# Quando todos os pacotes forem recebidos o stuffing, se houver, é removido e o arquivo salvo
# O server volta para seu estado ocioso
elif count > total:
end = time.time() - start
print("-------------------------")
print("Pacotes recebidos com sucesso")
print("Taxa de recepção: {:02}".format(total*Protocol.max_size/end))
print("Salvando")
print("-------------------------")
to_save = unpacker.destuff(recieved)
open("recieved/recieved{:02}".format(file_num) + Protocol.from_kind[kind],"wb").write(to_save)
log.write("Salvo em: {}\n".format(time.ctime(time.time())))
log.close()
file_num += 1
print("-------------------------")
print("Aguardando novo envio")
print("-------------------------")
ocioso = True
serverReady_message_sent = False
com.rx.clearBuffer()
count = 1
try_num = 1
# Se mais tempo que o estipulado para um timeout passou, o server volta para seu estado ocioso
else:
print("-------------------------")
print("Timeout")
print("Aguardando novo envio")
print("-------------------------")
message = packer.pack_message(Protocol.type_time_out, count, total, my_server, client_number)
com.sendData(message)
while(com.tx.getIsBussy()):
pass
ocioso = True
serverReady_message_sent = False
count = 1
log.write("Msg: {} – enviada: {} – destinatário: {}\n".format(Protocol.type_time_out, time.ctime(time.time()), client_number))
log.write("Encerrado\n")
log.close()
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()
packer = Packer()
unpacker = Unpacker()
# Log
run = True
call = True
response = False
serverReady_message_get = False
count = 1
while (run):
if not response:
if call:
selected = select_file()
print("-------------------------")
print("Gerando dados para transmissao :")
print("-------------------------")
data = open(selected, "rb").read()
delivery, total = packer.pack(data,
get_kind(selected),
Protocol.type_package_delivery,
get_total=True)
print("-------------------------")
print("Chamando o server para tranferência de dados")
print("-------------------------")
message_timeot = time.time()
call = False
else:
if (time.time() - message_timeot) < Protocol.great_timeout:
message = packer.pack_message(Protocol.type_client_call,
total, total,
Protocol.sever_number)
com.sendData(message)
while (com.tx.getIsBussy()):
pass
dataRx = com.getData(Protocol.max_size, time.time())
data, code, atual = unpacker.unpack(dataRx)
if code == Protocol.type_server_ready:
serverReady_message_get = True
response = True
print("-------------------------")
print("Server pronto, começando o envio")
print("-------------------------")
start = time.time()
time_out_time = time.time()
count = 1
else:
response = True
elif not call and serverReady_message_get:
if count <= total and (time.time() -
time_out_time) < Protocol.great_timeout:
print("-------------------------")
print("Envindo pacote {} de {}".format(count, total))
print("-------------------------")
com.sendData(delivery[count - 1])
while (com.tx.getIsBussy()):
pass
dataRx = com.getData(Protocol.max_size, time.time())
data, code, atual = unpacker.unpack(dataRx)
if code == Protocol.type_package_ok and atual == count:
print("-------------------------")
print("Pacote {} de {} enviado com sucesso".format(
count, total))
print("-------------------------")
count += 1
time_out_time = time.time()
else:
print("-------------------------")
print("Erro")
print("-------------------------")
if 1 <= atual <= total:
count = atual
elif count > total:
end = time.time() - start
print("-------------------------")
print("Pacotes enviados com sucesso")
print("Taxa de recepção: {:02}".format(
total * Protocol.max_size / end))
print("-------------------------")
print("-------------------------")
go_on = input(
"Se desejar um novo envio digite sim, caso contrário outro caractere: "
)
print("-------------------------")
call = True
serverReady_message_get = False
response = False
count = 1
if go_on != "sim":
print("-------------------------")
print("Até mais!")
print("-------------------------")
run = False
else:
print("-------------------------")
print("O server não respondeu e um timeout ocorreu")
print("-------------------------")
print("-------------------------")
go_on = input(
"Se desejar um novo envio digite sim, caso contrário outro caractere: "
)
print("-------------------------")
call = True
serverReady_message_get = False
response = False
count = 1
if go_on != "sim":
print("-------------------------")
print("Até mais!")
print("-------------------------")
run = False
else:
print("-------------------------")
print("O server não respondeu e um timeout ocorreu")
print("-------------------------")
print("-------------------------")
go_on = input(
"Se desejar um novo envio digite sim, caso contrário outro caractere: "
)
print("-------------------------")
call = True
serverReady_message_get = False
response = False
count = 1
if go_on != "sim":
print("-------------------------")
print("Até mais!")
print("-------------------------")
run = False