Projeto

Geral

Perfil

Ações

Atividade #1228

Fechada

Meta #1230: Ter bons filtro de posição e estimatidor de velocidades

Analisar por que as estimativas de velocidade estão tão ruidosas no código novo

Adicionado por Gabriel Borges da Conceição mais de 4 anos atrás. Atualizado mais de 4 anos atrás.

Situação:
Fechada
Prioridade:
Normal
Início:
14/02/2020
Data prevista:

Descrição

SENDO FEITO NA BRANCH checkestimatives CRIADA A PARTIR DA readudp.

Um dos focos do nosso trabalho nesse semestre é conseguir ter um bom filtro de posição e estimador de velocidades.

Durante a RoboCup 2019, utilzamos nosso Kalman mas sobrescrevemos a estimação de velocidades utilizando o bloco de derivada do labview que utiliza método de tustin.

Como resultado, as estimativas de velocidade melhoraram consideravelmente, ficando próximas às medições do autoref para a bola e melhorando de certa forma o controle dos robôs e eficiência do goleiro.

No entanto, na RoboCup 2019 foi utilizado o código antigo. De alguma versão do código novo pra cá, percebemos que as estimativas pioraram consideravelmente, ficando bem mais ruidosas, inclusive no grsim.

Ainda não conseguimos identificar o motivo. Mas, conseguindo identificar isso, com certeza vai ajudar na tarefa maior que é ter um bom filtro e estimador.


Arquivos

EstimativaNoCódigoRoboCup.png (7,04 KB) EstimativaNoCódigoRoboCup.png Gabriel Borges da Conceição, 17/02/2020 14:13 h
EstimativaNoCódigoNovo.png (7,92 KB) EstimativaNoCódigoNovo.png Gabriel Borges da Conceição, 17/02/2020 14:27 h
EstimativaCódigoNovoAntesDoReadUDP.png (5,6 KB) EstimativaCódigoNovoAntesDoReadUDP.png Gabriel Borges da Conceição, 17/02/2020 15:05 h
EstimativaWaitNaMão.png (14,2 KB) EstimativaWaitNaMão.png Gabriel Borges da Conceição, 17/02/2020 15:47 h
VerificaPaconteNovoTrue.png (38,8 KB) VerificaPaconteNovoTrue.png Gabriel Borges da Conceição, 17/02/2020 17:17 h
VerificaPacoteNovo.png (63,7 KB) VerificaPacoteNovo.png Gabriel Borges da Conceição, 17/02/2020 17:17 h
EstimativaSemRepetirPacote.png (5,73 KB) EstimativaSemRepetirPacote.png Gabriel Borges da Conceição, 17/02/2020 17:25 h
ruidots.png (6,25 KB) ruidots.png Antonio de Souza Gomes Pereira, 27/02/2020 01:17 h
est.png (5,52 KB) est.png Antonio de Souza Gomes Pereira, 27/02/2020 01:25 h
ballestjoinpass.png (7,88 KB) ballestjoinpass.png Antonio de Souza Gomes Pereira, 29/02/2020 22:24 h
ballestkalman.png (9,72 KB) ballestkalman.png Antonio de Souza Gomes Pereira, 29/02/2020 22:24 h
derivadaposkalman.png (10,4 KB) derivadaposkalman.png Antonio de Souza Gomes Pereira, 29/02/2020 22:24 h
ComparasionAutoRefDerivada.png (42,9 KB) ComparasionAutoRefDerivada.png Gabriel Borges da Conceição, 09/03/2020 14:51 h
Ações #1

Atualizado por Gabriel Borges da Conceiçãomais de 4 anos

  • Descrição atualizado(a) (diff)
Ações #2

Atualizado por Gabriel Borges da Conceiçãomais de 4 anos

Só para ter uma breve noção do que estou falando, fiz o seguinte teste nas duas versões de código:

Sem Kalman (ou qualquer outro tipo de filtro), comparei as velocidades medidas pela derivada de tustin do labview com as enviadas para o robô (sem controle. Velocidades enviadas por mim num control direto na comunicação). Em ambas as versões, estamos usando a mesma VI Covert Detection Robot, que é onde está a derivada para cálculo da velocidade.

Nos gráficos, utilizei escala em Y de -1 a 3 e em X de -500 a 500 e variei as velocidades entre os valores 0, 0,5, 0,7, 1 e 1,5 m/s.

Em ambos os gráficos, o vermelho é a velocidade de comando e em branco é a estimativa

