Implementação do algoritmo PID usando visão computacional

Estou construindo um solucionador de labirinto automático de labirinto e usando uma webcam para controlar meu labirinto.

Com base em sugestões de outros fóruns, estou tentando controlar o movimento da bola do labirinto pelo menos em uma direção no momento. Então, estou tentando controlar o movimento da minha bola entre as duas coordenadas 466,288 e 466,152. A entrada para a placa controladora do motor de passo é o tempo, não há etapas a serem rotacionadas para cada eixo, isto é, xey.

A placa controladora do motor de passo que estou usando é a placa controladora do motor de passo egg bot: http://www.sparkfun.com/products/10025

Então, para mover entre dois pontos, devo criar um número de pontos entre os dois pontos, ou seja, 288 e 152 (digamos 260 240 230 ... 150) e corrigir o movimento da minha bola?

Meu algoritmo de processamento de imagem não é rápido o suficiente para rastrear a bola, de forma que ela simplesmente gire e caia em um buraco.

Alguns sugeriram que eu use um modelo padrão, como mostrado no vídeo a seguir, e corrija os movimentos da minha bola para desviar o caminho:

http://www.youtube.com/watch?v=Prq78ctJ2Rk&feature=player_embedded

Eu também me deparei com uma ferramenta de processamento de imagens onde eles resolviam o mesmo problema usando pontos de passagem para o movimento da bola. Vendo muitas soluções para o mesmo problema, estou totalmente confuso em resolver o problema. Estou ciente de que devo implementar um controlador PID. Mas como devo resolver os problemas em etapas? Estou paralisado e frustrado em encontrar um avanço na solução do problema.

Minha configuração é assim:

... e aqui está uma captura de tela do meu software:

Revisão 2: Agora também estou enfrentando um novo problema: Antes, eu controlava os motores de passo por meio do applet Java da porta serial do Arduino. Eu sou capaz de conduzir os steppers usando o applet.

Preciso redefinir a placa toda vez que tento me comunicar via porta serial. Além disso, o motor de passo se energiza em pequenos intervalos quando nenhum comando é enviado a ele. Quando o motor de passo entra neste modo, não consigo controlar minha placa sem redefinir a placa. Qualquer ajuda seria apreciada.

Revisão 3:

Fiz alguns progressos onde implementei o algoritmo PID. Encontre o vídeo abaixo: http://www.youtube.com/watch?v=MEfp7RqPmqY

Agora eu tenho um problema com a velocidade na qual o algoritmo PID é implementado. Na verdade, meu processamento de imagem termina um ciclo em 200 ms, identifica uma bola e envia os comandos para a placa controladora do motor de passo. Mesmo que minha porta serial receba comandos para mudar de direção, meu stepper continua girando na mesma direção. Você pode encontrar o comportamento estranho no vídeo acima.

Meu pensamento é que eu deveria restringir os valores do PID com um teto, onde se o valor calculado do PID for maior que 100, devo apenas enviar um 100. Estou ansioso para ouvir seus pensamentos sobre isso.

A maneira como implementei o controlador PID é que identifiquei o ponto de partida do modelo usando o algoritmo de correspondência de modelos e identifiquei a bola usando outro algoritmo de correspondência de modelos. Agora, eu fiz a bola se mover para o centróide do modelo de ponto de partida. Como faço para seguir a linha reta com o algoritmo PID?

Revisão 4:

Eu isolei a trajetória, mas não consigo encontrar a função correta para imprimir as coordenadas de pixel corretas a partir do ponto de partida. Alguma ideia?

Primeiro, como os steppers são ótimos em posicionamento (não há necessidade de feedback sobre a posição), você certamente deve limitar o movimento deles como disse a si mesmo. Não tenho certeza de como o eixo do motor é projetado no momento, mas se ele foi fixado ao motor, deixá-lo continuar girando correria o risco de danificar o equipamento.

