braço robótico – projeto prático - cld.pt · de 24v e para cada sensor terá um divisor de...
Post on 30-Nov-2018
216 Views
Preview:
TRANSCRIPT
SARA LOPES M7907 | JOÃO BÁRBARA M7930 | JOÃO FARIA M8007 | LUÍS MENDES M8759
Ano Letivo: 2017/2018
UNIVERSIDADE DA BEIRA
INTERIOR
2º Ciclo de Engenharia Eletrotécnica e de Computadores
Robótica Industrial
Prof. Pedro Dinis
Braço Robótico – Projeto Prático RELATÓRIO
Covilhã, Janeiro 2018
2
Índice
Introdução ......................................................................................................................... 3
Comunicação RS232 ........................................................................................................ 4
Divisor de tensão .............................................................................................................. 5
Material ............................................................................................................................. 6
Braço robótico ........................................................................................................................... 6
Motores ..................................................................................................................................... 8
Sensores..................................................................................................................................... 9
Desenho do circuito eletrónico ....................................................................................... 10
(Ferramenta Proteus)........................................................................................................... 10
Código da Pic ....................................................................................................................... 13
Desenho do circuito para PCB........................................................................................ 16
(Ferramenta Eagle) .............................................................................................................. 16
Controlador para eixos.................................................................................................... 20
Anexos ............................................................................................................................ 21
Componentes Necessários ................................................................................................... 21
Gui Matlab .......................................................................................................................... 21
Código Gui Matlab ............................................................................................................... 23
3
Introdução
No âmbito da cadeira de Robótica Industrial foi proposta a elaboração de um
controlador que operasse um braço robótico. Este atua sob três eixos, x, y, z, onde cada
um funciona com um motor DC e apresenta dois sensores magnéticos. Existe ainda uma
pinça controlada por vácuo.
Para a elaboração deste projeto implementaremos sequencialmente dois pontos que
podemos designar por software e hardware.
Numa primeira fase, elaboraremos através da ferramenta Proteus, os seguintes
circuitos:
Esquema do regulador de tensão;
Esquema do microcontrolador;
Esquema da ponte H para eixo X e Y;
Esquema para a Ponte H para eixo Z e pinça;
Esquema de entrada dos sensores.
E através da ferramenta Eagle será elaborado, o desenho circuitos integrados (PCB),
sendo eles:
Alimentação e divisor de tensão para sensores;
Ponte H com respetivos díodos de roda livre para cada motor;
Ponte H com respetivos díodos de roda livre para cada motor e pinça;
Microcontrolador;
Conexões.
Posteriormente, elaboraremos o software responsável pelo controlo do sistema.
Primeiro vamos proceder à construção do código da programação da pic através do
software MikroC, responsável pelo controlo do braço robótico, que posteriormente será
simulada através da ferramenta Proteus. Por fim foi desenvolvido um software em visual
basic, designado por controllex, para o controlo dos eixos x, y e z.
4
Comunicação RS232
Uma parte essencial deste projeto é a comunicação entre o utilizador e o robô por
software. Depois de analisados diversos tipos de comunicação entre o computador e a pic
(robô), optamos pela escolha da comunicação RS232. Trata-se de uma comunicação série
bastante utilizada devido à simplicidade no que toca em estabelecer as suas ligações,
tendo somente três linhas de comunicação, RX, TX e GND (USB TTL 485 converter).
UART, Universal Assynchronous Receiver/Transmitter, como o próprio nome indica,
é uma comunicação assíncrona pois não necessita de enviar clock juntamente com a data,
tal como acontece nas comunicações síncronas. O responsável pelo clock é o Baud Rate
que providencia o clock necessário para a transmissão dos dados e para a sua receção. Tal
como já foi referido em cima, o envio dos dados é feito apenas por dois fios, o Tx que se
encontra ligado ao Rx e vice-versa. O GND dos dois dispositivos deve ser comum.
Figura 1: Comunicação RS232.
Dizer ainda que outro mecanismo de uma comunicação RS232 é através de um cabo
com um PINOUT de nove pinos, onde o pino 1 corresponde ao DCD (Data Carrier
Detected), o pino 2 o Rx (Receive Data), o pino 3 o Tx (Transmit Data), o pino 4 o DTR
(Data Terminal Ready), o pino 5 o GND, o pino 6 o DST (Data Set Ready), o pino7 o
RTS (Request To Send), o pino 8 o CTS (Clear To Send) e o pino 9 o RI (Ring Indicator).
Este tipo de PINOUT é bastante útil para estabelecer ligação a computadores mais antigos
que não têm uma porta USB, no entanto o mecanismo e a lógica são exatamente as
mesmas, como explicado para a pen USB.
5
Divisor de tensão
Para a ligação dos sensores à placa de controlo (PIC) é necessário ter uma tensão
máxima de 3.3v e a nossa fonte de alimentação será de 24v, como tal é necessário um
divisor de tensão para cada sensor, fazendo um total de 6 divisores.
𝑉𝑜𝑢𝑡 =𝑅2
𝑅2 + 𝑅1∗ Vin
5𝑣 =1.2𝑘Ω
1.2𝑘Ω + 𝑅1∗ 24v
R1 = 4.5kΩ
6
Material
Braço robótico
Figura 2: Braço Robótico.
O funcionamento do braço robótico consiste no seguinte:
Usando o programa controllex é introduzido um valor que dita as coordenadas e a
partir daí o programa faz a gestão de tempo/processo, isto é, transforma o valor
introduzido num tamanho de caracteres a enviar.
No caso do eixo X, usa os caracteres A e B, no que toca ao eixo Y, usa os caracteres
C e D por fim, no eixo Z, faz uso dos caracteres F e H.
Estes caracteres são enviados para o microcontrolador, onde cada caracter corresponde
a 0,5 segundos de movimento, com isto podemos associar uma distância a um
determinado tempo de ação. Assim sendo, imaginando que a posição 200mm no processo
demora 5 segundos a ser executada, ter-se-á então que enviar 10 caracteres A para o
microcontrolador. (ex: AAAAAAAAAA)
7
São necessários 10 caracteres A, onde cada A simboliza 0,5 segundos de movimento,
o que neste caso seriam 10 traços.
Este processo é um processo básico, mas a fisionomia do braço e os seus apetrechos
(fins de curso) não permitem outra solução, logicamente que a oleosidade do eixo varia,
o peso da carga também e isto influencia no tempo de movimento, mas apenas se
instalando em cada motor um encoder se conseguiria um melhoramento deste
desempenho.
Assim sendo, o movimento dos motores e respetiva colocação nas coordenadas será
feita desta forma.
No que toca à parte física do controlo, será constituído por uma fonte de alimentação
de 24v e para cada sensor terá um divisor de tensão, pois os sensores terão uma
alimentação de 24v e o sinal terá de ser enviado para a Pic que na sua vez apenas suporta
uma tensão máxima de 5v.
Posto isto, o processo será programado numa PIC16F628A, que terá como suporte
pontes H LM298 para gerir a direção de rotação de cada motor. Para este projeto foram
projetadas duas PCB’s dupla face e a ligação entre o computador e o processador será
feita por cabo RS232 e com possibilidade de reprogramação do mesmo através de uma
porta usb.
Posição pretendia
Figura 3: Exemplo.
8
Figura 4: Motor.
Motores
9
Figura 5: Sensor 1. Figura 6: Sensor 2.
Figura 7: Sensor 3.
Sensores
10
Desenho do circuito eletrónico
(Ferramenta Proteus)
Figura 8: Regulador de Tensão
Figura 9: Microcontrolador
11
Figura 10: Ponte H para eixo X e Y
Figura 11: Ponte H para eixo Z e Pinça
12
Figura 12: Entrada Sensores
13
A pic escolhida para este projeto foi a Pic16F886 e o software utilizado foi o mikroC.
O código seguinte é o código de programação da pic que foi simulado posteriormente
na ferramenta Proteus.
Código da Pic
int cont; // contador
unsigned char letra; // variavel
void InitTimer0() // função de inicialização das configurações do timer
//20ms tempo que demora a executar a função InitTimer0
OPTION_REG = 0x87; // registo
TMR0 = 100; // Prescaler 1.32
INTCON = 0xA0; // controlo do registo das interrupções
void main()
CMCON = 0x07; //Desabilita os comparadores
GIE_bit = 0x01; //Habilita interrupção global
PEIE_bit = 0x01; //Habilita interrupção por periféricos
T0IE_bit = 0x01; //Habilita interrução do Timer0
TRISA = 0x2F; // entrada no porto A
TRISB = 0X02; // configura a porta B como saída com exceção do bit 1 (rx)
PORTA = 0x00; // iniciam todos como saida
PORTB = 0x00; // inciam todos como saida
Uart1_Init(9600); // Baud Rate de 9600, comunicação RS232
delay_ms(50);
InitTimer0(); // chamada da função de inicialização das configurações do timer
14
cont=0;
while (1) // ciclo
letra = 0; // limpa a variavel que vai guardar os dados recebidos
void Interrupt()
if (TMR0IF_bit) //20ms que demora a interrupção a ser executada
cont++;
if(cont==25) //500ms que demora a executar o comando de envio da “letra”
cont=0;
portb=0b00000000; // porto b como saida
porta=0b00000000; // porto a como saida
if (Uart1_Data_Ready()) // função para indicar que os dados estão recebidos
letra = Uart1_Read(); // função para a leitura dos dados recebidos
if ((letra =='A') && (PORTA.F0==0))
portb=0b00000001; // pino 1
if ((letra =='B') && (PORTA.F1==0))
portb=0b00001000; // pino4
if ((letra =='C') && (PORTA.F2==0))
portb=0b00010000;// pino5
15
if ((letra =='D') && (PORTA.F3==0))
portb=0b00100000;//pino 6
if ((letra =='E') && (PORTA.F4==0))
portb=0b01000000;// pino7
if ((letra =='F') && (PORTA.F5==0))
portb=0b10000000; //pino8
if ((letra =='G'))
porta=0b10000000; //pino8
if ((letra =='H'))
porta=0b01000000; //pino8
TMR0IF_bit = 0; // limpa a flag da interupção
TMR0 = 100; // Prescaler 1:32
16
Desenho do circuito para PCB
(Ferramenta Eagle)
Figura 13: Circuito completo
Figura 14: Alimentação e divisor de tensão para sensores (fins de curso)
17
Figura 15: Ponte H com respetivos díodos de roda livre para cada motor
Figura 16: Ponte H com respetivos díodos de roda livre para cada motor e pinça
18
Figura 17: Microcontrolador
Figura 18: Conecções
19
Figura 20: TOP e Bottom divisor tensão Figura 19: TOP e Bottom divisor tensão
com desenho dos componentes
Figura 24: Bottom do circuito de controlo Figura 21: Top do circuito de controlo
Figura 23: Top e Bottom do circuito de controlo Figura 22: Bottom do circuito de controlo com
desenho dos componentes
20
Controlador para eixos
Para o utilizador conseguir comandar o braço robótico a partir do computador foi
desenvolvido um software em visual basic, designado por controllex. Aqui são inseridos
os segundos, comprimento e posição de cada eixo e da garra.
É também possível selecionar a porta que estabelece a comunicação com a pic via
rs232.
Tem também a capacidade de ao se carregar no botão home, regressar a posição inicial.
O círculo no canto inferior esquerdo diz-nos se está a estabelecer ligação ou não: caso
esteja vermelho não estabelece comunicação, caso esteja verde a comunicação está a
ocorrer.
O botão valores padrão é responsável por o próprio robô encontrar uma posição de
forma autónoma.
Figura 25: Ferramenta para controlar os movimentos por coordenadas.
21
Anexos
Componentes Necessários
Unidades / nome componente
1-Lm7805;
12-diodos;
1-Pic 16f628a;
2-pontes lm298;
1-adaptador usb /rs232;
1-conector rs232 para soldar a uma PCB;
Resistências.
Gui Matlab
Inicialmente para o controlo dos eixos x, y e z em que o braço robótico atua foi criado
um código através da ferramenta gui matlab.
Para executar o cálculo que cada eixo percorre é feita a seguinte expressão:
Para o eixo x: 𝑃𝑜𝑛𝑡𝑜 𝑥 ×30
100
Para o eixo y: 𝑃𝑜𝑛𝑡𝑜 𝑦 ×20
100
Para o eixo z: 𝑃𝑜𝑛𝑡𝑜 𝑧 ×10
100
O raciocínio para este cálculo seria, através de uma regra de três simples, onde esta
serve para calcular o tempo que se demora a percorrer uma determinada distância nesse
eixo sendo a sua totalidade 100 cm que demora 30 segundos a ser percorrida. O mesmo
aconteceria nos restantes eixos, alterando-se apenas o tempo a percorrer a totalidade dos
eixos.
22
Depois de executado o código seria aberta a seguinte janela:
Este código foi uma tentativa que se revelou não ser muito eficaz, pois não era possível
executar uma boa comunicação entre o computador e a pic, faltando alguns parâmetros
essenciais para a movimentação do braço robótico.
Aqui é escolhido o valor de BaudRate
Aqui é mostrado o valor calculado através
da expressão 𝑃𝑜𝑛𝑡𝑜 𝑥 ×30
100
Aqui é colocado o valor da distância que se pretenda que o
braço robótico percorra
Aqui é escolhida a porta COM
Figura 26: Ferramenta para controlar os movimentos por coordenadas gui matlab.
23
Código Gui Matlab
function varargout = TRAB_FINAL1(varargin)
% Inicialização do Código
gui_Singleton = 1; gui_State = struct('gui_Name', mfilename, ... 'gui_Singleton', gui_Singleton, ... 'gui_OpeningFcn', @TRAB_FINAL1_OpeningFcn, ... 'gui_OutputFcn', @TRAB_FINAL1_OutputFcn, ... 'gui_LayoutFcn', [] , ... 'gui_Callback', []); if nargin && ischar(varargin1) gui_State.gui_Callback = str2func(varargin1); end
if nargout [varargout1:nargout] = gui_mainfcn(gui_State, varargin:); else gui_mainfcn(gui_State, varargin:); end % Fim da Inicialização do Código
% --- Executes just before TRAB_FINAL1 is made visible. function TRAB_FINAL1_OpeningFcn(hObject, eventdata, handles, varargin) % This function has no output args, see OutputFcn. % hObject handle to figure % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA) % varargin command line arguments to TRAB_FINAL1 (see VARARGIN)
% Choose default command line output for TRAB_FINAL1 handles.output = hObject;
% Update handles structure guidata(hObject, handles);
% UIWAIT makes TRAB_FINAL1 wait for user response (see UIRESUME) % uiwait(handles.figure1);
% --- Outputs from this function are returned to the command line. function varargout = TRAB_FINAL1_OutputFcn(hObject, eventdata,
handles) % varargout cell array for returning output args (see VARARGOUT); % hObject handle to figure % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA)
% Get default command line output from handles structure varargout1 = handles.output;
function Ponto_X_Callback(hObject, eventdata, handles)
24
% hObject handle to Ponto_X (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA)
% Hints: get(hObject,'String') returns contents of Ponto_X as text % str2double(get(hObject,'String')) returns contents of Ponto_X
as a double
% --- Executes during object creation, after setting all properties. function Ponto_X_CreateFcn(hObject, eventdata, handles) % hObject handle to Ponto_X (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles empty - handles not created until after all CreateFcns
called
% Hint: edit controls usually have a white background on Windows. % See ISPC and COMPUTER. if ispc && isequal(get(hObject,'BackgroundColor'),
get(0,'defaultUicontrolBackgroundColor')) set(hObject,'BackgroundColor','white'); end
function Ponto_Y_Callback(hObject, eventdata, handles) % hObject handle to Ponto_Y (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA)
% Hints: get(hObject,'String') returns contents of Ponto_Y as text % str2double(get(hObject,'String')) returns contents of Ponto_Y
as a double
% --- Executes during object creation, after setting all properties. function Ponto_Y_CreateFcn(hObject, eventdata, handles) % hObject handle to Ponto_Y (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles empty - handles not created until after all CreateFcns
called
% Hint: edit controls usually have a white background on Windows. % See ISPC and COMPUTER. if ispc && isequal(get(hObject,'BackgroundColor'),
get(0,'defaultUicontrolBackgroundColor')) set(hObject,'BackgroundColor','white'); end
function Ponto_Z_Callback(hObject, eventdata, handles) % hObject handle to Ponto_Z (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA)
% Hints: get(hObject,'String') returns contents of Ponto_Z as text
25
% str2double(get(hObject,'String')) returns contents of Ponto_Z
as a double
% --- Executes during object creation, after setting all properties. function Ponto_Z_CreateFcn(hObject, eventdata, handles) % hObject handle to Ponto_Z (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles empty - handles not created until after all CreateFcns
called
% Hint: edit controls usually have a white background on Windows. % See ISPC and COMPUTER. if ispc && isequal(get(hObject,'BackgroundColor'),
get(0,'defaultUicontrolBackgroundColor')) set(hObject,'BackgroundColor','white'); end
% Código para o botão CALCULAR
function pushbutton1_Callback(hObject, eventdata, handles)
px = str2num(get(findobj(gcf,'Tag','Ponto_X'),'String')); % Transforma
a string com a tag denominada Ponto_X em número py = str2num(get(findobj(gcf,'Tag','Ponto_Y'),'String')); % Transforma
a string com a tag denominada Ponto_Y em número pz = str2num(get(findobj(gcf,'Tag','Ponto_Z'),'String')); % Transforma
a string com a tag denominada Ponto_Z em número
x = ((px * 30)/100); % Calcula a operação e guarda o
resultado em x y = ((py * 20)/100); % Calcula a operação e guarda o
resultado em y z = ((pz * 10)/100); % Calcula a operação e guarda o
resultado em z
calc_x = x; set(findobj(gcf,'Tag','X'),'String',calc_x); % Mostra o
resultado da operação anterior na tag denominada X calc_y = y; set(findobj(gcf,'Tag','Y'),'String',calc_y); % Mostra o
resultado da operação anterior na tag denominada Y calc_z = z; set(findobj(gcf,'Tag','Z'),'String',calc_z); % Mostra o
resultado da operação anterior na tag denominada Z
% Código para escolher BaudRate
function baud_rate_Callback(hObject, eventdata, handles)
contents = cellstr(get(hObject,'String')); bau_rate = contents(get(hObject,'Value')); assignin('base','baud_rate',baud_rate); if (strcmp(baud_rate,'300')) % Na primeira opção de
baudrate aparece 300 popVal = 1;
26
elseif (strcmp(baud_rate,'1200')) % Na segunda opção de
baudrate aparece 1200 popVal = 2; elseif (strcmp(baud_rate,'2400')) % Na terceira opção de
baudrate aparece 2400 popVal = 3; elseif (strcmp(baud_rate,'9600')) % Na quarta opção de
baudrate aparece 9600 popVal = 4; end assignin('base','popVal',popVal)
% --- Executes during object creation, after setting all properties. function baud_rate_CreateFcn(hObject, eventdata, handles) % hObject handle to baud_rate (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles empty - handles not created until after all CreateFcns
called
% Hint: popupmenu controls usually have a white background on Windows. % See ISPC and COMPUTER. if ispc && isequal(get(hObject,'BackgroundColor'),
get(0,'defaultUicontrolBackgroundColor')) set(hObject,'BackgroundColor','white'); end
% --- Executes on button press in com. function com_Callback(hObject, eventdata, handles) % hObject handle to com (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA) % Desactivar botão actual set(hObject,'Enable','off');pause(0.1) % Tomar a ID da porta serie com=get(handles.com_e,'String'); % Verificar se e um ID válido if isempty(com)||isnan(str2double(com)) return end % Obter a velocidade (baud) contents = get(handles.los_baud,'String'); vel=str2double(contentsget(handles.los_baud,'Value')); %Configuração da porta serie handles.SerPIC = serial(['COM',com]);%Seleccionar a porta COM set(handles.SerPIC,'BaudRate',vel);%Velocidade set(handles.SerPIC,'DataBits',8);%8 bits de dados set(handles.SerPIC,'Parity','none');%sem control de paridade set(handles.SerPIC,'StopBits',1);%stop bit set(handles.SerPIC,'FlowControl','none');%flow control % Abrir a porta serie fopen(handles.SerPIC); % mensagem de abertura da porta serie warndlg(['Port COM',com,' OPEN'],'RS_232') % Habilitar o botao de envio set(handles.tx_b,'Enable','on') set(handles.los_baud,'Enable','off') % Actualizar a estrutura guidata(hObject,handles)
27
function com_ser_Callback(hObject, eventdata, handles) % hObject handle to com_ser (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA)
% Hints: get(hObject,'String') returns contents of com_ser as text % str2double(get(hObject,'String')) returns contents of com_ser
as a double
% --- Executes during object creation, after setting all properties. function com_ser_CreateFcn(hObject, eventdata, handles) % hObject handle to com_ser (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles empty - handles not created until after all CreateFcns
called
% Hint: edit controls usually have a white background on Windows. % See ISPC and COMPUTER. if ispc && isequal(get(hObject,'BackgroundColor'),
get(0,'defaultUicontrolBackgroundColor')) set(hObject,'BackgroundColor','white'); end
% --- Executes on button press in reset. function reset_Callback(hObject, eventdata, handles) % hObject handle to reset (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA)
top related