Autor: admin

Making of EEZYbotARM MK2

Após ter feito um braço robótico EEZYbotARM (MK1), em que não cumpri exactamente as instruções pois não encontrei o tubo, e de ter tentado sem sucesso criar uma descrição do braço num ficheiro URDF, iniciei a construção do EEZYbotARM MK2.

O braço EEZYbotARM MK2, tal como o MK1 tem os ficheiros STL disponiveis para podermos imprimir parte das suas peças mecânicas numa impressora 3D e está descrito nos seguintes links:

  • http://www.eezyrobots.it/eba_mk2.html
  • https://www.thingiverse.com/thing:1454048
  • https://www.instructables.com/id/EEZYbotARM-Mk2-3D-Printed-Robot/

As partes mecânicas e a respectiva montagem estão bem descritas nos links acima.

A parte electrónica também tem a descrição, no artigo do instructables, de uma das soluções possíveis que é usar o controlador USB servo Mini Maestro da Pololu.  Nesta solução o software é fornecido com o controlador e instalado no PC

Outra solução possível, conforme indicado na informação disponível no thingverse, e assim como no instructables  é usar uma app para o android e um arduino. As informações sobre esta solução estão disponíveis em:

  • https://www.instructables.com/id/Android-APP-to-Control-a-3DPrinted-Robot/

A ideia de fazer este braço róbotico é também usa-lo com o ROS conforme exposto no seguinte link:

https://hotblackrobotics.github.io/en/blog/2018/01/17/ntbd-guide-part-I/

Existe também o seguinte trabalho que descreve o uso do braço robótico EEZYbotARM MK2 com o ROS:

eezyarm_APIEMS2019_paper_259

No entanto este documento não informa nem sobre o sobre qual a electrónica e software usado.

Por ultimo também será possível implementar o controlo do braço recorrendo ao ROS moveit.

Parte 1: Aquisição das peças necessárias para o braço robótico

As peças necessárias são 4 servos, esferas, um rolamento e um conjunto de diversas porcas, parafusos e anilhas.

3 x Servo Tower Pro MG955 ou MG946 ou MG996
1 x SG90 SERVO

1 x rolamento 606zz (6mm x 17mm x 6mm)

32 x esferas 6mm (diametro)

2 x parafuso M3 x 10 mm fenda
5 x parafuso M3 x 20 mm
2 x parafuso M3 x 25 mm
5 x parafuso M4 x 20 mm
1 x parafuso M4 x 35 mm ( original: 1 x parafuso M4 x 30)
1 x parafuso M4 x 50 mm ( original: 1 x parafuso M4 x 40)
1 x parafuso M6 x 25 mm

1 x varão roscado M4 x 32 mm
1 x varão roscado M4 x 60 mm

3 x porca M3
5 x porca M3 auto-bloqueante
9 x porca M4 auto-bloqueante
1 x porca M6  auto-bloqueante

2 x anilha M3
8 x anilha M4
1 x anilha M6

Esta lista de materiais pode ser ligeiramente diferente da original, por exemplo uso mais esferas, e em alguns pormenores, como por exemplo os parafusos, não tem de ser exactamente igual.

Parte 2: Impressão dos componentes para o braço robótico

Lista dos componentes impressos por ordem de impressão.

A ordem de impressão dos componentes foi escolhida de modo a ir efectuando a respectiva montagem.

Base

  • EBAmk2_001_base.STL
  • EBAmk2_010_gearservo.STL
  • EBAmk2_012_mainbase.STL
  • EBAmk2_013_lower base.STL
  • EBAmk2_011_gearmast_full.STL

Braço

  • EBAmk2_002_mainarm.STL
  • EBAmk2_003_varm.STL
  • EBAmk2_004_link135.STL
  • EBAmk2_005_link135angled.STL
  • EBAmk2_006_horarm__.STL
  • EBAmk2_007_trialink.STL
  • EBAmk2_008_link147_new.STL
  • EBAmk2_009_trialinkfront.STL