Código RoboCup:
![](EstimativaNoCódigoRoboCup.png)

Código atual:
![](EstimativaNoCódigoNovo.png)

Esse teste foi feito no meu computador, que não é tão bom, então provavelmente o robô não chegava à velocidade que eu mandava. Mas não estou entrando no mérito de estar próximo à real medida ou não. Estou falando somente do aumento significativo e estranho da ruidosidade da estimativa.

Ações #3

Atualizado por Gabriel Borges da Conceiçãomais de 4 anos

  • Arquivo excluído (EstimativaNoCódigoNovo.png)
Ações #5

Atualizado por Gabriel Borges da Conceiçãomais de 4 anos

Fiz o mesmo teste no código novo porém numa versão mais antiga dele. Nessa versão, não tínhamos separado a leitura de pacotes UDP em outro While ainda. A estimativa nesse teste voltou a ficar como no código da RoboCup. Então, a princípio, pode ser essa separação da leitura de pacotes que está causando o impacto negativo na estimativa.

![](EstimativaCódigoNovoAntesDoReadUDP.png)

Ações #6

Atualizado por Gabriel Borges da Conceiçãomais de 4 anos

Como eu disse na descrição, lembro que, de alguma versão do código novo pra cá, as estimativas pioraram consideravelmente. Na época, tentamos identificar o que estava causando isso e não conseguimos e acabamos não investigando mais devido a outras prioridades (até porque percebemos isso muito perto da competição).

Não tenho ainda como garantir que foi a partir da versão que separamos a leitura de pacotes, mas faz sentido ser. A diferença que isso causa é que o while Read UDP roda com fps igual ao recebimento de informações, pois tem uma VI que faz código ficar parado até chegar um pacote na porta. Já o while da visão não tem nenhum "bloqueio" de execução, seu fps depende apenas do seu processamento. Então, se não colocarmos nenhum wait, ele roda bem mais rápido (no grsim, na competição não). Nós criamos uma VI que leva em consideração os tempos de execução das últimas iterações dos dois whiles em questão e gera um valor que é levado a um wait no while da visão, com o intuito de forçar o while da visão a rodar menos que o Read UDP. Porém, isso não funciona tão efetivamente e o while da visão ainda continua rodando alguns FPS acima.

Com isso, o while da visão (e consequentemente todo o restante do código) trabalha com informações repetidas, pois pega pacotes repetidos. Sendo assim, a princípio, a estimativa tende a ficar ruim mesmo.

Mas como eu disse, não temos certeza de que é isso. Então o que temos que fazer é pensar numa maneira melhor de fazer o while da visão trabalhar apenas quando houver novo pacote e fazer um novo teste de estimativa.

Ações #7

Atualizado por Gabriel Borges da Conceiçãomais de 4 anos

Como dito, suspeitando de que o problema seja o fato de o while da visão estar rodando mais rápido que o while Read UDP e consequentemente estar trabalhando com informações repetidas diversas vezes, refiz o mesmo teste porém colocando um wait na mão até de forma que o FPS da visão ficasse menor que o FPS do read UDP.

![](EstimativaWaitNaMão.png)

A ruidosidade diminuiu bastante e as vezes que a estimativa caía para zero, eram justamente quando o booleano empty acendia, indicando que estava processando pacote repetido.

Mas ainda vou fazer algo que faça o while da visão rodar só quando tiver novo pacote e refazer o teste.

Atualizado por Gabriel Borges da Conceiçãomais de 4 anos

Fiz o seguinte para não processar pacotes repetidos na visão:

![](VerificaPacoteNovo.png)

![](VerificaPaconteNovoTrue.png)

Foi bem tranquilo uma vez já feita a lógica descrita na tarefa http://redmine.roboime.com.br/issues/1223.

Basicamente conferi se o vetor de clusters Detection Frame NewCameras que sai da VI getCurrentCameras está vazio. Essa VI lê as 4 referências e verifica quais tem informações novas e adiciona essas ao vetor.

Se o vetor estiver vazio, não executo nada no while da visão, nem escrevo nas referências. Com isso, o fps da visão ficou bem ajustado ao do while Read UDP sem ultrapassar.

Com isso, refiz o mesmo teste de estimativa e obtive o seguinte gráfico:
![](EstimativaSemRepetirPacote.png)

