Robo-técnico: 8 etapas

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

Imagine por um segundo que você é um dos astronautas que pousam em Marte. Você tem um milhão de coisas para fazer, amostras para coletar, experimentos para executar, dados para coletar, mas uma ou duas vezes por dia você precisa correr ao redor da habitação e / ou módulos de pesquisa em que você vive e trabalha para inspecioná-los. É necessário, alguém tem que garantir que a coisa está em bom estado, que todas as milhares de peças e peças estão funcionando e no lugar. Mas e se houvesse um ajudante automatizado para liberá-lo de algumas dessas funções. E se houvesse um pequeno robô que pudesse se mover dentro dos módulos para se certificar de que tudo estava no lugar, funcionando e seguro.

Robo-técnico para o resgate.

Essencialmente, este código controla o Robo-Técnico à medida que segue um caminho de cor clara no solo. Ele seguirá este caminho até encontrar um cruzamento no caminho ou uma curva, que solicitará que uma foto seja tirada para processamento de imagem para permitir que o Robo-Técnico tome uma decisão sobre para onde ir em seguida. Os sensores de colisão e colisão de luz funcionam para proteger o Robo-Técnico de danos, e os sensores de colisão controlam quando uma foto de diagnóstico será tirada. Juntos, o Robo-Technician foi projetado para dar um zoom nos módulos do Mar, liberando o tempo dos astronautas durante a tarefa básica de inspeção, apenas solicitando a intervenção humana quando encontrar algo errado.

Novamente como um aviso, este é um trabalho em andamento. O código, como existe, funciona, mas apresenta soluços, especialmente porque há vários programas sobrepostos envolvidos. Além disso, para este projeto funcionar em uma missão real a Marte, um robô precisaria ser construído para esse propósito específico, então, novamente, acho que esta é uma construção de "prova de conceito".

Existem algumas coisas que você precisa para colocá-lo em funcionamento. Você precisará de um programa caro, pacotes de suporte para esse programa e um pouco de experiência em codificação. Como sou um estudante e parte do código do andar térreo foi fornecido (para o pi framboesa), não vou falar especificamente sobre a configuração. Você pode encontrar todos os links para esse código base abaixo. Vamos para a lista de materiais.

Hardware

• Raspberry Pi (usamos uma versão 3)
• iRobot ®
• algum tipo de dispositivo de retenção para manter o Raspberry Pi preso ao Robo-Técnico
• Câmera Raspberry Pi (não importa o tipo, desde que tenha bom foco automático e resolução de imagem)
• algum tipo de suporte ou coldre para manter a câmera voltada para frente no Robo-Técnico
• um material para usar como tira, branco (ou de cor muito clara), que é segurado no chão com segurança. Ele precisa ser um pouco mais largo do que o espaço entre os dois sensores frontais de penhasco.
• 4 sinais com texto muito grande (com as palavras IMAGEM, DIREITA, VOLTA e ESQUERDA impressas neles)
• Folhas de papel colorido (pelo menos três e de preferência vermelho, verde e azul)

Programas

• Matlab (2018a e 2017b foram usados e parecem fazer pouca diferença)
• Pacote de suporte Raspberry Pi para Matlab
• Código Raspberry Pi para conexão ao Matlab (link para o código-fonte fornecido abaixo)
• Caixa de ferramentas de processamento de imagem para Matlab (você praticamente não pode fazer este projeto sem a caixa de ferramentas)
• OPCIONAL: Matlab Mobile instalado no seu telefone, que explicarei mais tarde

Etapa 1: Configurando o Hardware

ef.engr.utk.edu/ef230-2018-08/projects/roo…

Este é o link para o código base para garantir que o iRobot® possa se comunicar com o Matlab, junto com um tutorial básico. Como eu disse antes, não vou cobrir essa parte específica, pois o tutorial já está muito bem delineado. Mencionarei que, depois de seguir os passos do link, você pode usar o comando "doc" do Matlab para examinar as informações incluídas. Especificamente:

doc roomba

E mais um ponto muito importante.

Ao baixar os arquivos do link acima, COLOQUE-OS NA PASTA QUE DESCREVEI ACIMA, pois o Matlab requer que os arquivos gerados pelo usuário estejam na pasta de trabalho atual.

Com isso resolvido, vamos avançar para o código.

Etapa 2: Encontrar todos esses sensores

Reserve um segundo e faça uma inspeção no iRobot®. É bom saber onde eles estão para que você tenha uma ideia das entradas que o Robo-Técnico está recebendo e você será capaz de descobrir por que a coisa está girando em círculos em vez de seguir o caminho que você configurou (isso pode ou pode não ter acontecido). Obviamente, você verá o grande sensor de impacto físico na frente. Os sensores de penhasco são um pouco mais difíceis de ver, você precisará virá-los e procurar as quatro janelas de plástico transparente perto da borda frontal. Os sensores de colisão de luz estão ainda mais ocultos, mas por enquanto bastará dizer que ao vivo na faixa preta brilhante as corridas em torno da frente do iRobot®, que fica na frente da barra do sensor de colisão física.

