Cabeça de manequim de localização de som com Kinect: 9 etapas (com imagens)

2024 Autor: John Day | [email protected]. Última modificação: 2024-01-30 11:34

Conheça Margaret, um manequim de teste para um sistema de monitoramento de fadiga do motorista. Ela recentemente se aposentou de suas funções e encontrou seu caminho para o nosso escritório, e desde então tem chamado a atenção daqueles que a acham 'assustadora'. No interesse da justiça, dei a ela a capacidade de enfrentar seus acusadores de frente; em vez de aparentemente seguir você com seu olhar sem alma, agora ela realmente o faz. O sistema usa o conjunto de microfones de um Microsoft Kinect e um servo para orientá-la na direção das pessoas que falam perto dela.

Etapa 1: Teoria

Calculando o ângulo

Quando ouvimos algo, a menos que esse ruído esteja diretamente à nossa frente, ele atinge um ouvido antes do outro. Nossos cérebros percebem esse atraso de chegada e o convertem em uma direção geral de onde o ruído está vindo, permitindo-nos encontrar a fonte. Podemos obter exatamente o mesmo tipo de localização usando um par de microfones. Considere o diagrama mostrado, que contém um par de microfone e uma fonte de som. Se estivermos olhando de cima para baixo, as ondas sonoras são circulares, mas se a distância até a fonte for grande em relação ao espaçamento entre os microfones, do ponto de vista de nossos sensores a onda é aproximadamente plana. Isso é conhecido como suposição de campo distante e simplifica a geometria do nosso problema.

Portanto, suponha que a frente de onda seja uma linha reta. Se o som estiver vindo da direita, ele atingirá o microfone # 2 no tempo t2 e o microfone # 1 no tempo t1. A distância d que o som percorreu entre atingir o microfone # 2 e o microfone # 1 é a diferença de tempo na detecção do som multiplicada pela velocidade do som v s:

d = v s * (t1-t2) = vs * Δt

Podemos relacionar esta distância com a distância d 12 entre o par de microfones e o ângulo θ do par para a fonte de som com a relação:

cos (θ) = d / d 12 = vs * Δt / d12

Como temos apenas dois microfones, haverá ambigüidade em nosso cálculo sobre se a fonte de som está na frente ou atrás de nós. Neste sistema, vamos supor que a fonte de som está na frente do par e fixar o ângulo entre 0 graus (totalmente à direita do par) a 180 graus (totalmente à esquerda).

Finalmente, podemos resolver para teta tomando o cosseno inverso:

θ = acos (vs * Δt / d12), 0 <= θ <= π

Para tornar o ângulo um pouco mais natural, podemos subtrair 90 graus de teta, de modo que 0 grau seja diretamente à frente do par e +/- 90 graus totalmente à esquerda ou totalmente à direita. Isso muda nossa expressão do cosseno inverso para o seno inverso.

• cos (θ-π / 2) = sin (θ) = d / d12 = vs * Δt / d12

• θ = asin (vs * Δt / d12), -π / 2 <= θ <= π / 2

Encontrando o Atraso

Como você pode ver na equação acima, tudo o que precisamos resolver para o ângulo é o atraso na onda sonora que chega ao microfone um em comparação com o microfone dois; a velocidade do som e a distância entre os microfones são fixas e conhecidas. Para fazer isso, primeiro amostramos os sinais de áudio na frequência fs, convertendo-os de analógico em digital e armazenando os dados para uso posterior. Fazemos a amostragem por um período de tempo conhecido como janela de amostragem, que é de duração suficiente para capturar características distinguíveis de nossa onda sonora. Por exemplo, nossa janela pode ser o valor do último meio segundo de dados de áudio.