Garra

  • EBAmk2_014_claw base.STL
  • EBAmk2_015_claw finger dx.STL
  • EBAmk2_016_claw gear drive.STL
  • EBAmk2_017_claw finger sx.STL
  • EBAmk2_018_claw gear driven.STL

Cobertura da base

EBAmk2_019_drive cover.STL

Não impressos

  • EBAmk2_010_gearservo_22DENTI.STL
  • EBAmk2_011_gearmast.STL
  • EBAmk2_006_horarm_plate.STL

Parte 3: Montagem do braço róbotico

A montagem do braço robótico é efectuada em várias fases e está descrita mais abaixo. Posteriormente encontrei o seguinte video, em inglês, que explica com bastante pormenor a montagem do braço robótico.

Entre a descrição e o video creio que fica bastante claro o que é que é necessário e como se monta o braço robótico.

Montagem da base do braço robótico

A base, que é composta pelas seguintes peças:

  • Peças impressas ( 5 peças, das indicadas acima)
  • 1 x Servo MG966
  • 1 x rolamento 606 ZZ
  • 32 x esferas 6 mm
  • 2 x parafusos (1 mm x 5mm), (fixar o hub do servo à gearservo)
  • 1 x  parafuso M3 x 10 mm, (fixar o hub com engrenagem ao servo)
  • 3 x parafuso M3 x 20 mm
  • 2 x parafuso M3 x 25 mm
  • 1 x parafuso M6 x 25 mm
  • 3 x porcas M3
  • 2 x porcas M3 auto-bloqueante
  • 1 x porca M6 auto-bloqueantes
  • 1 x anilha M6
Passo 1:  montar o servo MG996R

Peças usadas:

  • 1 x 012_mainbase
  • 1 x Servo MG966
  • 4 x parafusos fornecidos com o servo

Para encaixar o servo na mainbase, retirar os 4 parafusos inferiores do servo e retirar a tampa inferior. Encaixar o servo na posição, colocar a tampa e voltar a colocar os parafusos no sitio.

A mainbase não tem os furos para fixar o servo. Fazer os furos com um arame fino e quente. De seguida Usar os 4 parafusos para fixar o servo à mainbase. 

Passo 2: Montar o suporte das esferas com o rolamento

Peças usadas

  • 1 x 013_lower base.STL
  • 3 x parafuso M3 x 20 mm
  • 3 x porcas M3
  • 1 x rolamento 606 ZZ

Primeiro encaixam-se as 3 porcas M3 nos locais apropriados. Provavelmente será necessário limar um pouco, ou aquecer as porcas, de modo a conseguir encaixar devidamente as porcas.

De seguida encaixa-se o rolamento no espaço destinado ao efeito e aplica-se os respectivos parafusos de modo a fixar a base

 

Passo 3: aplicar a engrenagem ao servo

Peças usadas

  • 1 x 010_gearservo
  • 1 x  parafuso M3 x 10 mm
  • 1 x suporte circular para o eixo do servo (fornecido com o servo)

Antes de aplicar a engrenagem verificar se está bem impressa e eventualmente retirar algum imperfeição ou algum plástico a mais que se tenha acumulado nas primeiros camadas.

Também convém determinar qual é a amplitude do servo, o seu mínimo, máximo e centro. Deixando o servo posicionado ao centro.

Aplicar o suporte circular préviamente encaixado  à engrenagem no eixo do servo (e eventualmente fixo com 2 parafusos pequenos). Fixar o conjunto com o parafuso M3.

Passo 4: aplicar as esferas e montar a base rotativa

Peças usadas

  • 1 x 001_base.STL
  • 1 x 011_gearmast_full
  • 32 x esferas 6 mm
  • 2 x parafuso M3 x 25 mm (com 2 porcas fixar a gearmaster à base)
  • 1 x parafuso M6 x 25 mm
  • 2 x porcas M3 auto-bloqueantes
  • 1 x porca autoblocante M6
  • 1 x anilha M6