Existem sensores de queda de roda, mas eles não são usados neste projeto, portanto, passaremos para o teste dos sensores.

Etapa 3: Teste para definir parâmetros

Antes de enviarmos o Robo-Técnico para fazer seu trabalho, precisamos descobrir suas peculiaridades e intervalos de sensores específicos. Uma vez que cada iRobot® é um pouco diferente e muda ao longo da vida do robô, precisamos descobrir como os sensores lêem sobre as áreas em que ele estará operando. A maneira mais fácil de fazer isso é configurar seu caminho de cor clara (Usei tiras de papel branco para impressora, mas qualquer coisa de cor clara serve) na superfície que o Robo-Técnico irá operar.

Inicie o Matlab e abra um novo script. Salve o script NA MESMA PASTA QUE DESCREVEI ANTES e nomeie-o como quiser (tente ser curto, pois o nome desse arquivo será o nome da função). Ligue o robô e use a configuração da variável roomba do tutorial, digitando os comandos na janela de comando.

Certifique-se de que o Raspberry Pi esteja conectado ao iRobot® e o seu computador esteja conectado à mesma conexão de internet. Você vai gastar menos tempo arrancando seu cabelo tentando descobrir por que o Matlab não conecta

r = roomba (número que você configurou)

A variável "r" nesta circunstância não é necessária, você pode chamá-la como quiser, mas torna a vida mais fácil usar uma variável de uma única letra.

Assim que o caminho estiver configurado e o roomba tiver sido conectado com sucesso, coloque o futuro Robo-Técnico onde um ou dois dos sensores de penhasco estão por cima do caminho. Obviamente, isso significa que os outros dois ou três estão acima da superfície que você escolheu.

Agora inicie os sensores de teste com o comando:

r.testSensors

Lembre-se de que o "r." É a variável que você definiu anteriormente, portanto, se não for 'r', altere o 'r'. para o que você decidiu. Isso abrirá a tela do sensor de teste com uma tonelada de informações.

Para este projeto, concentre-se nas seções lightBumpers, bumpers e penhasco. Mova o Robo-Técnico certificando-se de observar como os sensores mudam em superfícies diferentes, ou quão perto um objeto precisa estar para que os valores do ligthBumper mudem, etc. Mantenha esses números em mente (ou anote-os) porque você preciso deles para definir seus parâmetros em um segundo.

Etapa 4: Iniciando o Código

Em primeiro lugar, você estará construindo uma função. Eu o chamei de "caminho", mas novamente, o nome não é necessário, mas irei me referir a ele como "caminho" a partir de agora.

A parte superior do código está configurando algumas opções de entrada do usuário. Ele cria algumas listas que serão usadas no listdlg e, em seguida, abre uma caixa de diálogo de lista. Isso permite que o usuário selecione a cor do caminho que deseja seguir, o que entra em ação mais tarde.

list = {'Vermelho', 'Azul', 'Verde'}

Problist = {'Casualty, Save Image', 'Component Out of Place, Save Image', 'Expected, Continue'} pathcolor = listdlg ('PromptString', 'Select a Path Color',… 'SelectionMode', 'single', 'ListString', lista) prob = 0; driv = ;

As variáveis "prob" e "driv" precisam ser declaradas aqui, pois serão usadas dentro do loop while principal da função, mas, novamente, se você quiser renomear qualquer uma dessas variáveis ou alterar as seleções da lista, não há problema, contanto que você é consistente no resto do código.

Etapa 5: Top of the While Loop: Sensores de Bump Físico

O topo do loop while contém a lógica do sensor de colisão física. Basicamente, quando o Robo-Técnico esbarra em algo, ele para (ou para o sensor de colisão frontal ele recua 0,1 metro) e então se posiciona para tirar uma foto. Vamos abordar primeiro a parte de controle de velocidade e posição.

Se você testou todos os sensores no Robo-Técnico nas etapas anteriores, você saberá que os sensores de colisão têm um valor lógico (0 ou 1) com zero representando a posição normal não pressionada do sensor. Lembre-se disso para o código.

while true% main while loop% receber informações bumper S = r.getBumpers if S.left ~ = 0 r.stop elseif S.right ~ = 0 r.stop elseif S.front ~ = 0 r.stop end

Esta é a parte básica "se bater em algo, pare". Se os sensores detectarem uma colisão, então ele passa para a próxima parte do código, que reajusta a posição do Robo-Técnico para obter uma foto.