Pudemos ver então que realmente era a separação da leitura de pacotes UDP do resto da visão que estava causando o impacto tão negativo nas estimativas de velocidade. Agora obtivemos desempenho do bloco de derivada do labview parecido com o do código da robocup.

Ou seja, agora sabemos que não tem mais nada "estranho" piorando as estimativas, o que vai nos permitir mensurar com segurança cada melhoramento que fizermos no Kalman.

De qualquer forma, ainda vamos testar esse "conserto" no PIRF comparando a estimativa da bola com o autoref e ter noção de como fica com 4 câmeras.

As modificações feitas no código descritas nesta tarefa foram feitas na branch checkestimatives, criada a partir da branch readudp.

Ações #9

Atualizado por Gabriel Borges da Conceiçãomais de 4 anos

O que eu fiz nesta tarefa me atentou para um detalhe.

Em resumo, o que estava causando piora tão significativa nas estimativas de velocidade era o fato de o while da visão estar processando pacotes repetidos e perdendo alguns.

Mas com 4 câmeras, não é toda vez que o while da visão vai processar 4 dados novos. No código anterior à separação do Read UDP, o while da visão rodava sempre com apenas 1 câmera nova (e sempre uma nova) e realizava todo o Kalman para as 4, o que é incorreto já que usava a mesma medição como se fosse nova.

Do jeito que está o código agora, o Kalman só é realizado para as câmeras novas. Mas agora também acho isso incorreto. O que acho que deve ser feito é realizar todo o Kalman para as câmeras novas (predição de atualização) e realizar apenas predição para as que não possuem informação nova.

Ações #10

Atualizado por Gabriel Borges da Conceiçãomais de 4 anos

  • Tarefa mãe ajustado para #1230
Ações #11

Atualizado por Gabriel Borges da Conceiçãomais de 4 anos

  • Descrição atualizado(a) (diff)
Ações #12

Atualizado por Gabriel Borges da Conceiçãomais de 4 anos

  • Descrição atualizado(a) (diff)

Atualizado por Antonio de Souza Gomes Pereiramais de 4 anos

Mesmo corrigindo os ruídos que apareciam no grsim, devido à chegada de pacotes vazios, os mesmos permaneceram em testes feitos no pirf.
Uma das nossas suspeitas é que o causador do ruído é a falta de cadência na chegada das câmeras. Para poder ter uma noção se era isso que estava acontecendo, na vi de decodificação de pacotes, gerei um número aleatório que era sempre 0 ou 1 e depois era escrito no camera_id, se fosse 0, passava o robô de fato e caso fosse 1, passava um pacote vazio. Fazendo isso o ruído apareceu somente quando o bloco de derivada do LabView estava no TeamSide, como mostra abaixo:

![](ruidots.png)

Apesar disso, o kalman e qualquer outro estimador de velocidade (inclusive o bloco da derivada do LabView) funcionam sem muitos ruídos (figura abaixo), apesar de alguns demorarem a responder a mudanças de velocidade, se forem colocados para apenas processar a informação por câmera e apenas quando a mesma chega, ou seja a estimativa é feita apenas nas iterações que a correspondente câmera é a mais recente, processando apenas uma vez (posteriormente estuda-se estimar o estado das câmeras menos recentes com base na última estimativa das mesmas). O problema disso é que no pirf, também testamos essa situação e o ruído se manteve.

![](est.png)

Na nossa próxima ida no pirf, iremos fazer mais alguns testes, como deixar o robô andar em apenas uma câmera, com as outras desligadas, e medir a diferença entre os t_captures da câmera mais recente com o das outras e o de uma câmera com a de si mesmo na iteração anterior.

Ações #14

Atualizado por Gabriel Borges da Conceiçãomais de 4 anos

  • Atribuído para alterado de Gabriel Borges da Conceição para Antonio de Souza Gomes Pereira

Atualizado por Antonio de Souza Gomes Pereiramais de 4 anos

Fomos ao pirf realizar os testes propostos acima, e para a nossa surpresa o kalman funcionou normalmente quando colocado para executar individualmente para cada câmera, tanto na branch readudp quanto na que foi usada na larc 2019. Foram printados os resultados de três testes, um com o kalman puro, outro estimando a velocidade com a posição recebida do kalman e outro com a derivada no TeamSide, na JoinPass, ambos funcionando bem, destacando-se a do kalman com a derivada. O único problema é na intercessão das câmeras, onde a velocidade cai para 0.

UTILIZANDO APENAS O KALMAN P/ CADA CÂMERA
![](ballestkalman.png)