Antes de aplicar a engrenagem verificar se está bem impressa e eventualmente retirar algum imperfeição ou algum plástico a mais que se tenha acumulado nas primeiros camadas.

Numa primeira fase, aplicar a porca auto-bloqueantes M6 no local apropriado na parte de baixo da base.

De seguida aplicar o gearmaster com o rebordo de acondicionamento das esferas para baixo, na parte de baixo da base, fixando-o com 2 parafusos M3 de 25 mm e 2 porcas auto-bloqueantes M3.

Depois de preparar a base com a engrenagem colocar as esferas no socalco apropriado e manter peça na vertical de modo a que as esferas se mantenham na devida posição.

De seguida encaixar a base com engrenagem na engrenagem do servo sem deixar fugir as esferas.

Fixar os dois elementos com o parafuso M6, com anilha, que enrosca na porca M6 préviamente colocada na base. Apertar quanto baste de modo a não dificultar o movimento.

Montagem do braço robótico

Após finalizar a montagem da base do braço passamos a montagem do sistema de alavancas do braço que são comandadas por dois servos.

Esta parte do braço robótico, é composto pelas seguintes peças:

  • Peças impressas ( 8 peças, das indicadas acima)
  • 1 x Varão roscado M4 com 32 mm
  • 8 x parafusos fixadores do servo

 

Passo 5: aplicar as alavancas principais do braço

Peças usadas:

  • 002_mainarm
  • 003_varm
  • 1 x varão roscado M4 com 32 mm
  • 8 x parafusos fixadores do servo

Antes de começar este passo, determinar qual é a amplitude dos servos, o seu mínimo, máximo e centro. Deixar os servos posicionados ao centro.

Também deve preparar o fixador para o eixo do servo, pois é necessário retirar uma aba ao fixador longitudinal (o que tem 2 abas)

Como os buracos onde vai passar o varão roscado estão com certeza muito apertados deve-se afinar o seu diâmetro com uma lima redonda até o varão roscado deslizar sem muito atrito nos diversos orifícios das 2 hastes impressas.

Na primeira fase deste passo, coloca-se a haste maior (002_mainarm) no local adequado (com a curvatura para o lado da pequena haste existente base), insere-se de seguida o varão roscado M4 com 32 mm.

Na segunda fase, coloca-se a haste mais pequena (003_varm) e avança-se o varão roscado até estar a face nos dois lados.

Com o eixo dos servos posicionado na posição central, aplica-se o fixador no eixo dos servos. De acordo com o seguinte procedimento:

Na haste grande, o fixador fica a apontar para cima. Na haste pequena o fixador fica a apontar para o lado da haste, que fica mais ou menos na horizontal. Para montar o fixador, deve-se usar o parafuso que vem com os servos.

Como senti dificuldades na fixação dos servos com os parafusos. Será melhor adequar melhor os orifícios na peça impressa ao diâmetro dos parafusos que se vai usar e enroscar primeiro os parafusos mesmo sem o servo para testar primeiro.

Passo 6: montar as hastes verticais traseiras

Peças usadas

  • 004_link135
  • 005_link135angled
  • 2 x parafuso M4 x 20 mm
  • 2 x porca M4 auto-bloqueante

Preparar os buracos onde vão passar os parafusos M4 com uma lima de modo a que os parafusos deslizem e rodem sem muito atrito nos diversos orifícios das hastes (link135 e  link135angled).

Na primeira fase coloca-se a haste recta com a nervura para o lado de fora, no espaço apropriado para o efeito.

Fixa-se com um parafuso M4 de 20 mm e uma porca M4 auto-bloqueante. O aperto ao parafuso deve ser dado de forma a que o movimento não sofra atrito.

Na segunda fase, coloca-se a haste curvada com a nervura para o lado de dentro, e a parte saliente da curvatura orientada para traz. Aplica-se com o parafuso M4 de 20 mm e uma porca M4 auto-bloqueante. O aperto ao parafuso deve ser dado de forma a que o movimento não sofra atrito.

