Instituto Tecnológico de Aeronáutica - ITA

Inteligência Artificial para Robótica Móvel - CT213

Aluno:

Relatório do Laboratório 1 - Máquina de Estados Finita e Behavior Tree

1 Breve Explicação em Alto Nível da Implementação

1.1 Máquina de Estados Finita

Nesta implementação, foi utilizada uma máquina de estados finita para controlar o comporta-
mento do robô Roomba. Durante a execução da máquina de estados, o método update é chamado
e os métodos check_transition() e execute() são executados. Durante a verificação de estados,
se forem atendidas as condições para a mudança de estado, o método change_state() é chamado
com um objeto de uma das quatro classes herdeiras da classe State. Para realizar verificações
de tempo, um atributo "time" é inicializado como 0 no construtor de cada classe de estado
particular, e é incrementado a cada execute para simular a passagem do tempo.
O estado de "andar para frente” verifica se o robô bateu na parede utilizando o método
getBumperState() do Roomba. Se o robô bater, ele muda para o estado de "recuar". Caso
contrário, se o tempo contado naquele estado exceder o tempo de movimento em linha reta, ele
muda para o movimento em espiral. O método execute apenas define a velocidade do agente
como linear, sem velocidade angular.
No estado de movimento em espiral, se o robô bater, ele muda para o estado de "voltar".
Caso contrário, se o tempo contado naquele estado exceder o tempo de execução da espiral, ele
muda para o estado de "andar para frente". Na execução, a velocidade linear é definida como
a mesma da de "mover para frente” e angular como a velocidade linear dividida pelo raio atual
(r0 + bt).
No estado de "recuar", a única transição a ser verificada é se o tempo excedeu o tempo de
recuo, e se sim, ele passa para o estado de "girar". No execute, a velocidade é definida como a
velocidade de recuo.
No estado de "girar", um ângulo aleatório é definido no construtor e o tempo de rotação é
calculado com base nesse ângulo e na velocidade angular. Na verificação de transição, o robô
passa para o estado de "andar para frente"após o tempo de rotação calculado. Na execução,
a velocidade é definida puramente como angular, usando a constante fornecida. É importante
salientar que, se o ângulo for negativo, a velocidade angular de rotação é multiplicada por -1
para permitir que o robô gire na direção oposta.

1.2 Behavior Tree

Primeiro deve-se construir a árvore: Define-se a raiz como o nó Selector. Depois, a essa raiz,
usa-se o método addChild para adicionar dois nós do tipo Sequence. Depois, ao primeiro nó
Sequence, adiciona-se na ordem: nó de MoveForward e nó InSpiral. Isso fará com que, caso não
haja falha, siga a sequência de mover para a frente e depois em espiral. No segundo Sequence,

1
que executará caso o primeiro falhe (ou seja, bata na parede), adiciona-se como filhos, na ordem:
nó de Recuar e nó de Rotacionar (comportamento que assume quando bate na parede). É
importante lembrar que durante a execução, será reaproveitado as modificações de velocidade já
usadas da máquina de estados finita.
Sobre o primeiro nó de Sequence, ele primeiro fará entrar no MoveForwardNode. No método
enter, é importante zerar o tempo (atributo que definiu-se em todas as classes de nó-folha) para
contar o tempo sempre a partir de quando entra naquele nó. O tempo recebe o incremento no
início de cada execute (repeti a inicialização e incremento do tempo em todas outras classes
de nó-folha). Dentro do execute, são feitas as verificações de mudanças de estado (que são
as mesmas já explicadas na máquina de estado finita), só que com outra implementação: em
caso de estar batendo, retornará FAILURE (O que propagará o retorno de FAILURE para o
nó Sequence e forçará o Selector (raiz da árvore) a ir para o outro Sequence). Ao passar do
tempo de andar pra frente, retornará SUCCESS, fazendo com que o próximo nó (espiral) seja
executado pelo Sequence que é "pai” dele. Caso nenhuma transição ocorra, retorna RUNNING.
Esse comportamento é padrão nos outros nós.
Caso o nó MoveForward obtenha SUCCESS, o Sequence faz executar o espiral. De modo
análogo, se bater retorna FAILURE (vai recuar), se passar tempo retorna SUCCESS (vai para
frente) e nos demais casos só retorna RUNNING para continuar no mesmo estado. O próximo
estado (de recuar) entra quando dá FAILURE em algum dos estados anteriores, entra como
primeiro nó do respectivo nó Sequence. Não há falha para esse nó (pois já ocorre quando bate).
Quando passa determinado tempo, retorna SUCCESS e passa para o estado de girar, e enquanto
isso fica retornando RUNNING. No estado rotate segue a mesma lógica de esperar tempo, e
também não há situação que falhe, uma vez que é impossível bater após ter dado um recuo antes
de girar.
É importante frizar que a parte de setar velocidades e tempos já foi previamente explicado
na explicação da máquina de estados finita.

2 Figuras Comprovando Funcionamento do Código

2.1 Máquina de Estados Finita

Figura 1: Print do início do comportamento do Roomba implementado com Máquina de Estados

Finita.

2
Figura 2: Print da continuação do comportamento do Roomba implementado com Máquina de
Estados Finita após já ter batido na parede (começa a assumir direções aleatórias e seguir o resto
do comportamento).

2.2 Behavior Tree

Figura 3: Print do início do comportamento do Roomba implementado com Behavior Tree.

Figura 4: Print da continuação do comportamento do Roomba implementado com Behavior

Tree após já ter batido na parede (começa a assumir direções aleatórias e seguir o resto do
comportamento).