UTILIZANDO O KALMAN E A DERIVADA DO LABVIEW P/ CADA CÂMERA
![](derivadaposkalman.png)

A derivada do LabView não funciona direito quando posta dentro do TeamSide e existe a separação em dois whiles, um para receber os pacotes e outro para processar os mesmos. Já no caso em que há apenas um while para fazer tudo , como acontece na branch JoinPass (última sem a separação), no quesito ruído, não apresentou desvios tão grandes quanto esperava-se.

DERIVADA NO TEAMSIDE DA JOINPASS
![](ballestjoinpass.png)

Como conclusões finais, podemos dizer que ainda falta consertar o fato do módulo da velocidade desviar do esperado e a estimativa ir para 0 quando na intercessão das câmeras. Além disso, não conseguímos formular uma hipótese válida do fato de que a JoinPass apresenta uma estimativa razoável, quando há apenas um while.

Ações #16

Atualizado por Gabriel Borges da Conceiçãomais de 4 anos

Em resumo:

1- Com apenas uma câmera ligada no PIRF qualquer método de estimação de velocidades testado funciona sem ruídos.

2- Com mais de uma câmera ligada, só funciona sem ruído se estimarmos a velocidade antes da VI MediaCameras. Sendo que na RoboCup, começamos a usar o bloco de derivada do labview (método de tustin) na VI TeamAndSide, que fica depois do MediaCameras, mas como nessa competição havia apenas 1 câmera para todo o campo, não causava ruídos.

O que nós entendemos:

Sabemos que chega uma câmera por vez no código. Então considere a iteração que chega uma câmera que não tenha o robô 3, por exemplo. Esse robô continuará no código mas sua posição não será alterada. Então, se derivarmos a posição dele, estaremos causando um erro, já que não temos uma nova informação sobre sua posição e isso causa o ruído. Logicamente, isso só acontece quando tem mais de uma câmera.

Então, não podemos usar derivadas depois do MediaCameras pois não sabemos se determinado robô ou bola teve novo input de posição ou não, temos que derivar por câmera, ou seja, pra cada câmera derivamos apenas os robôs e bola que vêm nela.

Ações #17

Atualizado por Gabriel Borges da Conceiçãomais de 4 anos