Passo 7: Montar a haste horizontal e triângulo superior

Peças usadas:

  • 006_horarm__
  • 007_trialink
  • 008_link147_new
  • 1 x varão roscado M4 com 60 mm
  • 2 x parafuso M4 x 20 mm
  • 1 x parafuso M4 x 30 mm
  • 5 x porca M4 auto-bloqueante

Todos os orifícios devem ser preparados préviamente com uma lima de modo a que o varão roscado e os parafusos deslizem e rodem sem muito atrito nos diversos orifícios.

Primeiro encaixamos a haste horizontal (horarm) no local apropriado.  Seguidamente inserimos o varão roscado no orifício até ficar à face do encaixe (de forma a suster a haste).

Em segundo lugar encaixamos o triângulo (trialink) com a face plana para fora no espaço apropriado e continuamos a inserir o varão roscado (que previamente tinha ficado à face) pelo furo do triângulo. Apertar de ambos os lados com porcas M4 auto-bloqueantes.

Em terceiro lugar fixamos as duas hastes verticais na traseira da haste horizontal.

Numa primeira fase fixamos a haste com ângulos no orifício posterior na parte de dentro do triângulo com um parafuso M4 de 35 mm e uma porca M4 auto-bloqueante (este parafuso pode ser M4 25 mm).

Na fase seguinte fixamos a haste rectilínea no orifício posterior da haste horizontal, pela parte de fora, com um parafuso M4 de 20mm e uma porca M4 auto-bloqueante.

Em quarto lugar, com um parafuso M4 de 20mm e uma porca M4 auto-bloqueante, montamos a haste rectilínea maior (link147_new), por dentro no orifício do triângulo e com a nervura para fora.  

Passo 8: Montar terminação da haste horizontal

Peças usadas:

  •  009_trialinkfront
  • 1 x parafuso M4 x 35 mm
  • 1 x parafuso M4 x 50 mm
  • 2 x porca M4 auto-bloqueante

Neste passo vamos montar o suporte da garra (trialinkfront) na parte frontal da haste horizontal superior e no final da haste lateral superior.

Todos os orifícios devem ser preparados préviamente com uma lima de modo a que o varão roscado e os parafusos deslizem e rodem sem muito atrito nos diversos orifícios.

Como a garra (claw base) aplica no suporte da garra  (trialinkfront), num encaixe justo. Antes de prosseguir confirmar se as duas peças encaixam devidamente. Caso seja necessário deve desbastar a zona de encaixe no suporte da garra.

Primeiro aplica-se o suporte da garra no meio do encaixe da haste horizontal. Depois insere-se um parafuso M4 de 35mm no orifício e aperta-se uma porca M4 auto-bloqueante para o fixar.

Segundo, fixa-se a parte de cima da garra à terminação da haste lateral, com um parafuso  M4 de 50 mm no orifício e aperta-se uma porca M4 auto-bloqueante para o fixar.

Montagem da garra

Após a montagem das hastes do braço robótico a fase seguinte é montar a garra e aplicar no braço.

Passo 9: montar a garra e aplicar no suporte da garra

Peças usadas:

  • 1 x claw base
  • 1 x claw finger dx
  • 1 x claw gear drive
  • 1 x claw finger sx
  • 1 x claw gear driven
  • 1 x servo Tower Pro SG90
  • 2 x parafuso M3 com 20 mm
  • 2 x parafuso para montar servo
  • 1 x parafuso para montar suporte no eixo do servo

Todos os orifícios por onde passam os parafusos devem ser preparados préviamente com uma lima de modo a que o varão roscado e os parafusos deslizem e rodem sem muito atrito nos diversos orifícios.

A engrenagem (claw gear driven) tem duas saliências que servem como encaixe nos dois orifícios apropriados no dedo da garra (claw finger sx).