if S.left ~ = 0% se o loop obtém informações do bumper e alinha a câmera para a foto r.turnAngle (5) pause (0,5) img = r.getImage% tira a foto e exibe a imagem (img)% caixa de diálogo prob = listdlg (' PromptString ',' Encontrou um obstáculo inesperado, identifique '…,' SelectionMode ',' single ',' ListString ', problemsist) elseif S.right ~ = 0 r.turnAngle (-5) pause (0.5) img = r. getImage image (img) prob = listdlg ('PromptString', 'Encontrou um obstáculo inesperado, identifique' …, 'SelectionMode', 'single', 'ListString', problemsist) elseif S.front ~ = 0 r.moveDistance (- 0.1) pause (0.5) img = r.getImage image (img) prob = listdlg ('PromptString', 'Encontrou um Obstáculo Inesperado, Identifique'…, 'SelectionMode', 'single', 'ListString', Problista) end

Basicamente, uma vez que a imagem é tirada, outra caixa de diálogo aparecerá com três opções. As duas primeiras opções salvam a foto em uma pasta especificada, que abordarei mais tarde, enquanto a terceira opção simplesmente fecha a caixa de diálogo e continua através do loop. Se você não se lembra das opções, dê uma olhada na etapa anterior.

Agora eu inseri uma seção de código entre a parte do sensor de colisão e a parte de salvamento de fotos. Isso pega os valores do lightBumper e define a velocidade do drive para 0,025 metros / segundo (muito lento), o que não é realmente necessário, mas diminui o Robo-Técnico batendo nas coisas e, eventualmente, desgastando os sensores físicos de colisão.

L = r.getLightBumpers se L.left> 100 || L.leftFront> 100 || L.rightFront> 100 || L.direito> 100 driv = 0,025 r.setDriveVelocity (0,025) else driv = 0,1 fim

Esta seria a parte em que os valores que você observou (e com sorte anotou) anteriormente entram em jogo

O "L. (lado e direção do sensor)> 100" foi baseado nos valores que observei, portanto, se suas observações forem diferentes, altere esses números. A ideia é que se o Robotécnico sentir algo alguns centímetros à sua frente, ele irá desacelerar, não mais do que isso é desnecessário.

A próxima parte é onde as fotos são salvas para mais tarde.

% se a primeira ou segunda opção foi selecionada na caixa de diálogo prob, salva a imagem se prob == 1% se o loop cria informações de arquivo para a foto, grava com carimbo de data / hora t = clock; basename = sprintf ('\ img_% d_% d_% d_% d_% d.png', t (1), t (2), t (3), t (4), t (5)); folder = 'E: / UTK / Classes / fall 18 / ef230 / irobot / images'; fullFileName = fullfile (pasta, nome de base); imwrite (img, fullFileName) close Figura 1 pause (2) elseif prob == 2 t = clock; basename = sprintf ('\ img_% d_% d_% d_% d_% d.png', t (1), t (2), t (3), t (4), t (5)); folder = 'E: / UTK / Classes / fall 18 / ef230 / irobot / images'; fullFileName = fullfile (pasta, nome de base); imwrite (img, fullFileName) close Figura 1 pause (2) end

Todos os nomes de arquivos e locais onde as fotos são salvas são opcionais. Escolhi uma pasta que está aninhada dentro da pasta roomba que criei na etapa de introdução, mas pode estar em qualquer lugar que você escolher. Além disso, as fotos são salvas com o carimbo de data / hora, mas isso não é especialmente necessário (embora seja hipoteticamente útil para uma missão a Marte).

Com os sensores de colisão físicos cobertos, podemos passar para os sensores de penhasco e seguir o caminho.

Etapa 6: seguindo o caminho

O código para os sensores de penhasco é configurado para comparar os valores dos dois sensores frontal e lateral. Você precisará alterar esses valores (provavelmente) com base em seus valores observados. Você provavelmente também precisará editar esses valores após alguns testes e alterá-los com base na luz ambiente, hora do dia (dependendo de quão bem iluminada é a área de teste) ou quando as janelas do sensor estão sujas.

Antes de chegarmos ao código do sensor de penhasco, no entanto, há um segmento de código curto que inseri para liberar alguns dos dados desnecessários do Matlab. Esta parte não é necessária, mas usei-a para reduzir o armazenamento necessário para executar o programa.

limpar img clear t limpar o nome de base limpar fullFileName limpar a pasta

O próximo segmento de código é a carne do projeto. Permite ao Robo-Técnico seguir o caminho de cor clara que foi colocado no chão. Em suma, ele tenta se orientar de forma que os dois sensores frontais de penhasco fiquem acima do limite, com base em seus valores observados, e permite que o programa inicie as etapas de processamento de imagem um pouco mais tarde.

