DISTRIBUIÇÃO DA CASA DE ESTANQUEIDADE

1. INTRODUÇÃO

Com o advento do e-commerce, a demanda por produtos aumentou e as empresas precisam de grandes estoques e movimentam grandes volumes diariamente. Isso inclui muitas tarefas de trabalho intensivo, como armazenamento, movimentação, digitalização, inspeção, entrega e muito mais. Para uma melhor eficiência, o número crescente de armazéns e centros de distribuição estão se movendo em direção à automação em vários graus, de sistemas semi-autônomos a totalmente autônomos, de acordo com a demanda.

Os sistemas de manuseio robótico são cada vez mais usados ​​em depósitos e centros de distribuição, pois fornecem flexibilidade no gerenciamento de requisitos de demanda variados e podem funcionar 24 horas por dia, 7 dias por semana.

Neste projeto, um braço robótico é usado para transferir pacotes de um transportador e carregá-los em um robô de transporte interno para estocagem.

II. TRABALHANDO

Este é um sistema de coleta e transporte automatizado, onde o braço robótico 2 DOF (mostrado na Figura

2 ) pode girar em torno do eixo z e do eixo x e tem uma pinça. O bot de transporte (mostrado em

Figura 1 ) tem um sensor ultrassônico montado nele para detectar sua distância da estação de acoplamento. Ao chegar próximo à estação, o veículo faz uma volta de 180 graus enquanto envia uma notificação ao braço informando a chegada. Na recepção, o braço inicialmente alinhado com o eixo z, gira 90 graus em direção ao transportador, para retirar a carga dele com a ajuda de uma pinça. Depois de pegar a carga, o braço gira -90 graus alinhando-se de volta com o eixo z (a garra apontando para cima). O braço então começa a girar em torno do eixo z enquanto procura o veículo de transporte, usando OpenCV e PiCamera. Uma vez que ele descobre o robô de transporte que está estacionado em frente ao transportador, o braço gira ainda mais o braço -90 graus, em direção ao robô, em torno de x colocando a garra em cima do robô coletor. Posteriormente, a pinça se abre para colocar a carga no bot, e então dá um sinal (Bluetooth) ao mesmo indicando o carregamento, conforme ele se move de volta para a posição inicial. Assim que o veículo de transporte receber essa notificação, ele começará a se afastar da estação de encaixe em direção ao local de estocagem desejado.

III. FILTRO DE BAIXA PASSAGEM

Usamos um filtro Low Pass Butterworth para filtrar as alterações de alta frequência na leitura dos dados x-y-z da câmera. Estamos criando um vetor de valores x-y-z e aplicando este filtro a ele. Após a aplicação do filtro, estamos tirando os valores médios dos últimos 20 elementos do vetor de forma a reduzir o ruído e suavizar o gráfico, obtendo assim uma posição mais precisa da bola da PiCam.

Na Figura 3 , a linha laranja são dados brutos (que são muito barulhentos e flutuando muito) e a linha azul é filtrada bata que é suave.

IV. ELETRÔNICA

Servo: um total de 5 servo motores são usados ​​no projeto. 2 para conduzir o veículo de transporte (transmissão diferencial). 3 são usados ​​para controlar as articulações do braço robótico.

Sensor Ultrassônico: Um sensor ultrassônico mede a distância até um objeto usando ondas ultrassônicas. O transmissor no sensor emite pulsos de som curtos e de alta frequência em intervalos regulares que se propagam no ar e são refletidos de volta como sinais de eco para o receptor quando atingem um objeto. A distância é calculada medindo-se o intervalo de tempo entre a emissão do sinal e o recebimento do eco (denominado Tempo de voo). Ele é montado no robô móvel e usado para planejamento e detecção de caminho Bluetooth:o HC06 montado no Arduino é usado para se comunicar em série com o módulo Bluetooth embutido do Raspberry pi.

