Manufaturação industrial
Internet das coisas industrial | Materiais industriais | Manutenção e reparo de equipamentos | Programação industrial |
home  MfgRobots >> Manufaturação industrial >  >> Manufacturing Technology >> Processo de manufatura

Rastreamento Automatizado de Objetos Baseado em Visão com Raspberry Pi e OpenCV

Um sistema pan/tilt de servos que rastreia automaticamente objetos coloridos usando visão computacional.

História

Introdução

No tutorial anterior aprendemos como controlar um servo pan/tilt para posicionar uma câmera Raspberry Pi. Hoje estenderemos essa configuração para que a câmera rastreie autonomamente um objeto colorido.

Esta é minha primeira experiência prática com OpenCV, e já estou encantado com esta biblioteca open-source de visão computacional.

OpenCV é gratuito para uso acadêmico e comercial, oferece interfaces C++, C, Python e Java, e roda em Windows, Linux, macOS, iOS e Android. Nesta série focaremos no Raspberry Pi (Raspbian) e Python, porque OpenCV é feito para eficiência computacional e aplicações em tempo real — exatamente o que você precisa para projetos de computação física.

Passo 1: BOM – Lista de Materiais

Principais peças:

(*) Você pode comprar uma plataforma pan/tilt completa com servos ou construir a sua.

Passo 2: Instalando OpenCV 3

Em um Raspberry Pi V3 rodando o último Raspbian Stretch, o método mais confiável é seguir o tutorial de Adrian Rosebrock (Raspbian Stretch: Instalar OpenCV 3 + Python no seu Raspberry Pi). Ele guia pela compilação do OpenCV do fonte e configura um ambiente virtual Python dedicado.

Após completar o tutorial, ative o ambiente virtual e confirme a instalação:

source ~/.profile
workon cv
python
import cv2
print(cv2.__version__)

Você deve ver versão 3.3.0 ou superior. A saída confirma que OpenCV está pronto para uso dentro do ambiente virtual cv.

Passo 3: Testando sua Câmera

Com OpenCV instalado, verifique se o PiCamera stream corretamente. Rode o script abaixo (ou baixe simpleCamTest.py):

import cv2
cap = cv2.VideoCapture(0)
while True:
    ret, frame = cap.read()
    frame = cv2.flip(frame, -1) # Inverte verticalmente se necessário
    gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
    cv2.imshow('frame', frame)
    cv2.imshow('gray', gray)
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break
cap.release()
cv2.destroyAllWindows()

Pressione q ou Ctrl+C para sair. Uma execução bem-sucedida mostra feeds colorido e em escala de cinza.

Passo 4: Detecção de Cor em Python com OpenCV

OpenCV trabalha no espaço HSV (Matiz, Saturação, Valor), que alinha melhor com percepção de cor humana. Para detectar uma cor específica, você primeiro determina seus valores BGR, depois converte para HSV e estabelece limites inferior/superior.

Exemplo: Rastreando objeto amarelo. Usando seletor de cor (ex: PowerPoint), você achou valores BGR (71, 234, 213). Converta para HSV com o script abaixo (ou baixe bgr_hsv_converter.py):

import sys, numpy as np, cv2
blue, green, red = int(sys.argv[1]), int(sys.argv[2]), int(sys.argv[3])
color = np.uint8([[[blue, green, red]]])
hsv = cv2.cvtColor(color, cv2.COLOR_BGR2HSV)
hue = hsv[0][0][0]
print('Limite inferior:', [hue-10, 100, 100])
print('Limite superior:', [hue+10, 255, 255])

Rodando python bgr_hsv_converter.py 71 234 213 imprime:

Limite inferior: [24, 100, 100]
Limite superior: [44, 255, 255]

Use esses limites para mascarar a cor em uma imagem:

import cv2, numpy as np
img = cv2.imread('yellow_object.JPG', 1)
img = cv2.resize(img, (0,0), fx=0.2, fy=0.2)
hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)
lower = np.array([24, 100, 100], dtype=np.uint8)
upper = np.array([44, 255, 255], dtype=np.uint8)
mask = cv2.inRange(hsv, lower, upper)
cv2.imshow('mask', mask)
cv2.imshow('image', img)
while True:
    k = cv2.waitKey(0)
    if k == 27:
        break
cv2.destroyAllWindows()

Salve o script como colorDetection.py e rode python colorDetection.py (garanta que a imagem está no mesmo diretório).

Passo 5: Rastreamento de Movimento de Objeto em Tempo Real

Baseando-se na máscara, podemos rastrear o centróide do objeto frame a frame. O código abaixo adapta do tutorial Ball Tracking de Adrian Rosebrock e incorpora os limites HSV definidos anteriormente.

Primeiro, garanta que a biblioteca imutils está instalada:

pip install imutils

Então rode ball_tracking.py:

python ball_tracking.py

O script inverte o frame verticalmente (se necessário) e aplica a máscara. Quando o objeto é detectado, um círculo e centróide são desenhados.

Passo 6: Testando os GPIOs

Agora vamos adicionar um LED vermelho ao Pi e confirmar que podemos controlá-lo via GPIO.

Fiação: Conecte o cátodo do LED ao GPIO 21, o anodo ao ground através de resistor 220 Ω.

Se RPi.GPIO não estiver instalado no ambiente cv, instale:

pip install RPi.GPIO

Script de teste (LED_simple_test.py):