Antes de prosseguir deve certificar de que essas duas peças encaixam devidamente. Se não encaixarem deve-se desbastar os excesso nas saliências até estarem encaixarem.

O eixo do servo deve ser colocado nos zero graus. Mais tarde o fixador que é aplicado no eixo deve ficar posicionado para a frente. Deste modo quando o eixo do servo está no ângulo zero graus a garra está completamente fechada, e quando está no ângulo 180 graus  a garra está completamente aberta.

Após os procedimentos preparatórios, a primeira coisa a fazer é montar o servo no local apropriado. Para o montar devem ser usados os dois parafusos para esse efeito que vêm com o servo.

A segunda coisa a fazer é fixar a engrenagem (claw gear drive) junto com o fixador (que vem com o servo) no eixo do servo, e usar o parafuso que vem como o servo para prender o conjunto.

Em terceiro lugar, deve encaixar a engrenagem (claw gear driven) no dedo da garra (claw finger sx) e montar o conjunto alinhado com o orifício à direita na base da garra ( claw base), usando um parafuso M3 de 20 mm, uma anilha M3 e uma porca M3 auto bloqueante.

Em quarto lugar, proceder à montagem do outro dedo da garra, no orifício à esquerda na base da garra (claw base), usando um parafuso M3 de 20 mm, uma anilha M3 e uma porca M3 auto bloqueante.

Com a garra montada o ultimo passo é encaixar a garra no suporte da garra que está a haste horizontal, e fixar o conjunto com um parafuso M3 de 10 mm e uma porca M3 auto-bloqueante.

 

Finalizar a montagem da garra

Após a montagem da, base, hastes e garra do braço robótico a ultima coisa que falta da parte mecânica é a cobertura da base.

Passo 10: montar a cobertura da base

Peças usadas:

  • 019_drive cover

Para a aplicar a cobertura da base basta colocar no local e pressionar.

Com este passo, a montagem parte mecânica fica completa.

Parte 4: A electrónica de controlo do braço

Conforme indicado na introdução, o autor do braço refere as seguintes soluções:

  • controlador USB servo Mini Maestro da Pololu + sofware proprietario no pc
  • arduino uno + placa bluetooth ( HC-06) + sketch para arduino + app para android.

Para além das soluções do autor é possível ainda usar outras soluções disponíveis na internet como por exemplo:

O controlo do braço em ROS o método ntbd.

https://hotblackrobotics.github.io/en/blog/2018/01/17/ntbd-guide-part-I/

Também é possível usar outra solução testada previamente com o MK1, e que se baseia na placa PCA9685 + arduino + potenciómetros.

 

Estudo exploratório da interação homem máquina em linguagem natural no contexto visual

Pequeno relatório do estudo exploratório da interacção homem máquina em linguagem natural no contexto visual que efectuei com base num conjunto de processos ilustrados com as respectivas relações no diagrama mais abaixo.

Este abordagem à interacção homem máquina em linguagem natural tendo em conta o contexto visual da máquina, foi efectuada com o propósito de integrar o conhecimento adquirido num projecto de controlo vocal de um braço robótico Niryo One.

A solução que montei para explorar esta área está próxima do end user. Foi efectuada com o base no ROS e nos serviços do google cloud, e deste modo os principais serviços são caixas negras. Esta abordagem serve as minhas necessidades de aplicação prática já que não procuro saber como funcionam os processos mais complexos.

No entanto, alguns dos serviços remotos podem ser substituídos por soluções locais, dos quais destaco o reconhecimento de objectos e faces construídas com base no opencv e tensorflow. Uma segmentação dos custos de utilização dos serviços do google que exibo mais abaixo, sugere que serão os processos com o maior beneficio económico na execução local.

ROS nodes

Os nodes ROS usados no projecto estão contidos no opencv_apps e no meta-pacote gc_bridge, que foi adoptado de um dos vários projectos que usei para compor esta exploração.