Pi-câmera:uma câmera montada em uma das articulações do braço robótico é usada para rastrear o veículo de transporte estacionado em algum lugar na estação de acoplamento.

V. CIRCUITO

Como podemos ver na Figura 4 usamos três servos no framboesa pi.

Raspberry pi tem apenas dois pinos PWM, então escrevemos nosso próprio código de servo PWM para fazer três servos rodarem,

O came do Pi é conectado ao pi do framboesa como mostrado acima. A câmera encontra a bola usando OpenCV e bloqueia a posição do braço.

O Arduino tem um total de quatro componentes anexados a ele, conforme mostrado na figura acima. Dois servos, um sensor ultrassônico e um módulo HC-06 Bluetooth. Qual é usado para executar o bot de carga?

V. CÓDIGO

VI.I. Código Arduino:

#include

Servo à esquerda;

Servo direito;

const int GNND =4; const int GNDD =35; const int echo =37; const int trig =39; const int VCCC =41;

float invcmCosnt =(2 * 1000000) / (100 * 344,8); // cmDist =rawTime / invcmCosnt void setup () {

Serial.begin (9600); Serial3.begin (9600);

left.attach (3); // conecta o servo no pino 9 ao objeto servo right.attach (5);

pinMode (trig, OUTPUT); pinMode (eco, INPUT); pinMode (GNND, OUTPUT); pinMode (GNDD, OUTPUT); pinMode (VCCC, OUTPUT);

digitalWrite (VCCC, HIGH); digitalWrite (GNND, LOW); digitalWrite (GNDD, LOW); pinMode (LED_BUILTIN, OUTPUT);

left.write (114); right.write (74);

}

void loop () {

float rawTime, cmDist; digitalWrite (trig, LOW); atrasoMicrosegundos (2); digitalWrite (trig, HIGH); atrasoMicrosegundos (5); digitalWrite (trig, LOW); rawTime =pulseIn (eco, HIGH); cmDist =100;

while (cmDist> 4) {digitalWrite (trig, LOW); atrasoMicrosegundos (2); digitalWrite (trig, HIGH); atrasoMicrosegundos (5); digitalWrite (trig, LOW); rawTime =pulseIn (eco, HIGH); cmDist =rawTime / invcmCosnt; Serial.println (cmDist);

}

Serial.println (“Out”); Serial3.println (“s”); left.write (94); right.write (94); atraso (1000); left.write (114); right.write (114); atraso (1700); Serial.println (“Virado”); left.write (94); right.write (94); Serial.println (“Parado”); enquanto (1) {

if (Serial3.read () ==’f’) {break;

}

}

left.write (114); right.write (74); atraso (2500); left.write (94); right.write (94); enquanto (1) {

}

}

VI.II. Framboesa

No final do Raspberry, é necessário conectar o Raspberry Pi ao Módulo Bluetooth HC-06 usando os seguintes comandos para primeiro encontrar,

$ Hcitool scan # Pode ser ignorado se o MAC ID do Bluetooth for conhecido e estiver disponível

Em seguida, conecte-se ao Bluetooth necessário usando o MAC ID correto:

$ Sudo rfcomm conectar hci0 xx:xx:xx:xx:xx:xx

Se for executado com êxito, o Bluetooth está conectado.

importe os pacotes necessários das coleções import deque

de imutils.video import VideoStream import numpy as np
import argparse import cv2 import imutils import time import timeit
from scipy import sign import matplotlib.pyplot as plt

importar RPi.GPIO como GPIO

import serial

GPIO.setmode (GPIO.BCM) GPIO.setup (12, GPIO.OUT) # Gripper GPIO.setup (13, GPIO.OUT) # Rot_x GPIO.setup (16, GPIO.OUT) # Rot_z

rotz =16
rotx =GPIO.PWM (13, 50) gr =GPIO.PWM (12, 50)

azul =serial.Serial (“/ dev / rfcomm0”, taxa de transmissão =9600) imprimir (“Bluetooth conectado”)