import sys, time, RPi.GPIO as GPIO
led = int(sys.argv[1])
freq = int(sys.argv[2])
GPIO.setmode(GPIO.BCM)
GPIO.setup(led, GPIO.OUT)
GPIO.setwarnings(False)
print(f'Piscando LED no GPIO {led} a cada {freq}s, 5 vezes.')
for _ in range(5):
    GPIO.output(led, GPIO.LOW)
    time.sleep(freq)
    GPIO.output(led, GPIO.HIGH)
    time.sleep(freq)
GPIO.cleanup()

Rode com python LED_simple_test.py 21 1 para piscar o LED cinco vezes a cada segundo.

Passo 7: Reconhecimento de Cor e Interação GPIO

Combine a lógica de rastreamento com controle GPIO para que o LED acenda sempre que a cor alvo for detectada. Adições principais:

import RPi.GPIO as GPIO
led = 21
GPIO.setmode(GPIO.BCM)
GPIO.setwarnings(False)
GPIO.setup(led, GPIO.OUT)
GPIO.output(led, GPIO.LOW)
ledOn = False

Dentro do loop de detecção, após confirmar raio válido, adicione:

if not ledOn:
    GPIO.output(led, GPIO.HIGH)
    ledOn = True

Script completo: object_detection_LED.py. Rode com python object_detection_LED.py. O LED acende apenas quando a cor do objeto está dentro dos limites HSV.

Passo 8: O Mecanismo Pan/Tilt

Com OpenCV e GPIO funcionando, conecte os servos a uma fonte externa 5 V. Ligue os pinos de dados conforme:

Compartilhe o ground entre Pi, servos e fonte. Opcionalmente coloque resistor 1 kΩ em série entre GPIO do Pi e pino de dados do servo para proteger o Pi de picos de corrente.

Teste controle de servo com angleServoCtrl.py:

from time import sleep
import RPi.GPIO as GPIO
GPIO.setmode(GPIO.BCM)
GPIO.setwarnings(False)

def setServoAngle(servo, angle):
    pwm = GPIO.PWM(servo, 50)
    pwm.start(8)
    duty = angle / 18. + 3.
    pwm.ChangeDutyCycle(duty)
    sleep(0.3)
    pwm.stop()

if __name__ == '__main__':
    import sys
    servo = int(sys.argv[1])
    GPIO.setup(servo, GPIO.OUT)
    setServoAngle(servo, int(sys.argv[2]))
    GPIO.cleanup()

Exemplo: python angleServoCtrl.py 17 45 move o servo tilt para 45°.

Passo 9: Encontrando a Posição do Objeto em Tempo Real

Para centralizar a câmera no alvo, primeiro precisamos das coordenadas do centróide. Modifique objectDetect_LED.py para imprimir valores x e y:

def mapObjectPosition(x, y):
    print(f'[INFO] Centro do objeto em X={x}, Y={y}')

As coordenadas variam de 0–500 (esquerda-direita) para x e 0–350 (topo-base) para y. Mova o objeto e observe a saída ao vivo.

Passo 10: Sistema de Rastreamento de Posição do Objeto

Defina uma região "centralizada" (ex: 220 < x < 280 e 160 < y < 210). Se o objeto estiver fora, ajuste servos pan e tilt conforme:

def mapServoPosition(x, y):
    global panAngle, tiltAngle
    if x < 220:
        panAngle = min(panAngle + 10, 140)
        positionServo(panServo, panAngle)
    if x > 280:
        panAngle = max(panAngle - 10, 40)
        positionServo(panServo, panAngle)
    if y < 160:
        tiltAngle = min(tiltAngle + 10, 140)
        positionServo(tiltServo, tiltAngle)
    if y > 210:
        tiltAngle = max(tiltAngle - 10, 40)
        positionServo(tiltServo, tiltAngle)

O helper positionServo(servo, angle) simplesmente chama angleServoCtrl.py:

import os
def positionServo(servo, angle):
    os.system(f'python angleServoCtrl.py {servo} {angle}')
    print(f'[INFO] Posicionando servo GPIO {servo} a {angle}°')

Todos os scripts estão no mesmo diretório; baixe a implementação completa em objectDetectTrack.py.

Passo 11: Conclusão

Este projeto demonstra como combinar OpenCV, GPIO do Raspberry Pi e montagem pan-tilt de servos para criar um sistema autônomo de rastreamento de objetos coloridos. Sinta-se à vontade para experimentar com diferentes cores, formas e velocidades de servo.

Código completo e recursos adicionais disponíveis no GitHub e blog MJRoBot.org.

Obrigado por ler — até o próximo tutorial!

Processo de manufatura

  1. Dominando Programação Orientada a Objetos em Python: Classes, Herança, Encapsulamento e Polimorfismo
  2. Rastreamento Avançado de Bolas de Tênis de Mesa com OpenCV no Raspberry Pi
  3. Speathe: Comunicação Guiada pela Respiração para Usuários Paralizados
  4. Reconhecimento Facial em Tempo Real no Raspberry Pi – Guia Completo
  5. Programação Orientada a Objetos em Python: Guia Completo
  6. Medindo Precisão de Rastreamento de Objetos Dinâmicos em Sistemas de Captura de Movimento
  7. Novo Filtro Melhora Visão Robô para Estimativa Precisa de Pose 6-D
  8. Máquinas de Prensa Automáticas: Função, Benefícios e Aplicações
  9. Entendendo Prensas de Potência Automáticas: Características, Benefícios e Aplicações
  10. Dobradores de Tubos Automáticos: Funções, Benefícios e Aplicações