def __init__(self, corrida_id = None):
self.autorama = Autorama()
self.leitor = Leitor()
self.corridaEnd = False
self.dadosQualificatoria = None
if(corrida_id == None):
self.corrida = self.autorama.getCorridaAtual()
else:
self.corrida = self.autorama.getCorrida(corrida_id)
def __init__(self, corrida_id=None):
self.autorama = Autorama()
self.leitor = Leitor()
self.corridaEnd = False
self.dadosCorrida = None
self.primeiroVoltas = 0 #quantidade de voltas do primeiro colocado
self.primeiroTimestamp = 0 #timestamp. tempo de corrida do primeiro colocado
if (corrida_id == None):
self.corrida = self.autorama.getCorridaAtual()
else:
self.corrida = self.autorama.getCorrida(corrida_id)
def qualificatoriaHistorico(id):
if (request.method == "GET"):
autorama = Autorama()
qualificatoria = Qualificatoria(id)
corrida = qualificatoria.corrida
qualificatoriaDados = qualificatoria.getDadosQualificatoria()
return render_template('qualificatoria/qualificatoria.html',
status=corrida['qualificatoriaCompleta'],
qualificatoria=qualificatoriaDados,
circuito=autorama.getPista(
corrida['circuito_id']))
def classificacaoHistorico(id):
if (request.method == "GET"):
autorama = Autorama()
classificacao = Classificacao(id)
corrida = classificacao.corrida
classificacaoDados = classificacao.getDadosClassificacao()
return render_template('classificacao/classificacao.html',
status=corrida['corridaCompleta'],
classificacao=classificacaoDados,
circuito=autorama.getPista(
corrida['circuito_id']),
contentLarge=True)
def qualificatoriaUsuario():
if (request.method == "GET"):
autorama = Autorama()
qualificatoria = QualificatoriaUser()
corrida = qualificatoria.corrida
qualificatoriaDados = qualificatoria.getDadosQualificatoria()
return render_template('usuario/qualificatoria.html',
tempo=corrida['qualificatoriaDuracao'],
status=corrida['qualificatoriaCompleta'],
qualificatoria=qualificatoriaDados,
circuito=autorama.getPista(
corrida['circuito_id']),
pilotos=autorama.dados['pilotos'],
contentLarge=True)
def classificacaoUsuario():
if (request.method == "GET"):
autorama = Autorama()
classificacao = ClassificacaoUser()
corrida = classificacao.corrida
classificacaoDados = classificacao.getDadosClassificacao()
return render_template('usuario/classificacao.html',
tempo=corrida['classificacaoDuracao'],
status=corrida['corridaCompleta'],
classificacao=classificacaoDados,
circuito=autorama.getPista(
corrida['circuito_id']),
pilotos=autorama.dados['pilotos'],
contentLarge=True)
def test():
leitor = Leitor()
success = leitor.testConnection()['success']
error = not success
autorama = Autorama()
if autorama.dados['corrida_ativa'] > 0 and success:
corrida = autorama.getCorridaAtual()
return render_template('index.html',
success=success,
error=error,
ativo=True,
corrida=corrida,
circuito=autorama.getPista(
corrida['circuito_id']))
return render_template('index.html', success=success, error=error)
def updateClassificacao():
classificacao = Classificacao()
if (request.method == "GET"):
autorama = Autorama()
classificacaoDados = classificacao.getDadosClassificacao()
return {
'data': classificacaoDados,
'status': classificacao.corrida['corridaCompleta']
}
if (request.method == "POST"):
classificacao.setTime(request.form['time'])
return redirect(url_for('classificacao'))
def configEquipe():
if (request.method == "GET"):
autorama = Autorama()
return render_template('config/equipe.html')
if (request.method == "POST"):
autorama = Autorama()
autorama.addEquipe(request.form.to_dict())
return render_template('config/equipe.html', saved=True)
def createPiloto():
if (request.method == "GET"):
autorama = Autorama()
return render_template('config/piloto_create.html',
autorama=autorama.dados)
if (request.method == "POST"):
autorama = Autorama()
autorama.addPiloto(request.form.to_dict())
return redirect(url_for('listPilotos'))
def index():
if (request.method == "GET"):
autorama = Autorama()
if autorama.dados['administrador']:
if autorama.dados['corrida_ativa'] > 0:
corrida = autorama.getCorridaAtual()
return render_template('index.html',
ativo=True,
corrida=corrida,
circuito=autorama.getPista(
corrida['circuito_id']))
return render_template('index.html', ativo=False)
else:
autorama = AutoramaUser()
if autorama.dados['corrida_ativa']:
corrida = autorama.dados['corrida']
circuito = autorama.dados['circuito']
return render_template('usuario/index.html',
ativo=True,
corrida=corrida,
circuito=circuito)
return render_template('usuario/index.html', ativo=False)
def createCorrida():
if (request.method == "GET"):
autorama = Autorama()
return render_template('config/corrida_create.html',
autorama=autorama.dados)
if (request.method == "POST"):
autorama = Autorama()
autorama.addCorrida(request.form.to_dict(),
request.form.getlist('piloto_id[]'))
return redirect(url_for('listCorrida'))
class Qualificatoria:
def __init__(self, corrida_id = None):
self.autorama = Autorama()
self.leitor = Leitor()
self.corridaEnd = False
self.dadosQualificatoria = None
if(corrida_id == None):
self.corrida = self.autorama.getCorridaAtual()
else:
self.corrida = self.autorama.getCorrida(corrida_id)
def save(self):
self.autorama.saveCorrida(self.corrida)
def qualificatoria(self):
connection = self.leitor.getConnection()
headers = { 'pilotos': self.corrida['pilotos'], 'tempoMinimoVolta': self.autorama.getPista(self.corrida['circuito_id'])['tempoMinimoVolta'] }
connection.request('/corrida/carros',headers)#informa ao leitor quais as tags que devem ser lidas
#o codigo abaixo deve ser executado em uma thread separada
def qualificatoriaAcompanhar(self):
connection = self.leitor.getConnection()
connection.request('/corrida/acompanhar', '')
self.corridaEnd = False
corrida = self.autorama.getCorridaAtual()
qualificatoria = corrida['qualificatoria']
subscriber = True # variavel para determinar se um subscriber deve ser enviadado para acompanhar a corrida, se inscrevendo apenas uma vez na rota
while not self.corridaEnd:
# result = {"tag": epc , "timestamp": timestamp, "time": timestamp desde o inicio da qualificatoria ) }
result = connection.requestRecv(False, subscriber)['headers']#aguarda o leitor responder com uma tag
subscriber = False
if 'tag' in result:
qualificacao = qualificatoria[result['tag']]
if(qualificacao['timestamp'] == 0):
lap_time = result['time']
else:
lap_time = result['timestamp'] - qualificacao['timestamp']
lap_time_s = self.autorama.timestampFormat(lap_time)
if(qualificacao['tempo_menor'] > lap_time_s ):
qualificacao['tempo_menor'] = lap_time_s
qualificacao['tempo_menor_timestamp'] = lap_time
circuito = self.autorama.getPista( corrida['circuito_id'])
if( qualificacao['tempo_menor'] < circuito['recorde'] ):
piloto = self.autorama.getPiloto(qualificacao['piloto_id'])
circuito['recorde'] = qualificacao['tempo_menor']
circuito['autor'] = piloto['nome']
self.autorama.savePista(circuito)
qualificacao['timestamp'] = result['timestamp']
qualificacao['voltas'] += 1
qualificatoria[result['tag']] = qualificacao
corrida['qualificatoria'] = qualificatoria
print(qualificatoria)
tempoPercorrido = self.autorama.timestampFormat((result['time']))# interromper a corrida quando já tiver passado 1 minuto depois do tempo limite
print(tempoPercorrido)
print(corrida['qualificatoriaDuracao'])
if(corrida['qualificatoriaDuracao'] <= tempoPercorrido or self.corridaEnd):
self.corridaEnd = True
self.corrida['qualificatoriaCompleta'] = 1 #encerrada
else:
self.corrida['qualificatoriaCompleta'] = 2 #sendo realizada
self.save()
self.publicarDadosQualificatoria(result['tag'], self.corridaEnd, connection)
connection.request('/corrida/encerrar')
self.autorama.setCorridaAtiva()
self.setPosInicialForCorrida()
def publicarDadosQualificatoria(self, tag, status, pub):
self.getDadosQualificatoria()
print(self.corrida['qualificatoriaCompleta'])
pub.request('/corrida/acompanhar/' + str(self.corrida['corrida_id']) + "/qualificatoria/status", status, False, False, False)
pub.request('/corrida/acompanhar/' + str(self.corrida['corrida_id']), self.dadosQualificatoria, True, False, False)
for piloto in self.dadosQualificatoria:
if piloto['carro_epc'] == tag:
pub.request('/corrida/acompanhar/' + str(self.corrida['corrida_id']) + '/piloto/' + tag, piloto, True, False, False)
break
def getDadosQualificatoria(self):
corrida = self.corrida
qualificatoria = corrida['qualificatoria']
self.dadosQualificatoria = []
for piloto in corrida['pilotos']:
pilotoAtual = self.autorama.getPiloto(piloto['piloto_id'])
qualificacao = qualificatoria[piloto['carro_epc']]
pos = {}
pos['carro_epc'] = piloto['carro_epc']
pos['nome_piloto'] = pilotoAtual['nome']
pos['nome_equipe'] = self.autorama.getEquipe(pilotoAtual['equipe_id'])['nome']
pos['cor_carro'] = self.autorama.getCarro(pilotoAtual['carro_id'])['cor']
pos['num_carro'] = self.autorama.getCarro(pilotoAtual['carro_id'])['num']
pos['tempo_volta'] = qualificacao['tempo_menor']
pos['timestamp'] = qualificacao['tempo_menor_timestamp']
pos['voltas'] = qualificacao['voltas']
self.dadosQualificatoria.append(pos)
self.dadosQualificatoria = sorted(self.dadosQualificatoria, key=lambda pos: pos['timestamp'])
self.dadosQualificatoria[0]['posicao'] = 1
self.posicaoEntrePilotos(self.dadosQualificatoria[0], None, self.dadosQualificatoria[1])
for i in range(1, len(self.dadosQualificatoria) ):
posPrimeiro = self.dadosQualificatoria[0]
pos = self.dadosQualificatoria[i]
pos['posicao'] = i+1
pos['tempo_corrida'] = "+" + self.autorama.timestampFormat( pos['timestamp'] - posPrimeiro['timestamp'])
if i == (len(self.dadosQualificatoria) - 1):
self.posicaoEntrePilotos(pos, self.dadosQualificatoria[i-1])
else:
self.posicaoEntrePilotos(pos, self.dadosQualificatoria[i-1], self.dadosQualificatoria[i+1] )
self.dadosQualificatoria[i] = pos
return self.dadosQualificatoria
def posicaoEntrePilotos(self, pos, proximo=None, anterior=None):
pos['piloto_proximo'] = False
pos['piloto_anterior'] = False
if proximo:
pos['piloto_proximo'] = proximo['nome_piloto']
pos['num_proximo'] = proximo['num_carro']
pos['tempo_proximo'] = "+" + self.autorama.timestampFormat( pos['timestamp'] - proximo['timestamp'])
if anterior:
pos['piloto_anterior'] = anterior['nome_piloto']
pos['num_anterior'] = anterior['num_carro']
pos['tempo_anterior'] = "+" + self.autorama.timestampFormat( pos['timestamp'] - anterior['timestamp'])
def setPosInicialForCorrida(self):
self.getDadosQualificatoria()
pos = 1
for piloto in self.dadosQualificatoria:
self.corrida["classificacao"][piloto['carro_epc']]['pos_inicial'] = pos
pos = pos + 1
self.save()
def resetQualificatoria(self):
corrida = self.corrida
qualificatoria = corrida['qualificatoria']
for piloto in corrida['pilotos']:
pilotoAtual = self.autorama.getPiloto(piloto['piloto_id'])
qualificacao = qualificatoria[piloto['carro_epc']]
qualificacao['tempo_menor'] = "99:99:999"
qualificacao['tempo_menor_timestamp'] = 0
qualificacao['timestamp'] = 0
qualificacao['voltas'] = 0
self.save()
class Classificacao:
def __init__(self, corrida_id=None):
self.autorama = Autorama()
self.leitor = Leitor()
self.corridaEnd = False
self.dadosCorrida = None
self.primeiroVoltas = 0 #quantidade de voltas do primeiro colocado
self.primeiroTimestamp = 0 #timestamp. tempo de corrida do primeiro colocado
if (corrida_id == None):
self.corrida = self.autorama.getCorridaAtual()
else:
self.corrida = self.autorama.getCorrida(corrida_id)
def save(self):
self.autorama.saveCorrida(self.corrida)
def classificacao(self):
connection = self.leitor.getConnection()
headers = {
'pilotos':
self.corrida['pilotos'],
'tempoMinimoVolta':
self.autorama.getPista(
self.corrida['circuito_id'])['tempoMinimoVolta']
}
connection.request(
'/corrida/carros',
headers) #informa ao leitor quais as tags que devem ser lidas
#o codigo abaixo deve ser executado em uma thread separada
def classificacaoAcompanhar(self):
connection = self.leitor.getConnection()
connection.request('/corrida/acompanhar', '')
self.corridaEnd = False
classificacao = self.corrida['classificacao']
subscriber = True
while not self.corridaEnd:
# result = {"tag": epc , "timestamp": timestamp, "time": timestamp desde o inicio da classificacao ) }
print('sub')
result = connection.requestRecv(
False,
subscriber)['headers'] #aguarda o leitor responder com uma tag
subscriber = False
if 'tag' in result:
pos = classificacao[result['tag']]
if pos['voltas'] < self.corrida[
'quantidadeDeVoltas']: # se o primeiro carro não terminou a corrida
pos['tempo_total'] = self.autorama.timestampFormat(
result['time'])
if (pos['timestamp'] == 0):
lap_time = result['time']
else:
lap_time = result['timestamp'] - pos['timestamp']
lap_time_s = self.autorama.timestampFormat(lap_time)
pos['tempo_atual'] = lap_time_s
if (pos['tempo_menor'] > lap_time_s):
pos['tempo_menor'] = lap_time_s
circuito = self.autorama.getPista(
self.corrida['circuito_id'])
if (pos['tempo_menor'] < circuito['recorde']):
piloto = self.autorama.getPiloto(pos['piloto_id'])
circuito['recorde'] = pos['tempo_menor']
circuito['autor'] = piloto['nome']
self.autorama.savePista(circuito)
pos['timestamp'] = result['timestamp']
pos['voltas'] += 1
classificacao[result['tag']] = pos
self.corrida['classificacao'] = classificacao
if pos['voltas'] > self.primeiroVoltas:
self.primeiroVoltas = pos['voltas']
self.primeiroTimestamp = pos['timestamp']
print(classificacao)
tempoAposPrimeiro = self.autorama.timestampFormat(
(result['timestamp'] - self.primeiroTimestamp))
# tempo desde que o primeiro colocado concluiu uma volta
print(tempoAposPrimeiro)
if (self.primeiroVoltas >= self.corrida['quantidadeDeVoltas']
and tempoAposPrimeiro > "00:15:000"
or self.corridaEnd):
self.corridaEnd = True
self.corrida['corridaCompleta'] = 1 #encerrada
else:
self.corrida['corridaCompleta'] = 2 #sendo realizada
self.save()
self.publicarDadosClassificacao(result['tag'], self.corridaEnd,
connection)
connection.request('/corrida/encerrar')
self.autorama.setCorridaAtiva()
def publicarDadosClassificacao(self, tag, status, pub):
self.getDadosClassificacao()
pub.request(
'/corrida/acompanhar/' + str(self.corrida['corrida_id']) +
"/classificacao/status", status, False, False, False)
pub.request('/corrida/acompanhar/' + str(self.corrida['corrida_id']),
self.dadosCorrida, True, False, False)
for piloto in self.dadosCorrida:
if piloto['carro_epc'] == tag:
pub.request(
'/corrida/acompanhar/' + str(self.corrida['corrida_id']) +
'/piloto/' + tag, piloto, True, False, False)
break
def getDadosClassificacao(self):
corrida = self.corrida
classificacao = corrida['classificacao']
self.dadosCorrida = []
for piloto in corrida['pilotos']:
pilotoAtual = self.autorama.getPiloto(piloto['piloto_id'])
pos = classificacao[piloto['carro_epc']]
posicao = {}
posicao['carro_epc'] = piloto['carro_epc']
posicao['nome_piloto'] = pilotoAtual['nome']
posicao['nome_equipe'] = self.autorama.getEquipe(
pilotoAtual['equipe_id'])['nome']
posicao['cor_carro'] = self.autorama.getCarro(
pilotoAtual['carro_id'])['cor']
posicao['num_carro'] = self.autorama.getCarro(
pilotoAtual['carro_id'])['num']
posicao['tempo_corrida'] = pos['tempo_total']
posicao['tempo_volta'] = pos['tempo_atual']
posicao['tempo_menor'] = pos['tempo_menor']
posicao['timestamp'] = pos['timestamp']
posicao['voltas'] = pos['voltas']
posicao['pits'] = pos['pits']
posicao['pos_inicial'] = pos['pos_inicial']
self.dadosCorrida.append(posicao)
self.dadosCorrida = sorted(self.dadosCorrida,
key=itemgetter('tempo_corrida',
'pos_inicial'))
self.dadosCorrida = sorted(self.dadosCorrida,
key=itemgetter('voltas'),
reverse=True)
self.dadosCorrida[0]['posicao'] = 1
self.posicaoEntrePilotos(self.dadosCorrida[0], None,
self.dadosCorrida[1])
for i in range(1, len(self.dadosCorrida)):
posPrimeiro = self.dadosCorrida[0]
pos = self.dadosCorrida[i]
pos['posicao'] = i + 1
if (pos['voltas'] < posPrimeiro['voltas']):
pos['tempo_corrida'] = '+' + str(posPrimeiro['voltas'] -
pos['voltas']) + ' volta'
if (posPrimeiro['voltas'] - pos['voltas'] > 1):
pos['tempo_corrida'] = pos['tempo_corrida'] + 's'
else:
pos['tempo_corrida'] = "+" + self.autorama.timestampFormat(
pos['timestamp'] - posPrimeiro['timestamp'])
if i == (len(self.dadosCorrida) - 1):
self.posicaoEntrePilotos(pos, self.dadosCorrida[i - 1])
else:
self.posicaoEntrePilotos(pos, self.dadosCorrida[i - 1],
self.dadosCorrida[i + 1])
self.dadosCorrida[i] = pos
return self.dadosCorrida
def posicaoEntrePilotos(self, pos, proximo=None, anterior=None):
pos['piloto_proximo'] = False
pos['piloto_anterior'] = False
if proximo:
pos['piloto_proximo'] = proximo['nome_piloto']
pos['num_proximo'] = proximo['num_carro']
if (pos['voltas'] < proximo['voltas']):
pos['tempo_proximo'] = '+' + str(proximo['voltas'] -
pos['voltas']) + ' volta'
if (proximo['voltas'] - pos['voltas'] > 1):
pos['tempo_proximo'] = pos['tempo_proximo'] + 's'
else:
pos['tempo_proximo'] = "+" + self.autorama.timestampFormat(
pos['timestamp'] - proximo['timestamp'])
if anterior:
pos['piloto_anterior'] = anterior['nome_piloto']
pos['num_anterior'] = anterior['num_carro']
if (pos['voltas'] > anterior['voltas']):
pos['tempo_anterior'] = '+' + str(
pos['voltas'] - anterior['voltas']) + ' volta'
if (pos['voltas'] - anterior['voltas'] > 1):
pos['tempo_anterior'] = pos['tempo_anterior'] + 's'
else:
pos['tempo_anterior'] = "+" + self.autorama.timestampFormat(
pos['timestamp'] - anterior['timestamp'])
def resetClassificacao(self, save=True):
corrida = self.corrida
classificacao = corrida['classificacao']
for piloto in corrida['pilotos']:
pilotoAtual = self.autorama.getPiloto(piloto['piloto_id'])
pos = classificacao[piloto['carro_epc']]
pos['tempo_total'] = "99:99:999"
pos['tempo_atual'] = "99:99:999"
pos['tempo_menor'] = "99:99:999"
pos['timestamp'] = 0
pos['voltas'] = 0
if save:
self.save()
def setTime(self, time):
self.corrida['classificacaoDuracao'] = time
self.save()
def listCircuito():
if (request.method == "GET"):
autorama = Autorama()
return render_template('config/pistas.html', autorama=autorama.dados)
def setCorridaAtiva():
if (request.method == "POST"):
autorama = Autorama()
autorama.setCorridaAtiva(request.form.to_dict())
return redirect(url_for('listCorrida'))
def listPilotos():
if (request.method == "GET"):
autorama = Autorama()
return render_template('config/piloto.html', autorama=autorama.dados)
def listCorrida():
if (request.method == "GET"):
autorama = Autorama()
return render_template('config/corridas.html',
corridas=autorama.getCorridas(),
corridaAtiva=autorama.dados['corrida_ativa'])