INTRODUÇÃO À ROBÓTICA – RESOLUÇÃO DOS EXERCÍCIOS

1. Considere o robot móvel disponível para esta unidade curricular. Este desloca-se num
plano horizontal por intermédio de duas rodas motrizes diferenciais e com uma terceira roda
livre para apoio.

1.a. Programação do robot e preparação para a sua utilização:

Determinação do IP do robot:

Começa-se por descarregar e descomprimir a parta com o firmware a utilizar (disponível nos
Conteúdos da Unidade Curricular). De seguida, executa-se o programa Visual Studio Code e
abre-se a pasta descomprimida indo a File → Open Folder.

Na lista que aparece do lado esquerdo seleciona-se o ficheiro min.cpp. Nas linhas 315 e 316,
remove-se as barras inicias “//” e substitui-se os “XXXX” pelo SSID da rede wireless a utilizar
(TP-Link_28CD) na linha 315 e pela chave de acesso (49871005) na linha 316.

Feito isto, liga-se o robot ao computador com um cabo USB e compila-se e descarrega-se o
firmware clicando na seta (→) presente na barra azul presente na parte inferior do ecrã.

De seguida, aciona-se o PlatformIO: Serial Monitor (símbolo na barra azul). Ao fazer

isto, começa-se a visualizar as mensagem que o robot manda para o computador. É nessa série
de mensagens emitidas pelo robot que se pode visualizar o seu IP (que é algo como
192.168.0.158).

Instalação e utilização do software de controlo do robot:

Começa-se por descarregar e descomprimir a pasta com o software a utilizar (disponível nos
Conteúdos da Unidade Curricular). Deve-se, depois, abrir o ficheiro com o nome PCRobot.exe.

A primeira coisa a fazer no software é introduzir o IP do robot e, em seguida, carregar no botão

Connect. A partir daí, o software já está pronto para poder começar a controlar o robot.
Pode-se também ligar-se ao robot através da porta série (cabo USB). Para isso deve-se verificar
qual é a porta série utilizada pressionando com o botão do lado direto no símbolo Start do
Windows escolhendo a opção Device Manager:

Deve aparecer o quadro seguinte onde, no item Ports (COM & LPT), podemos ver a porta série,
neste caso a COM4:
Introduzindo-se esse valor no campo COM Port e pressionando o botão Open deveremos ter a
ligação ao robot por cabo. Antes de efetuar esta ligação deve fechar o programa Visual Studio
Code para que este liberte a porta série.

1.b. Movimento linear:

Movimentar o robot em linha reta de modo a determinar a relação entre os impulsos gerados
pelos sensores nas rodas e o deslocamento linear de cada roda (k):

1. Pressionar o botão Clear Enc para colocar a zero as somas das contagens dos
impulsos do enconder Senc 1 e Senc 2;
2. Escrever um valor para PMW 1 e PMW 2 na coluna Write (por exemplo, -30 e -30)
e pressionar Set PWM;
3. Para pôr o robot em movimento, pressionar Set State ao lado do valor 201,
colocando o robot no estado 201 onde se aplica os valores de PWM nos motores;
4. Para parar o robot, pressionar Set State ao lado do valor 200.
5. Usando os valores obtidos para Senc 1 e Senc 2, calcular a constante que relaciona
os impulsos com a distância percorrida (k):

Valores obtidos:

 Senc 1: - 4473
 Senc 2: - 4222
 Distância percorrida pelo robot (d): 23,5 cm (medido com régua)

k i . Senc i=d

Roda 1: k 1 . (−4473 ) =d ( ¿ ) k 1=−0,005254

Roda 2: k 2 . (−4222 )=d ( ¿ ) k 2=−0,005566
(−0,005254 ) + (−0,005566 )
k= =−0,00541 [ para distância medida emcm ] =¿
2
= −¿ 0,0000541 [para distância medida em m]

Nota: O sinal negativo apenas serve para indicar que o robot andou para trás.

1.c. Movimento angular:

Movimentar o robot apenas com velocidade angular e determinar o valor da distância entre as
rodas (b):

1. Escrever um valor para PMW 1 e PMW 2 na coluna Write (por exemplo, -30 e 30).
Pressionar Set PWM e deixar o robot fazer uma volta completa (2π radianos).

