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)
Exemple #2
0
def configLeitor():
    if (request.method == "GET"):
        leitor = Leitor()
        return render_template('config/leitor.html', leitor=leitor.dados)
    if (request.method == "POST"):
        leitor = Leitor()
        result = leitor.save(request.form.to_dict())
        return render_template('config/leitor.html',
                               leitor=leitor.dados,
                               saved=result['success'],
                               error=not result['success'])
 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)
Exemple #4
0
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)
Exemple #5
0
def buttonPres():
    if (request.method == "GET"):
        return {'success': False}
        leitor = Leitor()
        return leitor.getButton()
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()
Exemple #7
0
 def run(self):
     leitor = Leitor()
     result = leitor.getButton()
     if (result['success']):
         self.corrida.corridaEnd = True
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()