Mudanças entre as edições de "Projeto de Monitoramento de Dutos de"
(→Robô) |
|||
| Linha 356: | Linha 356: | ||
===Controle=== | ===Controle=== | ||
| + | Para o controlar os movimentos do robô e do sistema de pan/tilt foi utilizado um controle modelo dualshock 2 usb. A integração do controle com o resto do software do controlador se deu através da biblioteca PyGame. O botões reconhecidos pelo controlador e suas funções são: | ||
| + | * '''Analógico esquerdo: '''Movimentação do robô. | ||
| + | * '''Analógico direito: '''Movimentação do sistema pan/tilt. | ||
| + | * '''L1: '''Diminui a velocidade dos motores. | ||
| + | * '''R1: '''Aumenta a velocidade dos motores. | ||
| + | * '''Start: '''Gravação em disco da stream de video(função ainda não implementada). | ||
===Interface Gráfica=== | ===Interface Gráfica=== | ||
Edição das 14h25min de 26 de outubro de 2015
Reunião 7/5/2015
- Explanação Inicial do Marcelo
- Definição do Robô, da forma de comunicação e alimentação;
- distância;
- estimar potência total: ??
- forma de resgate
- usar sistema de lagarta: [1]
- estudar câmera com iluminação conjugada e controle independente da movimentação do robô;
- sistema de controle: arduíno, banana pi;
- dimensões: 20cmx30cm (LxC)
- fazer estimativa de custo,dimensões,peso, consumo de energia,potência, estimativa de câmera conjugada com iluminação;
- Horário definido para reuniões: segunda 15h30 (a partir do dia 18/5);
Horário dos Bolsistas
- Bruno
- Segunda: 15:30 ~ 19:30
- Terça : 13:30 ~ 17:30
- Quarta: 13:30 ~ 17:30
- Quinta: 13:30 ~ 17:30
- Sexta : 13:30 ~ 17:30
- Lucas
- Segunda: 7:30 ~ 12:00
- Terça : 7:30 ~ 12:00
- Quarta: 10:00 ~ 12:00
- Quinta: 7:30 ~ 12:00
- Sexta : 7:30 ~ 12:00
Relatórios - Lucas
| Relatório do dia 07/05/2015 até 18/05/2015 |
|---|
As duas primeiras semanas tiveram como objetivo a definição das configurações do robô como um todo. Entre os tópicos definidos na reunião entre os bolsistas e os coordenadores do projeto, estavam: a forma de resgate do robô, sistema de locomoção, câmera, iluminação, sistema de controle, custos e dimensões
“O melhor e mais completo equipamento de vídeo inspeção robotizada a serviço da SABESP. Capaz de inspecionar tubulações de 150 mm a mais de 3.000 mm de diâmetro” “Modelo VOR-42-C.” “O vídeo apresenta como foi realizado o planejamento e montagem do projeto de conclusão de curso da turma de Engenharia Mecatrônica da UNIP Ribeirão Preto no ano de 2012.”
|
| Relatório do dia 19/05/2015 até 26/05/2015 |
|---|
O tempo de uma semana foi gasto quase que inteiramente na aprendizagem conceitual de motores DC, ponte H e a arquitetura do raspberry pi.
|
Controle de Motores
Um dos circuitos mais importantes na elaboração de sistemas automatizados é a ponte H. Trata-se de um circuito utilizado para controlar um motor DC a partir de sinais gerados por um microcontrolador. Os links abaixo ensinam como projetar uma ponte H.
- http://arduinobymyself.blogspot.com.br/2012/08/ponte-h-controle-de-motores-dc.html
- http://www.maxwellbohr.com.br/downloads/robotica/mec1000_kdr5000/tutorial_eletronica_-_montagem_de_uma_ponte_h.pdf
O CI L293D faz a função de uma ponte H e embora ele consiga controlar dois motores com ele o mesmo suporta no máximo uma corrente de 600 mA constante e uma corrente de pico de 1,2 A.
O uso do raspberry pi para controle de motores DC é bastante comum e portanto é fácil encontrar alguns programas prontos para isso, sendo os mesmos geralmente escritos em python.
- http://computers.tutsplus.com/tutorials/controlling-dc-motors-using-python-with-a-raspberry-pi--cms-20051
- https://learn.adafruit.com/downloads/pdf/adafruit-raspberry-pi-lesson-9-controlling-a-dc-motor.pdf
Relação de itens necessários para o projeto
| Lista de itens |
|---|
servos: http://produto.mercadolivre.com.br/MLB-662053141-micro-servo-turnigy-9g-_JM CI L293: http://produto.mercadolivre.com.br/MLB-651266129-1-x-l293d-l293b-l293-ponte-h-dupla-p-arduino-pic-id8-_JM
suporte: http://produto.mercadolivre.com.br/MLB-650471695-fpv-pan-tilt-p-camera-projeto-arduino-servos-n-inclusos-_JM
câmera USB full HD: http://www.aliexpress.com/item/HD-1080P-2-megapixel-OV2710-USB-cmos-Camera-module-for-all-kinds-of-equipments-ELP-USBFHD01M/32237608962.html
injeto + divisor: http://produto.mercadolivre.com.br/MLB-655487154-poe-separador-injetor-_JM
(48/12)V: http://produto.mercadolivre.com.br/MLB-650712551-conversor-dcdc-step-down-08-reduz-de-24-a-50v-para-12v-3-a-_JM (48/5)V: http://produto.mercadolivre.com.br/MLB-663539048-conversor-dcdc-step-down-de-15v-ate-50v-saida-5v-3-a-sd14-_JM#
raspberry pi: http://produto.mercadolivre.com.br/MLB-639775372-novo-raspberry-pi-2-model-b-quadcore-1gb-ram-pronta-entrega-_JM
|
Descrição do sistema
| Levantamento de requisitos |
|---|
|
| Casos de uso |
|---|
Diagrama de casos de uso
Casos de usoCSU01Mover a câmera
CSU02Mover o robô
CSU03Alterar a velocidade dos motores.
CSU04Gravar vídeo
|
| Descrição de fucionamento | ||
|---|---|---|
Diagrama UML de sequência
Estrutura do pacote enviado do controlador para o robô
Diagrama UML de classes |
Software
- Controlador: Responsável por capturar e transmitir os comandos do usuário.
https://github.com/bruno-antonio-pinho/Controlador
- Controle dos Servos e motores em C++: https://github.com/bruno-antonio-pinho/PWM_Controler
- Controle dos Servos e motores em python: https://github.com/bruno-antonio-pinho/Robot_Controler
- Transmissão de video: Para a transmissão de video esta sendo utilizado o MJPG-Streamer devido a sua eficiência.
Processamento de imagens com o BeagleBone
O link abaixo explica como a câmera utilizada pode afetar o desempenho da transmissão de video e o consumo de recursos do sistema. https://www.raspberrypi.org/forums/viewtopic.php?p=751735
O link a seguir é uma introdução ao processamento de imagens com o OpenCV no BeagleBone. http://derekmolloy.ie/beaglebone/beaglebone-video-capture-and-image-processing-on-embedded-linux-using-opencv/
Sistema
Controlador
Controle
Para o controlar os movimentos do robô e do sistema de pan/tilt foi utilizado um controle modelo dualshock 2 usb. A integração do controle com o resto do software do controlador se deu através da biblioteca PyGame. O botões reconhecidos pelo controlador e suas funções são:
- Analógico esquerdo: Movimentação do robô.
- Analógico direito: Movimentação do sistema pan/tilt.
- L1: Diminui a velocidade dos motores.
- R1: Aumenta a velocidade dos motores.
- Start: Gravação em disco da stream de video(função ainda não implementada).
Interface Gráfica
Software
Robô
O Robô criado neste projeto é composto por um chassi(imagem acima), 2 motores DC, uma placa beaglebone Rev. C, sistema de pan/tilt, uma camera logitech C920, e um circuito de alimentação.
BeagleBone
A imagem acima mostra os pinos do beaglebone e a sua utilização, para o controle do robô foram utilizados 5 portas PWM e 2 portas digitais.
- 3 portas PwM (P8_13, P9_14 e P9_42) para controle dos motores DC, foram usadas portas PWM ao invés de portas digitais a fim de ser possível controlar a velocidade do robô, sendo dois sinais PWM ligados ao positivo dos motores e um sinal PWM ligado ao negativo de ambos os motores.
- 2 portas PWM (P9_22 e P9_28) usadas para controlar o sistema pan/tilt usado no controle da movimentação da câmera. A porta P9_28 não aparece como uma saída PWM na imagem acima pois a principio é reservada para saída de áudio HDMI, para liberar a mesma deve ser desabiltado o HDMI no beaglebone adicionada a linha abaixo ao arquivo uEnv.txt o qual pode ser acessado conectando a entrada mini-USB do beaglebone e acessando a partção boot.
optargs=capemgr.disable_partno=BB-BONELT-HDMI,BB-BONELT-HDMIN
- Durante testes realizados utilizando a biblioteca Adfruit_BBIO para o controle das portas PWM ocorreram erros onde ao parar e reiniciar as portas pwm constantemente acarretavam em encerramento forçado do programa ao mesmo tempo que ao permanecerem ligadas o continuamente acarreta em sobre aquecimento dos servos. Afim de resolver o problema são utilizadas 2 portas digitais (P9_23 e P9_30) que são ligados juntamente com as saídas PWM (P9_22 e P9_28) ao CI 74S244 o qual possui uma logica invertida assim quando os portas digitais estiverem em nível baixo o sinal PWM é liberado para os servos e quando estiverem em nivel alto o sinal é bloqueado.
Alimentação
A alimentação será feita através de um sistema PoE(Power over Ethernet) até a entrada do circuito onde será distribuída para 2 conversores DC/DC do tipo step-down sendo que um reduzira a tensão para 12V e o outro para 5V.
- Conversor DC/DC para 12V: É responsável por alimentar os motores DC, a saída será conectada a uma ponte-H que é ativada através das portas PWM.
- Conversor DC/DC para 5V: É responsável por alimentar o o beaglebone e os servos. Os servos são ativados através de pulsos com amplitude de 5V porém a amplitude dos pulsos Pwm do beaglebone são de 3.3V, para resolver isso os pulsos passaram por circuito composto pelo CI 74S244 mencionado anteriormente e um ampop(LM324) para aumentar a amplitude os quais serão alimentados pelo conversor de 5V.
Pan/tilt
O sistema de movimentação da câmera utilizado no projeto consiste de duas juntas metálicas conetadas a dois servos, SG90, que dão ao usuário um campo maior de visão.
MJPG-Streamer
O mjpg-Streamer é um software que captura a informação da imagem através do programa V4L2 e transmite via HTTP. Embora ele possa ser usado com qualquer câmera USB câmeras que possuem saída apenas no formato YUYV requerem um processamento adicional para converter a informação para MJPG o que faz com que aumente o consumo de recursos no sistema.
Obs: O funcionamento descrito acima é apenas a forma como o programa foi utilizado no projeto, também sendo a forma mais comum de utilização do mesmo. O MJPG_Streamer também permite a transmissão da informação nos protocolos UDP e RDP.
Nice
Nice é um programa que serve para alterar o niceness de um processo no linux, o niceness é um valor que varia de -20 a 19 esse valor tem uma relação inversamente proporcional com a prioridade que o linux da a um processo, ou seja quanto menor o valor maior a prioridade de um processo (por padrão o valor de niceness de um processo é 0), o nice é usado dentro do sistema para dar um prioridade maior ao MJPG-Streamer de modo que não haja delay na transmissão das imagens.
Para maiores informações sobre o nice: http://bencane.com/2013/09/09/setting-process-cpu-priority-with-nice-and-renice/
Software de Controle do robô
| Python |
|---|
import socket
import simplejson
import Adafruit_BBIO.PWM as PWM
import Adafruit_BBIO.GPIO as GPIO
# Inicia as portas PWM que controlam os motores.
PWM.start("P8_13", 0, 100)
PWM.start("P9_14", 0, 100)
PWM.start("P9_42", 0, 100)
# Inicia as portas PWM que controlam o suporte pan/tilt da camera.
PWM.start("P9_22", 2, 50)
PWM.start("P9_28", 2, 50)
# Inicia os saidas que contralam as passagem dos pulsos PWM do pan/tilt da camera.
GPIO.setup("P9_23",GPIO.OUT)
GPIO.setup("P9_30",GPIO.OUT)
# Coloca as portas P9_30 e P9_23 em nivel alto para bloquear a passagem do sinal PWM.
GPIO.output("P9_23", GPIO.HIGH)
GPIO.output("P9_30", GPIO.HIGH)
# Abre coneccao na porta 5506.
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
sock.bind(('172.18.131.50', 5506 ))
# Angulo inicial das cameras.
cam_angle = [0.0, 0.0]
def robot_direction(direction, speed):
# Move o robo para a direita
if(direction == 2):
PWM.set_duty_cycle("P8_13", 0)
PWM.set_duty_cycle("P9_14", speed)
PWM.set_duty_cycle("P9_42", 0)
# Move o robo para a esquerda.
elif(direction == 3):
PWM.set_duty_cycle("P8_13", speed)
PWM.set_duty_cycle("P9_14", 0)
PWM.set_duty_cycle("P9_42", 0)
# Move o robo para frente.
elif(direction == 0):
PWM.set_duty_cycle("P8_13", speed)
PWM.set_duty_cycle("P9_14", speed)
PWM.set_duty_cycle("P9_42", 0)
# Move o robo para tras.
elif(direction == 1):
PWM.set_duty_cycle("P8_13", 0)
PWM.set_duty_cycle("P9_14", 0)
PWM.set_duty_cycle("P9_42", speed)
# Para os movimentos do robo;
else:
PWM.set_duty_cycle("P8_13", 0)
PWM.set_duty_cycle("P9_14", 0)
PWM.set_duty_cycle("P9_42", 0)
pass
def cam_direction(direction):
# Movimenta a camera para a direita.
if(direction == 3 ):
if(cam_angle[0] >= 2):
cam_angle[0] = cam_angle[0] - 1
duty_cycle = (cam_angle[0] / 18) + 2
GPIO.output("P9_23", GPIO.LOW)
PWM.set_duty_cycle("P9_22", duty_cycle)
# Movimenta a camera para a esquerda.
elif(direction == 2):
if(cam_angle[0] <= 179):
cam_angle[0] = cam_angle[0] + 1
duty_cycle = (cam_angle[0] / 18) + 2
GPIO.output("P9_23", GPIO.LOW)
PWM.set_duty_cycle("P9_22", duty_cycle)
# Movimenta a camera para cima.
elif(direction == 0):
if(cam_angle[1] <= 179):
cam_angle[1] = cam_angle[1] + 1
duty_cycle = (cam_angle[1] / 18) + 2
GPIO.output("P9_30", GPIO.LOW)
PWM.set_duty_cycle("P9_28", duty_cycle)
# Movimenta a camera para baixo.
elif(direction == 1):
if(cam_angle[1] >= 2):
cam_angle[1] = cam_angle[1] - 1
duty_cycle = (cam_angle[1] / 18) + 2
GPIO.output("P9_30", GPIO.LOW)
PWM.set_duty_cycle("P9_28", duty_cycle)
# Para o movimento da camera.
else:
GPIO.output("P9_23", GPIO.HIGH)
GPIO.output("P9_30", GPIO.HIGH)
while True:
data, addr = sock.recvfrom(1024) # Espera o pacote com os comados.
info = simplejson.loads(data) # Transforma a informacao do pacote em um vetor de inteir.
print(info) # printa na tela o pacote recebido para Debug.
robot_direction(info[0], info[2])
cam_direction(info[1])
|