Valores obtidos:

 Senc 1: - 7446
 Senc 2: 6597
d1 −d 2 ( k 1 ) × ( Senc 1 ) −(k 2) ×( Senc 2)
ΔΘ = ( ¿ ) ΔΘ= (¿)
b b

(−0,005254 ) × (−7446 )−(−0,005566)×(6597)

( ¿) 2 π = =12,07 cm=0,1207 m
b

1.d. Movimentos compostos:

Verificar que pode efetuar movimentos compostos (ou seja, em que simultaneamente
possuem translação e rotação) e, com uma só experiência, determinar os parâmetros das
alíneas anteriores (k e b).

Com os valores de PWM de - 30 para ambas as rodas, o robot efetua movimentos de

translação (linear) e, com valores de PWM de -30 para uma roda e 30 para a outra, o robot
efetua movimentos de rotação (angular).
 Logo, para o robot fazer movimentos compostos (translação e rotação), temos de ter um valor
negativo numa roda e positivo noutra, mas não podem ser simétricos.

Depois, é só repetir os cálculos anteriores.

2. Definições de variáveis:

Alterando o código presente no ficheiro robot.cpp, nomeadamente o procedimento odometry

(linhas 33 a 54), implementar as equações que estimam a velocidade do robot e a estimativa
da sua posição e orientação em função dos impulsos recebidos do encoder (Enc1 e Enc2)

i. Ir ao ficheiro robot.cpp e, na parte onde diz robot_t, alterar os valores apresentados nas
variáveis pulses_to_meters e wheel_dist:

k 1 +k 2 0,005254+0,005566
 pulses_to_meters = = = 0,00541 cm = 0,0000541 m
2 2
 wheel_dist = 12,22 cm = 0,1222 m (é o valor real de b, calculado anteriormente
[0,1207 m], medido com a régua)

ii. No ficheiro robot.h está definida a classe Robot_t e pode-se ver as variáveis associadas
ao robot, onde:

 enc1 e enc2 - Leitura os impulsos provenientes dos encoders;

  ds e dtheta - Deslocamentos linear e angular, respetivamente, em cada ciclo de
controlo;
 x, y e theta - Posição e orientação do robot no referencial cartesiano global.

Pode-se ver os valores calculados para x, y e theta (ϴ) na tabela de variáveis presente no
programa PCRobot. Para inicializar estas
variáveis com um determinado valor,
insira o mesmo na coluna da direita e
pressione o botão Set XYϴ.
Para atuar no robot de alguma forma deve-se utilizar o código presente no ficheiro control.cpp
onde pode criar estados com as atuações pretendidas e, através do programa no computador,
colocar o robot nesse estado (ver exercício 4).

É também útil ver o código presente no procedimento real_loop, dentro do ficheiro main.cpp.
Este código é executado periodicamente, a uma frequência muito elevada, e chama os
procedimentos e funções referidas anteriormente (ver exercício 3).

3. Controlo em malha fechada da velocidade de cada roda:

Encontrar a relação média entre o valor do PWM aplicado e a velocidade linear do robot em
m/s (Kf):

i) Aplicar um determinado valor de PWM nas duas rodas e ler o valor dos impulsos
gerados em cada ciclo de 40 ms (Enc1 e Enc2 em PCRobot).

Valores definidos Valores obtidos

PWM = -30 Enc1 = -52 Enc2 = -50
PWM = -20 Enc1 = -32 Enc2 = -30
PWM = -10 Enc1 = -7 Enc2 = -5
PWM = 15 Enc1 = 19 Enc2 = 17
PWM = 30 Enc1 = 49 Enc2 = 45

ii) Converter os valores da alínea anterior para m/s, primeiro convertendo para m/ciclo
e depois para m/s.

PWM Enc1 Enc2 m/ciclo1 m/ciclo2 m/s1 m/s2

-30 -52 -50 -1300 -1250 -0,068302 -0,069575
-20 -32 -30 -800 -750 -0,042032 -0,041745
-10 -7 -5 -175 -125 -0,0091945 -0,0069575
 15 19 17 475 425 0,0249565 0,0236555