O pacote opencv_apps contêm os nodes locais que usei para explorar esta área. A exploração dos serviços de detecção facial do google tem de ser complementada por um node que republique a informação do rectângulo no node de reconhecimento facial no opencv. (TODO. colocar no repositório)

O gc_bridge contêm vários pacotes que contribuem em conjunto com outros que surgem como dependências do projecto.

  • gc_msgs
  • gc_dialogflow_bridge
  • gc_speech_bridge
  • gc_vision_bridge

Diagrama de relações entre os vários sistemas e mensagens envolvidas

gc_bridge

Meta pacote copiado do gc_bridge (https://github.com/jihoonl/gc_bridge), e ao qual foi adicionado posteriormente os outros pacotes. De origem o gc_bridge contribuiu com o gc_msgs e o gc_vision_bridge.

gc_msgs

Este pacote contém a definição das mensagens trocadas com o serviço que processa a interacção com os serviços de análise de imagem do google.

As mensagens definidas neste pacote são usadas pelos nodes  e serviços do gc_vision_bridge.

gc_dialogflow_brigde

Foi adaptado do pacote  dialogflow_ros (https://github.com/piraka9011/dialogflow_ros). Contém o interface com o Google dialogflow services alimentado em tempo real pelo microfone, via transcrição de voz para texto, e o seu resultado alimenta o sistema de transcrição de texto para voz. O resultado dos serviços do dialogflow é construído tendo em conta a informação existente num servidor de contexto remoto, alimentado pelo os nodes do gc_vision_bridge.

gc_vision_bridge

Este pacote contem o software que processa as imagens recolhidas pelo node usb_cam, e as redirige para os nodes especializados de análise, armazenando num servidor remoto as respostas de cada um deles.

gc_speech_bridge

Este pacote foi adaptado do pacote speech_database (http://wiki.ros.org/speech_database)

Este pacote passou a incluir o node speech2text_mic.py que foi obtido no pacote (dialogflow_ros)

 

 

 

Nesta fase exploratória o leque de entendimento que se expressa no conjunto de comandos implementados visa apenas aspectos descritivos e de focalização de atenção.

Comandos implementados

  • Enunciar os objectos que detecta nas imagem da camera  de video
  • Confirmar que está a ver um objecto
  • Indicar quantos objectos é que está a ver de um tipo especifico
  • Solicitação para ignorar determinados objectos
  • Solicitação para parar de ignorar objectos previamente ignorados
  • Saudar o utilizador

 

 

 

ROS roscore service

Instruções para correr o ROS roscore como serviço

Para o efeito é necessário criar dois ficheiros novos:

  • /etc/systemd/system/roscore.service
  • /etc/roscore_env.sh

Seguidamente usar o comando systemctl para testar o serviço e  a sua activação posterior.

Criar o ficheiro para a unit roscore.service

sudo nano /etc/systemd/system/roscore.service

Substituir “kinetic” por “melodic” ou outra distribuição do ROS, na linha que começa por “ExecStart=”

Substituir “ubuntu”  pelo user adequado na linha User=ubuntu

[Unit]
After=NetworkManager.service time-sync.target
[Service]
Type=forking
User=ubuntu
# Start roscore as a fork and then wait for the tcp port to be opened
# ----------------------------------------------------------------
# Source all the environment variables, start roscore in a fork
# Since the service type is forking, systemd doesn't mark it as
# 'started' until the original process exits, so we have the
# non-forked shell wait until it can connect to the tcp opened by
# roscore, and then exit, preventing conflicts with dependant services
ExecStart=/bin/sh -c ". /opt/ros/kinetic/setup.sh; . /etc/roscore_env.sh; roscore & while ! echo exit | nc localhost  11311 > /dev/null; do sleep 1; done"
[Install]
WantedBy=multi-user.target

Criar o ficheiro com as variáveis de ambiente para o roscore

sudo nano /etc/roscore_env.sh

Colocar o seguinte texto.

#!/bin/sh
export ROS_HOSTNAME=$(hostname).local
export ROS_MASTER_URI=http://$ROS_HOSTNAME:11311

Após criar estes ficheiros passamos a fase de teste.

Teste e conclusão da configuração do serviço roscore

Para testar iniciamos o serviço e seguidamente consultamos o seu estado com os seguintes comandos:

systemctl start roscore
systemctl status roscore

Se existir algum erro verificar se o texto foi bem copiado e as substituições bem feitas. Repetir a verificação até funcionar bem.

Após o serviço iniciar correctamente activar a sua inicialização automática com o seguinte comando:

systemctl enable roscore

O processo ficou concluido e o serviço roscore irá iniciar automaticamente.

Gestão do serviço roscore

Para iniciar o serviço

systemctl start roscore

Para saber o estado do serviço

systemctl status roscore

Para parar o serviço

systemctl stop roscore

Para ligar a inicialização automática do serviço

systemctl enable roscore

Para desligar a inicialização automática do serviço

systemctl disable roscore

 

 

ros package opencv-apps

 

http://wiki.ros.org/opencv_apps

https://github.com/ros-perception/opencv_apps

Install ros opencv apps

O pacote do ros opencv apps e as suas dependencias são instalados com os seguintes comandos:

Nota: se a instalação for no kinetic, basta substituir o melodic por kinetic.

sudo apt install ros-melodic-opencv-apps
sudo apt install xterm

Também convem ter instalado uma fonte de imagens video, como pr exemplo o node usb_cam. Este node pode ser instalado com o seguinte comando:

sudo apt install ros-melodic-usb-cam

Criar o ficheiro usbcam.launch para o node usb cam  num pacote de teste com a seguinte configuração:

<launch>

  <arg name="view" default="false" />
  <arg name="tf" default="true" />

  <node if="$(arg tf)" pkg="tf" type="static_transform_publisher" name="usb_cam_tf" args="10.0 0 0.10 0 0 0 /base_link /usb_cam 10" />

  <node name="usb_cam" pkg="usb_cam" type="usb_cam_node" output="screen" >
    <param name="video_device" value="/dev/video0" />
    <param name="image_width" value="800" />
    <param name="image_height" value="600" />
    <param name="pixel_format" value="yuyv" />
    <param name="camera_frame_id" value="usb_cam" />
    <param name="io_method" value="mmap"/>
  </node>

  <node if="$(arg view)" name="image_view" pkg="image_view" type="image_view" respawn="false" output="screen">
    <remap from="image" to="/usb_cam/image_raw"/>
    <param name="autosize" value="true" />
  </node>

</launch>

Esta configuração é genérica, inclui a publicação do transform para a camera e a opção de visualização do video.

Pode ser executada com opções com o seguinte comando:

roslaunch pacote usbvideo.launch view:=true tf:=false

Funciona, pelos meus testes em várias cameras, umas capazes de maior resolução que outras, e pode ser modificada para a camera que usamos.

Configure face recognition on opencv apps

De modo a mais facil controlo sobre as configurações de lançamento dos nodes envolvidos no reconhecimento facial copiar para os ficheiros  os seguintes ficheiros launch para um pacote de teste:

  • https://raw.githubusercontent.com/ros-perception/opencv_apps/indigo/launch/face_detection.launch
  • https://raw.githubusercontent.com/ros-perception/opencv_apps/indigo/launch/face_recognition.launch

De seguida adequar as copia dos ficheiros.

No ficheiro face_recognition.launch:

O pacote usado (o nome do pacote para onde foi copiado) deve o opencv_apps, na seguinte linha:

<include file=”$(find opencv_apps)/launch/face_detection.launch”

O tópico da imagem (da camera usb) que o node subscreve, é definido pelo default deve ser trocado  pelo topico que o node usb_cam publica (normalmente /usb_cam/image_raw) na linha:

<arg name=”image” default=”image” />

No ficheiro face_detection.launch:

Proceder do modo descrito para o tópico da imagem.

Executar  o reconhecimento facial

A base de dados de faces reconhecidas fica guardada na seguinte pasta:

~/.ros/opencv_apps/face_data

Na primeira execução não existem faces na base de dados, pelo que é necessário efectuar a sua recolha de pessoas a serem reconhecidas, e uma reinicialização do programa (que deve acontecer após cada sessão de recolha).

Para iniciar o reconhecimento facial deve iniciar primeiro o node que publica a imagem da camera de video, o usb_cam.

roslaunch pacote usbcam.launch view:=false tf:=false

De seguida executar o launch file do reconhecimento facial (face_recognition.launch) com o seguinte comando:

roslaunch pacote face_recognition.launch

Este comando executa os seguintes nodes:

  • face_detection
  • face_recognition
  • face_recognition_trainer

Nesta configuração base acontece o seguinte:

O face_detection abre uma janela com circulos nas faces (e respectivos olhos) detectadas;

O face_recognition abre uma janela com circulos nas faces detectadas e indicação do rosto reconhecido;

O face_recognition_trainer abre uma janela que permite adicionar rostos a base de dados de faces a reconhecer.

A abertura destas janelas é opcional, assim como o lançamento do node de treino (face_recognition_trainer),

 

já que numa aplicação prática o resultado do reconhecimento pode ser recolhido pela subscrição do tópico: /face_recognition/output   com mensagens do tipo opencv_apps/FaceArrayStamped.

rostopic echo /face_recognition/output

header: 
seq: 2486
stamp: 
secs: 1572481537
nsecs: 290916277
frame_id: "usb_cam"
faces: 
- 
face: 
x: 372.0
y: 191.0
width: 209.0
height: 209.0
eyes: 
- 
x: 413.0
y: 177.0
width: 49.0
height: 49.0
label: "sergio"
confidence: 2279.43355205

 

roslaunch rospibot6 usbcam.launch view:=false tf:=false

roslaunch rospibot6 face_detection.launch

roslaunch rospibot6 face_recognition.launch

 

Descobri este pacote depois de ter tentado compilar o pacote face_recoginiton, com documentação no seguinte link:

http://wiki.ros.org/face_recognition

No entanto não compila nas versões mais recentes do ros.

Após efectuar o treino, o face_recgnition funciona em duas fases
na primeira detecta a face a reconhecer, e marca a região, na segunda identifica a face exibida nessa região na base de dados que alimentou o treino.

Como a base do pacote é opencv, voltei a minha atenção para ai, e mais especificamente para a documentação da versão que vem com ubuntu/bionic, e descobri este tutorial:

https://docs.opencv.org/3.2.0/da/d60/tutorial_face_main.html

O tutorial parece ser a resposta que me pode permitir fazer um node do ros para reconhecimento facial.

Consegui compilar os 3 exemplos, e do que compreendi, apenas o ultimo faz uma identificação ou não da face.

O exemplo procede à identificação da ultima face de uma base de dados experimental.

Por isso conclui que este seria um bom modelo para poder rescrever o pacote.

A fase da detecção facial está tambem descrita num tutorial do opencv disponivel no seguine endereço:

https://docs.opencv.org/…/d3a/facedetect_8cpp-example.html

Também considerei este exemplo um bom modelo para a parte que faltava.

No entanto o trabalho que tinha pela frente nao ia ser facil e por isso decidi que o melhor era procurar mais um bocado antes de tentar rescrever tudo de novo (para alem dos blocos retirados dos exemplos), que seria o que me esperava. Foi quando descobri o pacote opencv_apps.

Uma ultima nota sobre a performance da detecção facial com o opencv.

A face detection demora menos de 100ms, num portatil com um i7. No pi2 demora quase 1s (750ms).

 

ros package people

http://wiki.ros.org/people

Pelo que eu percebi necessita de uma camera stero.

Para compilar o pacote é necessário instalar as seguintes dependencias:

sudo apt install ros-melodic-easy-markers

sudo apt install ros-melodic-bfl

sudo apt install ros-melodic-kalman-filter