Em seguida, o atraso de transporte de 200 ms no seu sensor provavelmente será muito lento, caso contrário, você precisará desacelerar bastante as coisas para desacelerar a bola. Semelhante ao que o Rocket Surgeon disse, você deve simplificar o algoritmo de processamento de imagem para calcular o caminho apenas uma vez e depois calcular rapidamente apenas a posição da bola em cada quadro. Se você quiser pular esta etapa rapidamente, encontre uma bola vermelha em vez desta e verifique somente o componente vermelho na sua imagem RGB, até encontrar um algoritmo melhor.

Para o controle PID, comece com o fato de que você realmente precisa de dois controladores PID separados, um para o motor leste-oeste e outro para o norte-sul. Se você tiver dois motores exatos, seus parâmetros deverão ser iguais.

Para um controlador PID agir, ele precisa saber o erro : diferença entre a posição desejada e a posição real da bola. Os componentes X e Y deste deslocamento serão as entradas para dois controladores PID (um para cada motor). Para obter o erro, você precisa primeiro ter a posição desejada no seu caminho: uma trajetória .

Para obter a trajetória, você precisa processar a imagem e obter o caminho , bem como seu ponto inicial e final. Não tenho certeza se o seu algoritmo é capaz de distinguir o caminho do restante da placa no momento, mas, se não, observe que esse é um algoritmo próprio a ser manipulado antes de continuar. Novamente, você pode pular esta parte inserindo manualmente os pontos de junção, se estiver ansioso para ver alguns resultados rapidamente. De qualquer forma, você deve poder definir a velocidade do ponto de ajuste e fazer com que o software mova a posição de coordenada desejada sobre o caminho, do início ao fim. Obviamente, você começará com a baixa velocidade desejada.

Portanto, antes de começar com o controle, você deve primeiro examinar a seguinte lista de verificação:

• Simplifique seu algoritmo de processamento de imagem para obter uma resposta mais rápida
• Crie um algoritmo que crie uma trajetória no seu caminho usando uma velocidade predefinida
• Em cada quadro:
  • Calcular a diferença entre a trajetória e a posição da bola
  • Passe o componente delta-X para o PID leste-oeste, passe o delta-Y para o PID norte-sul

Pode ser que seja melhor criar a trajetória um segmento por vez e continuar com o próximo segmento quando a bola terminar com a anterior. Caso contrário, você precisará cuidar para que a bola não ultrapasse a trajetória desejada (o que pode ser difícil de realizar)

Se você tiver uma posição fixa para a câmera e a leitura momentânea dos dois eixos, não precisará reconhecer o caminho pintado, os furos e as paredes nos quadros. Isso pode ser feito de uma só vez durante o tempo de configuração. No tempo de execução, você pode precisar apenas localizar a localização exata da única bola de metal brilhante.

Para localizar a bola, você pode usar 1 LED IR de ponto fixo e filtro de banda estreita na câmera. O algoritmo deve calcular o pixel mais brilhante e converter X, Y em X, Y real, levando em consideração etapas como:

• encontre o pixel mais brilhante
• use o ângulo para ambos os eixos (leitura do servo) para recuperar a distância da câmera
• use carimbo de data e hora para leitura da posição dos eixos
• aplicar interpolação ao longo do tempo para leitura da posição, se necessário
• use distorção conhecida da lente
• traduza o mundo X, Y do pixel em ângulo de reflexão da esfera perfeita para encontrar o verdadeiro centro da bola no mundo X, Y
• tempo delta para recuperar o tempo real do quadro
• interpolação no momento da posição no plano de bordo X, Y, se necessário
• envie o resultado X, Y (t) para o algoritmo PID
• envia o segundo objetivo de alimentação X, Y (t) do gerador / sequência de trajetória
• deixe o PID decidir sobre a saída
• executar saída (os últimos passos podem ser feitos em paralelo)

Não deve ser computacionalmente intensivo e depende principalmente de alguns valores absolutos.

Normalmente, uma CPU pequena deve fazê-lo com o ritmo da taxa de quadros.