30 49 45 1225 1125 0,0643615 0,0626175

Exemplo de cálculo de m/ciclo (para PWM = -30):

Enc 1 −52
 m/ciclo1 = = −3 = −1300
40 40 x 10
Enc 2 −50
 m/ciclo2 = = = −1250
40 40 x 10−3

Exemplo de cálculo de m/s (para PWM = -30):

 m/s1
=

m/ ciclo 1 ×k 1 =¿ −1300 ×0,00005254 = −0,068302

 m/s2 = m/ciclo 2 ×k 2=¿ −1250 ×0,00005566 = −0,069575

Representando graficamente a velocidade linear em m/s em função de PWM, temos que:

O

valor de kf, que corresponde ao declive do gráfico, é de 468 para a roda 1 e 470 para a roda 2.
Considera-se o valor médio: 469.

3.a. O ganho calculado na alínea anterior (kf) será o bloco de Feedforward da figura seguinte:

O controlador PID por realimentação terá uma equação do tipo:

Out_PID = Kp*Erro + Ki*Integral_do_erro + Kd*Derivada_do_erro

No ficheiro PID.cpp, no procedimento calc(.), pode-se ver uma aproximação numérica destas
equações. Repare no Anti windup e na limitação do sinal de saída.
No ciclo principal do programa, presente no ficheiro “main.cpp”, procedimento “real_loop(.)”,
poderá observar o seguinte código:
Como se pode observar, para os estados 200 a 255, o PWM enviado para o motor é o
determinado no control(.) em control.cpp, e para os estados 0 a 199, o PWM é calculado com o
controlador PID + Feedforward.

Repare que, quando a referência de velocidade é 0, coloca-se o PWM e a variável relacionada

com a integração a 0. Isto porque, devido à zona morta do motor, é possível ter o motor
parado com algum PWM, o que não é desejável (pode-se testar alterando o código).

Desta forma o motor pára rapidamente devido ao atrito. Noutras situações, pode não ser o
mais adequado (por exemplo querer manter o robot parado mesmo numa descida ou subida).

i) No programa do robot, deve-

se começar por introduzir o
valor de Kf determinado
anteriormente
(469).

i) Depois, definimos a
velocidade linear como
sendo 0,05 m/s.
No código, a velocidade linear “v” e angular “w” são convertidas em velocidades nas rodas:

Com este controlo apenas baseado no Feedforward, é possível ter velocidades ligeiramente
diferentes em cada roda e é muito fácil perturbar a velocidade de cada roda.
ii) Calcule para uma velocidade linear de 0,05 m/s qual o número de impulso por
ciclo que deve ter em cada roda.

Nas equações anteriores, substituir o “robot.v” por 0,05 e o “DISTWHEELS” por 0,1222. Como
não há velocidade angular, a velocidade nas duas rodas vai dar igual, por isso pode-se
introduzir logo no PCRobot a velocidade linear (no campo “v”) de 0,05 m/s.

Feito isto, regista-se os valores de “Enc1” e “Enc2” fornecido pelo programa após colocar o
robot em movimento com 0,05 m/s.

ii) Introduza agora um valor para o ganho, por exemplo Kp = 300. Observe o valor
obtido em regime permanente para os impulsos por ciclo para diferentes valores de
ganho. Repare que, neste robot, a diferença entre ter as rodas no ar e pousadas não
é significativa (não é sempre assim em todos os robots). Suba o ganho em passos de
300 a 500 e observe os diferentes valores em regime permanente e as oscilações
quando se passa de uma referência 0 m/s para 0.05 m/s. Quando começar a oscilar
bastante, anote o valor. Assuma um valor bastante mais baixo (seja ¼ deste valor)
para se ter uma boa margem de segurança.

Começam-se a registar oscilações a partir de K p = 500.

iii) Altera agora a constante relacionada com a integração (K i), iniciando em 1000,
incrementando com passos de 1000 e observando a resposta a variações na
 velocidade de referência em 0 m/s e 0,05 m/s. Escolha um valor que não gere sobre
elongações nem oscilações.

Começam-se a registar oscilações a partir de K i = 4500.