dever def (ângulo):
ângulo de retorno * 5/90 + 2,5

def search (angle =90, add =1):servo_pwm (rotz, duty (angle), 50) ap =argparse.ArgumentParser () ap.add_argument (“- v”, “–video”,
help =”Caminho para o (opcional) arquivo de vídeo”) ap.add_argument (“- b”, “–buffer”, type =int, default =64,
help =”tamanho máximo do buffer”) args =vars (ap .parse_args ())
xn =np.zeros ([500]) xm =np.zeros ([1])
greenLower =(20, 20, 53)
greenUpper =(64 , 255, 255)
pts =deque (maxlen =args [“buffer”])

se um caminho de vídeo não foi fornecido, pegue a referência # para a webcam

senão args.get (“video”, False):
vs =VideoStream (src =0) .start ()

caso contrário, pegue uma referência ao arquivo de vídeo else:

vs =cv2.VideoCapture (args [“video”])

permitir que a câmera ou arquivo de vídeo aqueça time.sleep (2.0)

enquanto verdadeiro:
se ângulo ==125:
adicionar =-5
ângulo elif ==35:
adicionar =5 ângulo + =adicionar
servo_pwm (rotz, dever (ângulo), 10) tempo. sono (0,01)

pegue o quadro atual frame =vs.read ()

manipular o quadro de VideoCapture ou VideoStream frame =frame [1] if args.get (“video”, False) else frame

se estivermos vendo um vídeo e não capturamos um quadro, # então chegamos ao final do vídeo

se o quadro for Nenhum:
quebrar

redimensione o quadro, desfoque-o e converta-o para o espaço de cor HSV #

quadro =imutils.resize (quadro, largura =600) desfocado =cv2.GaussianBlur (quadro, (11, 11), 0)
hsv =cv2.cvtColor (desfocado, cv2.COLOR_BGR2HSV)

construir uma máscara para a cor “verde” e, em seguida, realizar # uma série de dilatações e erosões para remover quaisquer # pequenas manchas deixadas na máscara

mask =cv2.inRange (hsv, greenLower, greenUpper) mask =cv2.erode (mask, None, iterations =2)
mask =cv2.dilate (mask, None, iterations =2)

encontre contornos na máscara e inicialize o centro atual # (x, y) da bola

cnts =cv2.findContours (mask.copy (), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
cnts =imutils.grab_contours (cnts) center =None

só prossiga se pelo menos um contorno for encontrado se len (cnts)> 0:

encontre o maior contorno da máscara e, em seguida, use

para calcular o círculo mínimo e # centroide

c =max (cnts, key =cv2.contourArea)
((x, y), raio) =cv2.minEnclosingCircle (c) M =cv2.moments (c)
center =(int (M [“M10”] / M [“m00”]), int (M [“m01”] / M [“m00”])) # prossiga apenas se o raio atingir um tamanho mínimo
se raio> 10:

desenhe o círculo e o centroide no quadro, # em seguida, atualize a lista de pontos rastreados cv2.circle (quadro, (int (x), int (y)), int (raio),

(0, 255, 255), 2)
cv2.circle (frame, center, 5, (0, 0, 255), -1)

xn =np.delete (xn, 0) xn =np.append (xn, x) fs =300
fc =1 x_old =x
w =fc / (fs / 2)
b, a =sinal.butter (5, w, 'baixo') saída =sinal.filtfilt (b, a, xn) x =np.média (xn [480:500]) imprimir (x, x_old)
xm =np.append (xm, x) se abs (x - 300) <20:
quebra

atualize a fila de pontos pts.appendleft (centro)

para i no intervalo (1, len (pts)):

se algum dos pontos rastreados for Nenhum, ignore # eles

se pts [i - 1] for Nenhum ou pts [i] for Nenhum:
continue

caso contrário, calcule a espessura da linha e # desenhe as linhas de conexão