Depois de obter os sinais de áudio em janela, encontramos o atraso entre os dois calculando sua correlação cruzada. Para calcular a correlação cruzada, mantemos o sinal de janela de um microfone fixo e deslizamos o segundo sinal ao longo do eixo do tempo, de trás do primeiro para todo o caminho à frente do primeiro. Em cada etapa ao longo de nosso slide, multiplicamos cada ponto em nosso sinal fixo por seu ponto correspondente em nosso sinal deslizante e, em seguida, somamos todos os resultados para calcular nosso coeficiente de correlação para essa etapa. Depois de completar nosso slide, a etapa que tem o maior coeficiente de correlação corresponde ao ponto onde os dois sinais são mais semelhantes, e em que etapa estamos nos informa em quantas amostras n o sinal dois está deslocado do sinal 1. Se n for negativo, então o sinal dois está atrasado em relação ao sinal um, se for positivo, o sinal dois está à frente e, se for zero, os dois já estão alinhados. Convertemos este deslocamento de amostra em um atraso de tempo usando nossa frequência de amostragem com a relação Δt = n / fs, assim:

θ = asin (vs * n / (d12 * fs)), -π / 2 <= θ <= π / 2

Etapa 2: Componentes

Peças

• Microsoft Kinect para Xbox 360, modelo 1414 ou 1473. O Kinect tem quatro microfones dispostos em uma matriz linear que usaremos.
• Adaptador para converter o conector proprietário do Kinect em alimentação USB + CA como este.
• Raspberry Pi 2 ou 3 executando Raspbian Stretch. Eu originalmente tentei usar um Pi 1 Model B +, mas não era poderoso o suficiente. Continuei tendo problemas para me desconectar do Kinect.
• A cabeça de manequim mais assustadora que você pode encontrar
• Um servo analógico forte o suficiente para virar a cabeça de seu manequim
• Um carregador de parede USB de 5V com amperagem suficiente para alimentar o Pi e o servo e pelo menos duas portas. (Eu usei um plugue de 3 portas 5A semelhante a este
• Um cabo de extensão com duas tomadas (uma para o carregador de parede USB e outra para o adaptador AC Kinect.
• Dois cabos USB: um cabo tipo A para micro-USB para alimentar o Pi e outro para alimentar o servo que você não se importa em cortar
• Uma plataforma para tudo se sentar e outra plataforma menor para a cabeça do manequim. Usei uma bandeja de servir de plástico como base e um prato de plástico como plataforma principal. Ambos eram do Walmart e custavam apenas alguns dólares
• 4x # 8-32 1/2 "parafusos e porcas para prender seu servo à plataforma maior
• 2 parafusos M3 de 8 mm com arruelas (ou qualquer tamanho que você precise para anexar o chifre do servo à plataforma menor)
• Dois fios de ligação macho para macho, um vermelho e um preto, e um cabo de ligação fêmea para macho
• Tiras de velcro com parte posterior adesiva
• Fita isolante
• Fita adesiva para gerenciamento de cabos

Ferramentas

• Dremel com roda de corte
• Furar
• Brocas de 7/64 ", 11/16" e 5/16"
• Torneira M3 (opcional, dependendo da buzina do seu servo)
• Chave de fenda
• Ferro de soldar com solda
• Mãos que ajudam (opcional)
• Marcador
• Bússola
• Decapantes de arame
• Multímetro (opcional)

EPI

• Óculos de segurança

• Máscara facial (para brocas de plástico).

Etapa 3: Montagem da plataforma inferior

A primeira parte que faremos é a plataforma inferior, que abrigará nosso Kinect, servo e todos os nossos eletrônicos. Para fazer a plataforma, você precisará de:

• Bandeja de servir de plástico
• Servo
• 4x # 8-32 parafusos de 1/2 "com porcas
• Dremel com roda de corte
• Chave de fenda
• Furar
• Broca 11/16"
• Marcador

Como fazer

1. Vire sua bandeja de cabeça para baixo.
2. Coloque seu servo lateralmente próximo à parte de trás da bandeja, certifique-se de que a engrenagem de saída do servo esteja ao longo da linha central da bandeja e marque ao redor da base do servo.
3. Usando a dremel e a roda de corte, corte a área que você marcou e, em seguida, deslize o servo para dentro da ranhura.
4. Marque os centros dos orifícios de montagem da carcaça do servo na bandeja, remova o servo e faça os orifícios com sua broca de 11/16 ". É muito fácil quebrar um plástico fino como este ao fazer orifícios, então acho muito mais seguro para executar a broca ao contrário e lentamente talhar o material. É muito mais lento do que fazer os furos corretamente, mas garante que não haja rachaduras.
5. Coloque seu servo de volta no slot e monte-o na bandeja com os parafusos e porcas # 8-32.

Etapa 4: Montagem da plataforma da cabeça

A próxima parte que faremos será uma plataforma para conectar a cabeça do manequim ao servo. Para fazer a plataforma principal, você precisará de:

• Prato de plástico
• Chifre de servo
• 2 parafusos M3 de 8 mm com arruelas
• Chave de fenda
• Furar
• Brocas de 7/64 "e 5/16"
• Bússola
• Dremel com roda de corte

Como fazer

1. Defina sua bússola para o raio da base de sua cabeça de manequim.
2. Use sua bússola para marcar um círculo centralizado no centro da placa. Este será o tamanho real de nossa plataforma principal.
3. Use a dremel e a roda de corte para cortar a plataforma menor da placa.
4. Perfure o centro de sua nova plataforma com uma broca de 5/16 ". Isso nos dará acesso ao parafuso que monta nosso chifre de servo ao nosso servo. Para dar estabilidade à plataforma enquanto perfuro o orifício, coloquei um carretel de fio embaixo dele e perfurado no centro do carretel.
5. Alinhe sua buzina servo com o centro da plataforma e marque dois orifícios para prender a buzina à plataforma. Certifique-se de que esses orifícios de montagem estejam distantes o suficiente para que haja espaço para as cabeças dos parafusos M3 e arruelas.
6. Faça os furos marcados com uma broca de 7/64 ".
7. O orifício inferior do meu chifre servo era liso, ou seja, não tinha as roscas para o parafuso M3. Assim, usei minha broca e uma torneira M3 para fazer os fios.
8. Use os parafusos e arruelas para prender o chifre do servo à plataforma principal.

Etapa 5: Cabo de alimentação servo

Os servos analógicos são normalmente alimentados com 4,8-6V. Como o Raspberry Pi já será alimentado por 5 V de USB, simplificaremos nosso sistema também alimentando o servo via USB. Para fazer isso, precisaremos modificar um cabo USB. Para fazer o cabo de alimentação servo, você precisará de:

• Cabo USB sobressalente com extremidade tipo A (do tipo que se conecta ao computador)
• Um fio jumper vermelho e um preto
• Ferro de solda
• Solda
• Decapantes de arame
• Fita isolante
• Mãos que ajudam (opcional)
• Multímetro (opcional)

Como fazer

1. Corte o conector não USB tipo A do cabo e, em seguida, remova um pouco do isolamento para revelar os quatro fios internos. Corte a blindagem ao redor dos fios expostos.
2. Normalmente, o cabo USB terá quatro fios: dois para transmissão e recepção de dados e dois para alimentação e aterramento. Estamos interessados em energia e aterramento, que são comumente vermelhos e pretos, respectivamente. Retire parte do isolamento dos fios vermelho e preto e corte os fios verde e branco. Se você estiver preocupado por não ter os fios de alimentação e aterramento corretos, conecte o cabo ao adaptador de alimentação USB e verifique a tensão de saída com um multímetro.
3. Em seguida, corte uma extremidade dos cabos jumper vermelho e preto e remova parte do isolamento.
4. Agora, torça os fios pretos expostos do jumper e dos cabos USB. Cruze os centros dos fios expostos e torça-os um ao redor do outro. Em seguida, aplique solda aos fios acoplados para mantê-los juntos. A ajuda de mãos tornará isso mais fácil, segurando os cabos no lugar.
5. Repita a etapa 4 para os fios vermelhos.
6. Cubra a fiação exposta com fita isolante ou tubo termorretrátil, se quiser. Essas juntas serão frágeis, pois os fios são muito pequenos, portanto, adicione uma segunda camada de fita segurando os cabos de ligação ao isolamento externo do cabo USB. Isso tornará a montagem mais rígida e, portanto, menos propensa a quebrar ao ser dobrada.

Etapa 6: Montagem de eletrônicos

Finalmente, vamos juntar tudo, montando nossos eletrônicos e tudo o mais na plataforma inferior. Você vai precisar de:

• Plataforma inferior
• Plataforma principal
• Cabeça de manequim
• Kinect com adaptador USB + AC
• Adaptador de alimentação USB
• Cabo de extensão
• Cabo micro usb
• Servo cabo de alimentação
• Raspberry Pi
• Cabo jumper macho-fêmea
• Velcro Adesivo
• Tesoura

Como fazer

1. Monte o Pi no fundo da bandeja com velcro.
2. Conecte o adaptador de alimentação USB com Velcro.
3. Conecte o servo e o Pi no adaptador de alimentação USB.
4. Conecte o pino 12 (GPIO18) do Pi ao cabo de sinal do servo. É o sexto pino à direita.
5. Passe o cabo de extensão pela alça traseira da bandeja e conecte o adaptador de alimentação USB em um lado.
6. Pegue o adaptador Kinect USB + AC e conecte o adaptador de energia no outro lado do cabo de extensão e o USB no Pi.
7. Passe o cabo do Kinect pela alça frontal da bandeja e conecte-o ao adaptador Kinect.
8. Usei fita adesiva para prender os cabos na parte inferior da plataforma. Isso não parece muito elegante, mas felizmente tudo isso está escondido.
9. Vire a plataforma com o lado direito para cima e use Velcro para montar o Kinect na frente da plataforma.
10. Use o velcro para montar a cabeça do manequim na plataforma principal. Depois que tudo estiver alinhado, no entanto, separe as duas peças para que possamos acessar o parafuso de montagem da buzina do servo. Não aparafuse a buzina ao servo ainda, pois precisamos primeiro ter certeza de que o servo está na posição central para que possamos alinhar tudo. Faremos isso em uma etapa posterior.

Etapa 7: Software e Algoritmo

Visão geral

O software para este projeto é escrito em C ++ e está integrado ao Robot Operating System (ROS), um framework para escrever software de robótica. No ROS, o software de um sistema é dividido em uma coleção de programas chamados de nós, onde cada nó implementa uma subseção específica da funcionalidade do sistema. Os dados são transmitidos entre os nós usando um método de publicação / assinatura, em que os nós que estão produzindo os dados os publicam e os nós que consomem os dados os assinam. O desacoplamento do código dessa maneira permite que a funcionalidade do sistema seja facilmente expandida e permite que os nós sejam compartilhados entre os sistemas para um desenvolvimento mais rápido.

Neste sistema, o ROS é usado principalmente para separar o código que calcula a direção de chegada (DOA) da fonte de som do código que controla o servo, permitindo que outros projetos incluam a estimativa do Kinect DOA sem incluir o código do servo que eles podem não precisar ou querer. Se você deseja examinar o código em si, ele pode ser encontrado no GitHub:

github.com/raikaDial/kinect_doa

Nó Kinect DOA

O nó kinect_doa é a carne e os ossos deste sistema, fazendo basicamente tudo de interessante. Na inicialização, ele inicializa o nó ROS, possibilitando toda a mágica do ROS e, em seguida, carrega o firmware para o Kinect para que os fluxos de áudio fiquem disponíveis. Em seguida, ele gera um novo thread que abre os fluxos de áudio e começa a ler os dados do microfone. O Kinect faz a amostragem de seus quatro microfones a uma frequência de 16 kHz cada, então é bom ter a correlação cruzada e a coleta de dados em threads separados para evitar a perda de dados devido à carga computacional. A interface com o Kinect é realizada usando libfreenect, um driver de código aberto popular.

O encadeamento de coleta executa uma função de retorno de chamada sempre que novos dados são recebidos e ambos os armazena e determina quando estimar o DOA. Os dados de cada microfone são armazenados em buffers de rolagem iguais em comprimento à nossa janela de amostragem, que aqui é de 8192 amostras. Isso se traduz em calcular a correlação cruzada com cerca de meio segundo de dados, o que descobri por meio de experimentos ser um bom equilíbrio entre desempenho e carga computacional. A estimativa DOA é acionada para cada 4096 amostras sinalizando o thread principal, de modo que correlações cruzadas consecutivas se sobreponham em 50%. Considere um caso em que não há sobreposição e você faz um ruído muito rápido que é cortado pela metade pela janela de amostragem. Antes e depois, seu som distinto provavelmente será ruído branco, que pode ser difícil de alinhar com a correlação cruzada. As janelas sobrepostas nos fornecem uma amostra mais completa do som, aumentando a confiabilidade de nossa correlação cruzada ao nos dar recursos mais distintos para alinhar.

O encadeamento principal espera pelo sinal do encadeamento de coleta e, a seguir, calcula a estimativa DOA. Primeiro, porém, ele verifica se as formas de onda capturadas são ou não significativamente diferentes do ruído branco. Sem essa verificação, estaríamos computando nossa estimativa quatro vezes por segundo, independentemente de haver ruídos interessantes ou não, e nossa cabeça de manequim seria uma bagunça espástica. O algoritmo de detecção de ruído branco usado neste sistema é o primeiro dos dois listados aqui. Calculamos a razão entre a integral absoluta da derivada de nossa forma de onda e sua integral absoluta; para sinais com alto conteúdo de ruído branco, essa proporção é maior do que para sinais menos ruidosos. Ao definir um limite para esta relação que separa o ruído do não ruído, podemos acionar a correlação cruzada somente quando apropriado. Claro, essa proporção é algo que deve ser reajustado toda vez que o sistema é movido para um novo ambiente.

Depois de determinar que as formas de onda contêm um conteúdo significativo de não ruído, o programa prossegue com as correlações cruzadas. No entanto, existem três otimizações importantes incorporadas a esses cálculos:

1. Existem quatro microfones no Kinect, o que significa que há seis pares de formas de onda que podemos correlacionar. No entanto, se você observar o arranjo espacial da matriz de microfones, verá que os microfones 2, 3 e 4 estão muito próximos um do outro. Na verdade, eles estão tão próximos que devido à velocidade do som e nossa frequência de amostragem as formas de onda recebidas em 2, 3 e 4 serão separadas por no máximo uma amostra à frente ou atrás, o que podemos verificar com o cálculo maxlag = Δd * fs / vs, onde Δd é a separação do par de microfones, fs é a frequência de amostragem e vs é a velocidade do som. Assim, correlacionar pares entre esses três é inútil, e só precisamos correlacionar o microfone 1 com 2, 3 e 4.
2. A correlação cruzada padrão de sinais de áudio é conhecida por ter um desempenho ruim na presença de reverberações (ecos). Uma alternativa robusta é conhecida como correlação cruzada generalizada com transformada de fase (GCC-PHAT). Esse método se resume a aplicar uma função de ponderação que amplifica os picos na correlação cruzada, tornando mais fácil distinguir o sinal original dos ecos. Eu comparei o desempenho do GCC-PHAT com a correlação cruzada simples em uma câmara de reverberação (leia-se: banheiro de concreto sendo remodelado) e descobri que o GCC-PHAT é 7 vezes mais eficaz na estimativa do ângulo correto.
3. Ao realizar a correlação cruzada, estamos pegando os dois sinais, deslizando um ao longo do outro e, a cada etapa, multiplicando cada ponto em nosso sinal fixo por cada ponto em nosso sinal deslizante. Para dois sinais de comprimento n, isso resulta em n ^ 2 cálculos. Poderíamos melhorar isso realizando a correlação cruzada no domínio da frequência, que envolve uma transformação rápida de Fourier (cálculos nlogn), multiplicando cada ponto em um sinal transformado pelo ponto correspondente no outro (cálculos n) e, em seguida, realizando um inverso transformada de Fourier para voltar ao domínio do tempo (cálculos nlogn), resultando em n + 2 * cálculos nlogn, menos do que n ^ 2. No entanto, essa é uma abordagem ingênua. Os microfones em nossa matriz estão tão próximos e a velocidade do som é tão relativamente lenta que as formas de onda de áudio já estarão quase totalmente alinhadas. Assim, podemos criar uma janela de nossa correlação cruzada para considerar apenas os deslocamentos que estão um pouco à frente ou atrás. Para os microfones 1 e 4, o atraso deve ficar entre +/- 12 amostras, o que significa que para cada correlação cruzada precisamos apenas realizar cálculos de 24 * n, resultando em economia computacional quando nossas formas de onda são maiores que 2.900 amostras.

Este sistema aproveita a biblioteca minidsp, que implementa o algoritmo GCC-PHAT com otimização 3.

Depois de encontrar o atraso nos sinais de cada par de microfone, o programa escolhe o valor mediano para o atraso, usa-o para calcular o ângulo estimado e publica o resultado para que possa ser usado para controlar o servo.

Nó de servo controle

Comparado ao nó kinect_doa, o nó servo é relativamente simples. Seu trabalho é apenas pegar o DOA estimado e mover o servo para aquele ângulo. Ele usa a biblioteca wiringPi para acessar o módulo PWM de hardware do Raspberry Pi, usando-o para definir o ângulo do servo. A maioria dos servos analógicos são controlados por um sinal PWM com uma largura de pulso variando de 1000 µs a 2000 µs, correspondendo a um ângulo de 0 ° a 180 °, mas o servo que eu usei era controlado com 500 µs a 2500 µs, correspondendo a um ângulo de 0 ° a 270 °. Assim, o nó é configurável para diferentes servo hardware, definindo parâmetros para a largura de pulso mínima, largura de pulso máxima e a diferença entre os ângulos máximo e mínimo. Além disso, o servo não se move imediatamente para o ângulo alvo, mas em vez disso se move em direção ao ângulo em uma velocidade configurável, dando a Margaret uma vibração mais gradual e assustadora (além disso, o som de um servo movendo-se rapidamente para frente e para trás fica irritante muito rápido)

Etapa 8: construção e instalação

Dependências de instalação:

Primeiro, instale o libfreenect. Temos que construí-lo a partir do código-fonte porque a versão que você pode obter com o gerenciador de pacotes não inclui suporte para áudio. Isso ocorre porque devemos carregar o firmware para o Kinect para habilitar o áudio, e redistribuir esse firmware não é legal em certas jurisdições. Além disso, podemos evitar a construção de exemplos que requerem OpenGL e excesso, desnecessários para instalações Raspbian sem cabeça.

sudo apt-get install git cmake build-essential libusb-1.0-0-dev

cd git clone https://github.com/OpenKinect/libfreenect cd libfreenect mkdir build cd build cmake.. -DCMAKE_BUILD_REDIST_PACKAGE = OFF -DCMAKE_BUILD_EXAMPLES = OFF make sudo make install sudo cp ~ / libfreenect / platform / linux / udev / 51-kinect.rules /etc/udev/rules.d udevadm control --reload-rules && udevadm trigger

Em seguida, precisamos instalar o pacote wiringPi, que nos permite controlar os pinos GPIO do Pi:

CD

git clone git: //git.drogon.net/wiringPi cd ~ / wiringPi./build

Anexar cabeça de manequim:

Com o wiringPi instalado, podemos agora fazer um rápido desvio de volta ao terreno das ferragens para prender a cabeça do manequim na plataforma inferior. Para centralizar o servo por meio da linha de comando, digite os seguintes comandos:

gpio pwm-ms

gpio pwmc 192 gpio pwmr 2000 gpio -g pwm 18 150

Se não houver movimento, então seu servo provavelmente já está centrado. Para ter certeza, porém, você pode definir o servo para um valor não central, por exemplo, gpio -g pwm 18 200 e, em seguida, defina-o de volta para 150.

Quando tiver certeza de que o servo está centralizado, conecte o chifre do servo da plataforma da cabeça ao servo de forma que a cabeça do manequim fique voltada para a frente. Em seguida, aparafuse o chifre no servo e prenda sua cabeça com as pontas de velcro.

Instale ROS:

Em seguida, instale o ROS em seu Pi. Um ótimo guia de instalação pode ser encontrado aqui; para nosso sistema, não precisamos do OpenCV, portanto, você pode pular a etapa 3. Esta compilação levará várias horas para ser concluída. Quando terminar de seguir o guia de instalação, adicione a origem da instalação ao seu bashrc para que possamos usar nossos pacotes ROS recém-instalados:

echo "source /opt/ros/kinetic/setup.bash" >> ~ /.bashrc

Pacote Kinect DOA:

Depois de fazer tudo isso, crie um espaço de trabalho catkin para o nosso projeto e insira o diretório src:

mkdir -p ~ / kinect_doa_ws / src

cd ~ / kinect_doa_ws / src

O código para este projeto está contido no pacote kinect_doa, portanto, clone-o no diretório src do seu novo espaço de trabalho:

git clone

O pacote robot_upstart fornece uma ferramenta fácil de usar para instalar arquivos de inicialização para que sejam executados na inicialização, portanto, também clone isso em seu espaço de trabalho:

git clone

Agora, podemos construir o código do projeto chamando catkin_make do diretório de nível superior de nosso espaço de trabalho e, em seguida, fornecer nossa construção para que nossos pacotes estejam disponíveis:

cd ~ / kinect_doa_ws

catkin_make echo "source /home/pi/kinect_doa_ws/devel/setup.bash" >> ~ /.bashrc

Executando e ajustando:

Supondo que tudo esteja conectado e ligado, você deve conseguir iniciar o sistema e fazer com que o Kinect rastreie sua voz! No entanto, se você tiver um Kinect 1473, primeiro abra o arquivo ~ / kinect_doa_ws / src / kinect_doa / launch / kinect_doa.launch em um editor de texto e defina o parâmetro using_kinect_1473 como verdadeiro. Além disso, se você usou um servo diferente do que eu usei, provavelmente é um servo analógico padrão. Portanto, enquanto estiver no arquivo de inicialização, altere o parâmetro min_us para 1000, max_us para 2000 e max_deg para 180.

roslaunch kinect_doa kinect_doa.launch

Brinque com isso por um tempo. Se você acha que o sistema é muito sensível (olhando em direções aleatórias que não correspondem a vozes ou ruídos distintos), tente alterar o parâmetro white_noise_ratio no arquivo de inicialização e reiniciar o sistema até que a capacidade de resposta esteja em um nível que você esteja confortável. Aumentar a proporção tornará o sistema menos responsivo e vice-versa. Provavelmente, você terá que realizar esse ajuste sempre que mover o sistema para um local diferente para obter o desempenho desejado.

Para iniciar o programa quando ligamos o Pi, usamos o pacote robot_upstart para instalar nosso arquivo de inicialização. Se o ROS não estiver em execução, inicie-o com o comando roscore. Em seguida, abra um novo terminal e instale o lançamento com:

rosrun robot_upstart install kinect_doa / launch / kinect_doa.launch --user root --symlink

Criamos um link simbólico para o arquivo de inicialização em vez de copiá-lo para que possamos alterar os parâmetros editando ~ / kinect_doa_ws / src / kinect_doa / launch / kinect_doa.launch.

Etapa 9: Escondendo no escritório

Agora a parte divertida. Vá para o trabalho após o expediente e coloque a cabeça do seu manequim em segredo. Em seguida, é só sentar e ver quanto tempo leva para seus colegas de trabalho entenderem! Sua nova criação com certeza vai virar algumas cabeças …