C = r.getCliffSensors% se o loop segue uma faixa colorida (branco) se C.leftFront> 2000 && C.rightFront> 2000% orientação de caminho reto r.setDriveVelocity (driv) elseif C.leftFront 2000% vira à direita se o robô for muito longe left r.turnAngle (-2.5) elseif C.leftFront> 2000 && C.rightFront <2000% vira à esquerda se o robô for muito para a direita r.turnAngle (2.5) elseif C.leftFront <2000 && C.rightFront 100 || L.leftFront> 100 || L.rightFront> 100 || L.right> 100 img = r.getImage end% verifica se há uma curva no caminho se C.left> 2800 && C.right <2800 r.turnAngle (2.5) elseif C.left 2800 r.turnAngle (- 2.5) end% placeholder para reconhecimento de imagem de caminho disp ('GETTING IMAGE') end end end

Lembre-se de que os nomes de variáveis que escolhi são opcionais, mas, novamente, acho que torna a vida mais fácil usar variáveis de uma única letra quando possível

Para explicar a seção intermediária do código, quando os dois sensores frontais saem da borda do caminho (quando se trata de uma interseção ou quando atinge o final do caminho), ele verifica se há algo na frente dele. Você precisará colocar um objeto no chão no final do caminho ou em qualquer cruzamento para que isso funcione.

Depois que a foto é tirada, ele usa o reconhecimento de imagem para descobrir o que fazer. Também há um marcador de posição nesta seção de código:

% espaço reservado para reconhecimento de imagem de caminhodisp ('GETTING IMAGE')

Usei isso no momento porque queria falar especificamente sobre o processamento de texto e cores que ocorre, que está na próxima etapa.

Etapa 7: Processamento de imagem

O processamento da imagem é dividido em duas partes. O primeiro é o reconhecimento de cores, que calcula a intensidade da cor na imagem para decidir se continua ou não para o reconhecimento de texto. Os cálculos de cores baseiam-se na escolha feita na primeira caixa de diálogo no início (usei vermelho, azul, verde, mas você pode escolher as cores que quiser, desde que os valores médios para a intensidade da cor possam ser reconhecidos pelo Câmera Raspberry Pi).

img = r.getImage img = imcrop (img, [0 30 512 354]) imgb = imcrop (img, [0 30 512 354]) imgt = imcrop (img, [0 30 512 354]) vermelho = média (média (imgb (:,:, 1))); g = média (média (imgb (:,:, 2))); b = média (média (imgb (:,:, 3)));

Esta é a verificação de intensidade. Isso será usado no próximo segmento para decidir o que deseja fazer.

if red> g && red> b if pathcolor == 1 imgc = imcrop (img, [0 30 512 354]) R = ocr (img) if R. Words {1} == IMAGE || R. Words {2} == IMAGEM || R. Words {3} == IMAGEM t = relógio; basename = sprintf ('\ img_% d_% d_% d_% d_% d.png', t (1), t (2), t (3), t (4), t (5)); folder = 'E: / UTK / Classes / fall 18 / ef230 / irobot / images'; fullFileName = fullfile (pasta, nome de base); imwrite (img, fullFileName) pause (2) elseif R. Words {1} == RIGHT || R. Words {2} == DIREITO || R. Words {3} == RIGHT r.turnAngle (-75) elseif R. Words {1} == LEFT || R. Words {2} == ESQUERDA || R. Words {3} == LEFT r.turnAngle (75) elseif R. Words {1} == VOLTAR || R. Words {2} == VOLTAR || R. Words {3} == BACK r.turnAngle (110) end else r.turnAngle (110) end end

Este segmento decide se a cor que foi selecionada na primeira caixa de diálogo corresponde à cor que a câmera está vendo. Se isso acontecer, ele executa o reconhecimento de texto. Olha para ver qual palavra (IMAGEM, VOLTAR, DIREITA ou ESQUERDA) aparece e então gira (para direita e esquerda), gira (para trás) ou tira uma foto e salva da mesma maneira que antes.

Forneci apenas uma única seção do código para as diferentes cores

Para permitir que o código reconheça azul e verde, simplesmente copie o código e altere a verificação lógica na parte superior do segmento e defina o "pathcolor == (número)" para corresponder às seleções de cores da caixa de diálogo superior (para o código conforme é exibido, o azul seria 2 e o verde seria 3).

Etapa 8: O produto acabado

Agora o Robo-Técnico deve dar um zoom nos módulos da missão de Marte e relatar aos astronautas quando algo estiver fora do lugar.

Lembre-se de que todos os valores do sensor de penhasco e do lightBumper precisam ser alterados para os valores observados. Além disso, por experiência própria, descobri que é melhor testar este projeto em um piso de cor escura e é ainda melhor se esse piso não for reflexivo. Isso faz com que o contraste entre o caminho e o piso aumente, o que torna mais provável que o Robotécnico o siga corretamente.

Espero que você tenha gostado de preparar um pequeno ajudante para a missão de Marte e se divirta construindo.