espessura =int (np.sqrt (args [“buffer”] / float (i + 1)) * 2,5) cv2.line (frame, pts [i - 1], pts [i], (0, 0, 255) , grossura)

mostrar o quadro em nossa tela cv2.imshow (“Quadro”, quadro) key =cv2.waitKey (1) &0xFF

se a tecla ‘q’ for pressionada, pare o loop se a tecla ==ord (“q”):

print (xn) print (xn.shape) plt.plot (xm, label =’x’) plt.show ()
break

senão args.get (“video”, False):vs.stop ()

caso contrário, libere a câmera senão:

vs. liberação ()

feche todas as janelas cv2.destroyAllWindows () retornar x, adicionar

def servo_pwm (pin, duty, pulse):on =20 * duty / 100000
off =-on + 20/1000 para i na faixa (pulso):
GPIO.output (pin, GPIO.HIGH ) time.sleep (on) GPIO.output (pin, GPIO.LOW) time.sleep (off)

def grip (ângulo =90):
servo_pwm (rotz, duty (angle), 100) rotx.start (duty (90)) gr.start (duty (100))
time.sleep (1 ) rotx.ChangeDutyCycle (duty (0)) time.sleep (1) gr.ChangeDutyCycle (duty (180)) time.sleep (0,5) rotx.ChangeDutyCycle (duty (90)) time.sleep (0,5)

def drop ():rotx.ChangeDutyCycle (duty (180))

time.sleep (1) gr.ChangeDutyCycle (duty (100)) time.sleep (1) rotx.ChangeDutyCycle (duty (90)) time.sleep (0,5)

def done ():
done =“f”
done =done.encode () blue.write (done)

try:
enquanto True:
data =blue.readline () # data =data.decode ()

imprimir (tipo (dados), dados) # se dados! =“s”:

imprimir (“não”) # continuar

else:print (“found s”) grip (80)

x, add =search (80, 5) drop ()
done ()

exceto KeyboardInterrupt:GPIO.cleanup () print (“Quit”)

VII. CONCLUSÃO

Neste projeto, implementamos um sistema de movimentação de carga para automação de almoxarifado. Um braço robótico pega itens de uma correia transportadora, procura o veículo de transporte usando uma câmera montada nela, carrega o pedido no veículo e, em seguida, o veículo de transporte leva as mercadorias ao local necessário para processamento posterior. A automação de depósitos está se tornando cada vez mais comum em grandes e pequenas empresas devido às crescentes demandas dos clientes e ao crescimento do comércio eletrônico. O Goods to People (GTP) é uma tendência emergente mais recente, em que os bens são movidos para os trabalhadores, em vez dos trabalhadores para os itens. De acordo com Nathan Busch, engenheiro consultor associado da Bastian Solutions Inc., “As taxas de transferência dos sistemas GTP são normalmente um pouco mais altas do que as operações manuais tradicionais. Isso permite que as empresas reduzam seus custos gerais de operação e atendimento de pedidos, melhorando a produtividade e os níveis de serviço ”. A robótica móvel agora se tornou uma parte crucial disso, pois os itens são procurados, coletados e levados para seus respectivos locais de processamento. O escopo futuro deste projeto foi amplamente considerado para um sistema de armazém totalmente autônomo, onde os itens que devem ser estocados podem ser separados por outro sistema e o sistema apresentado acima pode transferir as mercadorias do transportador para o bot de armazenamento, que ainda encontra um caminho ideal para o local de armazenamento desejado e os estoques das mercadorias. Esta demonstração mostra que o sistema mencionado pode ser implementado em partes para o benefício de empresas menores; portanto, combinando a operação manual e robótica para um maior rendimento e desempenho aprimorado.

Fonte:DISTRIBUIÇÃO DE WEARHOUSE

Projeto e desenvolvimento de um robô de inspeção de baixo custo Planejamento de movimento em tempo real para carro autônomo em várias situações ， sob ambiente urbano simulado