Só relembrando que nesta tarefa não estamos entrando no mérito se os estimadores que estamos testando estão condizendo com a realidade ou não (isso será feito na tarefa http://redmine.roboime.com.br/issues/1230). Aqui focamos apenas em identificar o que estava causando o excessivo ruído na estimação.

Ações #18

Atualizado por Gabriel Borges da Conceiçãomais de 4 anos

  • Título alterado de Analisar por que as estimativas de velocidade estão tão piores no código novo para Analisar por que as estimativas de velocidade estão tão ruidosas no código novo
Ações #19

Atualizado por Nicolas Oliveiramais de 4 anos

Sabemos que chega uma câmera por vez no código. Então considere a iteração que chega uma câmera que não tenha o robô 3, por exemplo. Esse robô continuará no código mas sua posição não será alterada. Então, se derivarmos a posição dele, estaremos causando um erro, já que não temos uma nova informação sobre sua posição e isso causa o ruído. Logicamente, isso só acontece com mais de uma câmera.

Então, não podemos usar derivadas depois do MediaCameras pois não sabemos se determinado robô ou bola teve novo input de velocidade ou não, temos que derivar por câmera, ou seja, pra cada câmera derivamos apenas os robôs e bola que vêm nela.

Concordo com o dito acima, pra mim esse é o problema, já tinha levantado essa hipótese algumas vezes mas nunca ataquei o problema.

Ações #20

Atualizado por Gabriel Borges da Conceiçãomais de 4 anos

Fizemos o seguinte teste no PIRF:

Utilizamos a derivada de tustin, por câmera (no case que tem o kalman) mas sem utilizar o Kalman e jogamos a bola, comparando com o medido pelo autoref:
![](ComparasionAutoRefDerivada.png)

Fizemos esse teste para garantir que, fazendo as correções necessárias, eliminamos de fato o ruído absurdo com o qual estávamos.

Para esse teste, não utilizamos nenhum filtro de posição para não influenciar no teste. Por isso, a estimação não fica tão boa. Mas o foco desta tarefa é identificar e corrigir o ruído fora do normal. Já estamos trabalhando em ter uma melhor estimação.

Ações #21

Atualizado por Gabriel Borges da Conceiçãomais de 4 anos

Como conclusão desta tarefa temos que:

1- Código da dev processa pacotes repetidos e isso causa ruído. Foi resolvido com http://redmine.roboime.com.br/issues/1223 (lembrando que a solução dada no link ainda precisa ser melhorada).

2- Temos que estimar por câmera e não por elemento depois do MediaCameras.

Identificados e consertados esses dois erros, a estimação de velocidades voltou a ficar normal, ou seja, sem presença absurda de ruído.

Vamos partir agora para estudo e implementação do novo estimador/ melhoria do atual.

Ações #22

Atualizado por Gabriel Borges da Conceiçãomais de 4 anos

  • Situação alterado de Em andamento para Feedback
Ações #23

Atualizado por Lucas Germanomais de 4 anos

Seria uma boa estudar como o autoref faz o cálculo da velocidade da bola em azul. Esse gráfico em verde, se não me engano, detecta grandes variações na velocidade da bola. Eles usam esse gráfico em verde junto a velocidade estimada da bola para calcular uma velocidade mais real. (Isso são só suposições do que eu me lembro do pessoal da Tigers falando na competição)

O estimador do autoref é talvez o mais preciso da competição, caso queiramos melhorar o estimador é uma boa estudar como eles fazem isso.

Existem também outros autorefs, como o da ER-Force. Geralmente eles são usados em conjunto na competição, de tal forma que se chegue num consenso. Mas pra começar, podemos ficar com o da Tigers (caso achem documentação é o bizu, caso não achem tentem procurar o código fonte e fazer uma engenharia reversa).

Ações #24

Atualizado por Gabriel Borges da Conceiçãomais de 4 anos

Lucas Germano escreveu:

Seria uma boa estudar como o autoref faz o cálculo da velocidade da bola em azul. Esse gráfico em verde, se não me engano, detecta grandes variações na velocidade da bola. Eles usam esse gráfico em verde junto a velocidade estimada da bola para calcular uma velocidade mais real. (Isso são só suposições do que eu me lembro do pessoal da Tigers falando na competição)

O estimador do autoref é talvez o mais preciso da competição, caso queiramos melhorar o estimador é uma boa estudar como eles fazem isso.

Existem também outros autorefs, como o da ER-Force. Geralmente eles são usados em conjunto na competição, de tal forma que se chegue num consenso. Mas pra começar, podemos ficar com o da Tigers (caso achem documentação é o bizu, caso não achem tentem procurar o código fonte e fazer uma engenharia reversa).

Sim, realmente tem uma documentação explicando como eles fazem essa filtragem para ter uma melhor estimativa. Está nos nossos planos estudar isso.

Ações #25

Atualizado por Nicolas Oliveiramais de 4 anos

Lucas Germano escreveu:

Seria uma boa estudar como o autoref faz o cálculo da velocidade da bola em azul. Esse gráfico em verde, se não me engano, detecta grandes variações na velocidade da bola. Eles usam esse gráfico em verde junto a velocidade estimada da bola para calcular uma velocidade mais real. (Isso são só suposições do que eu me lembro do pessoal da Tigers falando na competição)

O estimador do autoref é talvez o mais preciso da competição, caso queiramos melhorar o estimador é uma boa estudar como eles fazem isso.

Existem também outros autorefs, como o da ER-Force. Geralmente eles são usados em conjunto na competição, de tal forma que se chegue num consenso. Mas pra começar, podemos ficar com o da Tigers (caso achem documentação é o bizu, caso não achem tentem procurar o código fonte e fazer uma engenharia reversa).

Gabriel Borges escreveu:

Vamos partir agora para estudo e implementação do novo estimador/ melhoria do atual.

Acho q o primeiro passo seria realmente oq o germano falou, isso já era uma ideia nossa a algum tempo. Dê prosseguimento nesse sentido. Mas essa tarefa aqui acho q ta ok já. Muito bom. Colocar na wiki como ficou organizada essa estimação!

Ações #26

Atualizado por Gabriel Borges da Conceiçãomais de 4 anos

Okay, então vou fechar essa tarefa.

Ações #27

Atualizado por Gabriel Borges da Conceiçãomais de 4 anos

  • Situação alterado de Feedback para Resolvida
Ações #28

Atualizado por Gabriel Borges da Conceiçãomais de 4 anos

  • Situação alterado de Resolvida para Fechada
Ações

Exportar para Atom PDF