iv) Introduza agora novamente o valor de Kf. Observe que agora temos uma sobre
elongação forte.

Introduzindo um pequeno valor em Kd (cerca de 10) diminui essa sobre elongação,

mas rapidamente começa a gerar oscilações. Diminua a sobre elongação diminuindo
simultaneamente Ki e Kf.

Ao baixar o Ki até 2500 e o Kf até 300, conseguimos contrariar a sobre elongação.

4. Fazer com que o robot percorra a linha preta num único estado (100)
Num dos estados em control(.), implementar um controlador que impõe uma velocidade linear
“v” constante e uma velocidade angular “w” que varia em função da leitura dos sensores de
linha de modo que o robot consiga seguir uma linha. As leituras dos sensores (IR 1 a 5) estão
disponíveis num vetor IRLine.IR_values[0 a 4].

4.a. Começar, por exemplo, por usar apenas os dois sensores de cada extremidade e um
novo estado 100:

Originalmente, o código apresenta isto:

É aqui que se tem de mexer. O “robot.v_req” é onde se impõe a velocidade linear e o

“robot.w_req” é onde se impõe a velocidade angular.

Os sensores de cada extremidade são os sensores 5 e 1, que no vetor correspondem aos

números 4 e 0, respetivamente. A velocidade angular ficará, então, algo como:

4.b. Aumente a velocidade linear até ao limite máximo que conseguir sem que o robot perca
a linha:

O “robot.v_req” inicialmente é 0,1 m/s (como se vê na figura acima). A velocidade linear

máxima que o robot consegue ter sem perder a linha e usando os sensores de velocidade
definidos anteriormente é de 0,5 m/s, ficando o código assim:

4.c. Observando os valores das leituras dos sensores repare que existe uma pequena zona na
transição entre preto e branco que o sensor dá uma leitura intermédia entre os valores de
branco e preto.
Usando este facto faça agora um controlador que use o sensor do meio e siga a borda
interior da linha:

Utilizam-se os sensores 4 e 2, que no vetor correspondem aos números 3 e 1, respetivamente.

O sensor 3 (número 2 no vetor) nunca precisa de ser utilizado porque as alterações nos
sensores 4 e 2 são suficientes para que o robot siga a borda interior da linha.
5. Fazer com que o robot percorra a linha preta com mudanças de estado

Criar um estado 99 para apenas inicializar a posição e orientação do robot, variáveis “robot.x”,
“robot.y” e “robot.theta” no valor zero correspondente ao início da primeira reta mais longa,
ou seja estamos, a considerar que o referencial cartesiano tem o eixo x coincidente com essa
reta e a origem nesse ponto. De seguida, passar logo para o estado 100.

Acrescente mais regras de transição de estado e os respetivos estados de modo que o robot
passe para o estado 101 um pouco antes de chegar à curva, para o 102 um pouco depois de
sair da curva e assim sucessivamente. Desta forma o robot sabe sempre em que parte da pista
está. Crie também um estado final em que o robot pare sensivelmente a meio da reta inicial.
6. Equações de odometria:

Aproveitando o facto de saber em que parte da pista está o robot pode, nas retas, ter alguma
certeza sobre o ângulo e uma das coordenadas, usando os impulsos apenas para estimar a
outra coordenada. Veja o procedimento odometry e atue em conformidade.

7. Movimentar o robot sem usar a linha:

Teste agora, em alguns estados, movimentar o robot sem usar a linha, ou seja, por exemplo
quando entrar num estado correspondente a uma curva, aplicar uma velocidade linear e
angular constantes e com um valor que leve o robô ao início da próxima reta, ignorando os
sensores de linha. Teste
a sua eficiência
tapando a linha com
uma folha.
8. Movimentar o robot para um ponto com coordenadas (x,y)

Implemente um estado em que o robot se movimente para um determinado ponto com

coordenadas (xf, yf) e pare assim que estiver a uma distância inferior a um certo limite. Atue
na velocidade angular de modo a corrigira a diferença entre a orientação atual do robô e a
orientação que deve ter quando aponta para esse ponto de destino.

9. Utilize o procedimento da alínea anterior para navegar em zonas sem linhas ou com as
linhas interrompidas.