MATHIAS NEGRÃO KUX

RAFAEL DE MELLO VILLATORE

INTERFACE DE CONTROLE ROBÓTICO DE ALTO NÍVEL ASSOCIADO A

FPGA

São Caetano do Sul

2014

1
 MATHIAS NEGRÃO KUX
RAFAEL DE MELLO VILLATORE

INTERFACE DE CONTROLE ROBÓTICO DE ALTO NÍVEL ASSOCIADO A

FPGA

Trabalho de conclusão de curso apresentado à Escola de

Engenharia Mauá do Centro Universitário do Instituto
Mauá de Tecnologia como requisito parcial para a
obtenção do título de Engenheiro Eletrônico.
Área de concentração: Engenharia Eletrônica

Orientador: Dr. Wânderson de Oliveira Assis

São Caetano do Sul

2014

2
 Kux, Mathias Negrão
Interface de controle robótico de alto nível associado a
FPGA/Mathias Negrão Kux, Rafael de Mello Villatore, Wânderson de
Oliveira Assis – São Caetano do Sul, SP : IMT-CEUN, 2014.
59p.
1. Controle Robótico 2. FPGA 3. Servomotor 4. BeagleBone Black
5. DE0-Nano I. Kux, Mathias Negrão. II. Villatore, Rafael de Mello.
III. Assis, Wânderson de Oliveira. IV. Instituto Mauá de Tecnologia.
Centro Universitário. V. Interface de controle robótico de alto nível
associado a FPGA.

3
 LISTA DE FIGURAS

FIGURA 1 - KIT ROBONOVA-1 ................................................................................................................................ 13

FIGURA 2 – IMAGEM DA PLACA COM TECNOLOGIA FPGA (DE0-NANO)............................................................... 17
FIGURA 3 – IMAGEM DA PLACA PROCESSADORA (BEAGLEBONE BLACK) ............................................................. 18
FIGURA 4 – VISÃO GERAL DO SISTEMA ................................................................................................................. 18
FIGURA 5 – IMAGEM DA PLACA DE0-NANO .......................................................................................................... 21
FIGURA 6 – RECURSOS DA PLACA DE0-NANO ....................................................................................................... 22
FIGURA 7 – ARQUITETURA DESENVOLVIDA NO FPGA .......................................................................................... 23
FIGURA 8 – BLOCO ESQUEMÁTICO DO MÓDULO PWM ....................................................................................... 24
FIGURA 9 – CÓDIGO FONTE DO MÓDULO PWM ................................................................................................... 25
FIGURA 10 – MÓDULO DO GRUPO DE PWM......................................................................................................... 26
FIGURA 11 – BLOCO ESQUEMÁTICO DO MÓDULO INTERPRETADOR ................................................................... 27
FIGURA 12 – CÓDIGO FONTE DO MÓDULO INTERPRETADOR .............................................................................. 28
FIGURA 13 – CARTA DE TEMPOS DO PROTOCOLO UART ...................................................................................... 29
FIGURA 14 – BLOCO ESQUEMÁTICO DO MÓDULO RX DA UART ........................................................................... 30
FIGURA 15 – CÓDIGO FONTE DO MÓDULO RX DA PORTA UART .......................................................................... 31
FIGURA 16 – CONEXÃO DO ACELERÔMETRO COM O FPGA .................................................................................. 32
FIGURA 17 – VALORES MEDIDOS PELO ACELERÔMETRO...................................................................................... 33
FIGURA 18 – BLOCO ESQUEMÁTICO DO MÓDULO AMOSTRADOR....................................................................... 34
FIGURA 19 – CÓDIGO FONTE DO MÓDULO AMOSTRADOR .................................................................................. 35
FIGURA 20 – BLOCO ESQUEMÁTICO DA PLL ......................................................................................................... 36
FIGURA 21 – IMAGEM DA PLACA BEAGLEBONE BLACK ........................................................................................ 37
FIGURA 22 – CONFIGURAÇÃO DA COMUNICAÇÃO DAS PLACAS .......................................................................... 39
FIGURA 23 – MÉTODO PARA O CONTROLE DE UM MOTOR ................................................................................. 41
FIGURA 24 – ATRIBUIÇÃO DA POSIÇÃO DO GRUPO DE SERVOMOTORES ............................................................ 42
FIGURA 25 – IMAGEM DO SERVOMOTOR INSTALADO NO ROBÔ ......................................................................... 43
FIGURA 26 – INTERFACE ELÉTRICA DO SERVOMOTOR .......................................................................................... 43
FIGURA 27 – RELAÇÃO ENTRE O ÂNGULO E A LARGURA DE PULSO DO SINAL DE CONTROLE ............................. 44
FIGURA 28 – POSSÍVEIS VALORES PARA A GERAÇÃO DO PWM ............................................................................ 45
FIGURA 29 – LEITURA DE POSIÇÃO DO SERVOMOTOR ......................................................................................... 46
FIGURA 30 – DISPOSIÇÃO DOS MOTORES NO ROBONOVA-1. .............................................................................. 49
FIGURA 31 – CÓDIGO FONTE DA AÇÃO "ANDAR PARA FRENTE" .......................................................................... 50
FIGURA 32 – CONFIGURAÇÃO DO QT CREATOR.................................................................................................... 56
FIGURA 33 – EXEMPLO DE COMPILADOR CONFIGURADO CORRETAMENTE ........................................................ 57
FIGURA 34 – ADICIONANDO UMA NOVA VERSÃO DO QT..................................................................................... 57

4
FIGURA 35 – CONFIGURAÇÃO BEM SUCEDIDA DE UM DEBBUGER ...................................................................... 58
FIGURA 36 – CONFIGURAÇÃO FINAL DO QT ......................................................................................................... 59

5
 SUMÁRIO

LISTA DE FIGURAS ............................................................................................................................................ 4

1 RESUMO .................................................................................................................................................. 9
2 ABSTRACT ...............................................................................................................................................10
3 INTRODUÇÃO .........................................................................................................................................11

3.1 OBJETIVO ................................................................................................................................................. 12

3.2 MOTIVAÇÃO ............................................................................................................................................. 12

4 APRESENTAÇÃO DOS COMPONENTES ....................................................................................................14

4.1 INTRODUÇÃO AO FPGA .............................................................................................................................. 14

4.2 INTRODUÇÃO AO PROCESSADOR ................................................................................................................... 14
4.3 INTRODUÇÃO AO MICROCONTROLADOR ......................................................................................................... 15
4.4 INTRODUÇÃO AO SERVOMOTOR ................................................................................................................... 15

5 HARDWARE ............................................................................................................................................16

5.1 VISÃO GERAL ............................................................................................................................................ 16

6 SOFTWARE..............................................................................................................................................19

6.1 SOFTWARE DO FPGA ................................................................................................................................. 19

6.2 SOFTWARE DO PROCESSADOR ...................................................................................................................... 19
6.3 MÁQUINA VIRTUAL.................................................................................................................................... 20

7 FPGA .......................................................................................................................................................21

7.1 VISÃO GERAL ............................................................................................................................................ 21

7.1.1 Especificações Técnicas ............................................................................................................. 21

7.2 ARQUITETURA IMPLEMENTADA .................................................................................................................... 23

7.3 MÓDULO PWM ....................................................................................................................................... 23

7.3.1 Descrição ................................................................................................................................... 23

7.3.2 Bloco Esquemático .................................................................................................................... 24
7.3.3 Código verilog do módulo.......................................................................................................... 24

7.4 CONJUNTO DE MÓDULOS PWM................................................................................................................... 25

6
 7.4.1 Bloco Esquemático .................................................................................................................... 25

7.5 MÓDULO INTERPRETADOR .......................................................................................................................... 26

7.5.1 Descrição ................................................................................................................................... 26

7.5.2 Bloco Esquemático .................................................................................................................... 26
7.5.3 Código verilog ............................................................................................................................ 27

7.6 UART ..................................................................................................................................................... 28

7.6.1 Descrição do protocolo .............................................................................................................. 28

7.6.2 Bloco Esquemático .................................................................................................................... 30
7.6.3 Código verilog ............................................................................................................................ 31

7.7 ACELERÔMETRO ........................................................................................................................................ 32

7.7.1 Descrição ................................................................................................................................... 32

7.8 AMOSTRADOR .......................................................................................................................................... 33

7.8.1 Descrição ................................................................................................................................... 33

7.8.2 Bloco Esquemático .................................................................................................................... 34
7.8.3 Código verilog ............................................................................................................................ 34

7.9 PLL ........................................................................................................................................................ 35

7.9.1 Bloco Esquemático .................................................................................................................... 35

8 PROCESSADOR ........................................................................................................................................37

8.1 VISÃO GERAL ............................................................................................................................................ 37

8.1.1 Especificações Técnicas ............................................................................................................. 37

8.2 SISTEMA OPERACIONAL .............................................................................................................................. 38

8.3 EXECUÇÃO DE CÓDIGO ................................................................................................................................ 38
8.4 CÓDIGO FONTE DESENVOLVIDO .................................................................................................................... 39

8.4.1 Configuração da UART .............................................................................................................. 39

8.4.2 Método de Controle do Servomotor .......................................................................................... 40
9 SERVOMOTORES.....................................................................................................................................43

9.1 VISÃO GERAL ............................................................................................................................................ 43

9.2 CONTROLE DO SERVOMOTOR ....................................................................................................................... 44

9.2.1 Controle de Posição ................................................................................................................... 44

9.2.2 Leitura de Posição ..................................................................................................................... 45
10 MÁQUINA VIRTUAL ................................................................................................................................47

7
 10.1 VISÃO GERAL ............................................................................................................................................ 47
10.2 SISTEMA OPERACIONAL .............................................................................................................................. 47
10.3 COMPILAÇÃO CRUZADA .............................................................................................................................. 48
10.4 QT E QT CREATOR ..................................................................................................................................... 48
10.5 CONFIGURAÇÃO ........................................................................................................................................ 48

11 CONTROLE DE MOVIMENTAÇÃO DE ROBÔ HUMANOIDE .......................................................................49

11.1 TESTE DE APLICAÇÃO.................................................................................................................................. 49

12 RESULTADOS E CONCLUSÕES ..................................................................................................................52

13 BIBLIOGRAFIA .........................................................................................................................................53
14 APÊNDICE I – INSTALAÇÃO COMPLETA DO AMBIENTE DE MÁQUINA VIRTUAL .......................................54

14.1 CONFIGURAÇÃO DO QT CREATOR ................................................................................................................. 55

8
1 RESUMO

Foi desenvolvida uma plataforma genérica, intuitiva e programável para aplicações em

controle. Essa plataforma tem como principal característica a distribuição do processamento
em duas placas de desenvolvimento distintas, a placa DE0-Nano, com tecnologia FPGA e a
placa BeagleBone Black, um processador. Para o trabalho com essas placas, foi desenvolvido
um ambiente de desenvolvimento instalado em uma máquina virtual com sistema operacional
Linux. Além do desenvolvimento dessa plataforma, também foi feita a aplicação da mesma no
controle de um robô humanoide de pequeno porte, frequentemente utilizado nas competições
de robótica universitária e analisados os resultados obtidos.
Palavras-chave: Controle Robótico, FPGA, servomotor, BeagleBone Black, DE0-
Nano.

9
2 ABSTRACT

A generic, intuitive and programmable platform for applications in control was

developed. This platform main feature is splitting the processing into two different boards,
DE0-Nano, with FPGA technology and BeagleBone Black board, a processor. To work with
these boards, it was developed a development environment, installed into a virtual machine
operating Linux. In addition to developing of this platform, it was also made an application
within the control of a small humanoid robot, often used in university robotics competition
and analyzed the results.
Key-words: Robotic Control, FPGA, servomotor, BeagleBone Black, DE0-Nano

10
3 INTRODUÇÃO

A eletrônica é uma área em constante ascensão. Constantemente são lançados no

mercado novos componentes eletrônicos e novas tecnologias destinadas a aplicações das mais
diversas em áreas de conhecimento como computação, telecomunicações, eletrotécnica,
eletrônica embarcada, entre outras. São exemplos de aplicação a automação residencial e
industrial, a eletrônica embarcada em dispositivos móveis, brinquedos eletrônicos, os
eletroeletrônicos e eletrodomésticos, a robótica, e muitas outras.
Especificamente na área da robótica, o emprego de novas tecnologias é abordado em
diversas pesquisas e projetos avançados. Existem robôs para entretenimento, robôs
domésticos os quais são uma grande aposta para o futuro, robôs assistentes como os
empregados em cirurgias (DIODATO et al., 2004), e robôs industriais encontrados nas
indústrias automobilísticas. Alguns robôs são utilizados na exploração de ambientes hostis, ou
seja, ambientes que sejam prejudiciais ao ser humano (GUIMARÃES, 2006) como por
exemplo, em gasodutos, em tanques para transporte e armazenamento de produtos químicos,
gases tóxicos ou radiação nuclear, em locais onde há risco de desabamento. Outros robôs são
utilizados no desarmamento de bombas ou no resgate de sobreviventes em locais de difícil
acesso ou em casos de explosões ou desastres ambientais (LI et al., 2010) (ASCHENBRUCK
et al., 2009).
Muitos projetos envolvem a participação em competições estudantis de robótica,
alguns deles aplicando tecnologias avançadas com placas de FPGA (Field Programmable
Gate Array) e processadores com tecnologia ARM (Advanced RISC Machine)
(CMDRAGONS, 2014) (TONIDANDEL; BIANCHI, 2014).
Particularmente em relação a projetos utilizando robôs humanoides desenvolvidos no
Centro Universitário do Instituto Mauá de Tecnologia, merecem destaque ZANZARINI et al.
(2009), RIZZUTI et al. (2010), ACCARINI et al. (2010) e ACCARINI et al. (2011).
Este trabalho propõe uma contribuição para o estudo de robôs humanoides, bem como
para outros projetos na área de eletrônica embarcada, por meio do estudo e implementação de
tecnologias eletrônica recentemente disponibilizadas comercialmente.

11
3.1 OBJETIVO

Este trabalho tem como objetivo a construção de uma plataforma programável e

intuitiva para controle de dispositivos, sejam eles motores, atuadores ou até mesmo
medidores, a qual pode ser utilizada em qualquer tipo de aplicação, desde um controle direto
de poucos mecanismos até o controle de uma alta variedade de equipamentos e funções
inteligentes.
Esta plataforma será constituída de dois componentes principais: um FPGA e um
processador. O FPGA será utilizado para fazer a interface direta com o hardware, no qual
serão definidas saídas digitais, de alta velocidade e no protocolo adequado a cada dispositivo
da malha de controle. O processador será responsável pela interface entre o FPGA e o usuário,
possibilitando uma programação tanto de baixo nível, quando necessário, quanto de alto nível,
se for mais conveniente.
Esta plataforma foi aplicada ao kit ROBONOVA-1, robô humanoide de pequeno
porte, a fim de controlar seus movimentos e permitir que, futuramente, sejam desenvolvidos
algoritmos mais complexos e de melhor desempenho para que se obtenham melhores
resultados em competições de robótica.

3.2 MOTIVAÇÃO

A principal motivação para a escolha deste projeto foi o trabalho, na iniciação

científica, com o controle de um robô humanoide capaz de jogar futebol. Essa tarefa é
altamente complexa, pois envolve coordenação com outros membros da equipe e alta
inteligência para tomada de decisões, além de controlar os servomecanismos do robô.
Portanto, é necessária a programação da inteligência do software e a preocupação com o
acionamento do hardware simultaneamente.
A abordagem deste problema utilizando um microcontrolador limita muito a
capacidade de utilização do hardware do robô, bem como dificulta o trabalho de se criar um
algoritmo inteligente capaz de permitir que o mesmo tome as decisões necessárias em uma
partida de futebol, por mais que as regras tenham sido simplificadas para a competição. Dessa
forma, a utilização de uma plataforma diferente de controle para o robô se torna interessante,
uma vez que permite tanto a criação de rotinas e sub-rotinas para o algoritmo de jogar futebol
numa linguagem de alto nível, quanto um controle mais preciso, eficiente e rápido para o
hardware que será utilizado.

12
A figura 1 mostra o kit ROBONOVA-1 montado conforme o manual de fábrica:

Figura 1 - Kit ROBONOVA-1

Fonte: HITEC ROBOTICS (2007)

13
4 APRESENTAÇÃO DOS COMPONENTES

4.1 INTRODUÇÃO AO FPGA

Um FPGA (Field-Programmable Gate Array) é um dispositivo de hardware formado

por milhões de elementos lógicos (portas lógicas e flip-flops) programáveis, dispostos em
uma matriz lógica, o que permite a criação de algoritmos sintetizados diretamente em
hardware, ou seja, livre da existência de um processador. Devido a isso, surgem como
principais vantagens:

 tratamento paralelo de diversas entradas, pois não é necessária uma abordagem

“passo-a-passo” como em um microcontrolador;
 alta velocidade no tratamento de cada entrada, já que os elementos lá presentes
são puro hardware;

O ambiente de trabalho para esse tipo de dispositivo permite a criação de “blocos” de

processo que podem ser sintetizados numa linguagem de descrição de hardware (HDL). Há
também, a possibilidade de programação sequencial, assim como no microcontrolador.

4.2 INTRODUÇÃO AO PROCESSADOR

Um processador é um dispositivo programável formado por uma Unidade Lógico-

Aritmética e diversos registradores e contadores, os quais são utilizados por meio de uma lista
de instruções (instruction set). Ao se enviar um comando para o processador ele será
executado com base na sua lista de instruções, uma sequência desses comandos forma um
programa, o qual ao ser executado realiza uma determinada função. Essa lista de comandos é
executada passo a passo e cada um desses passos tem uma duração pré-determinada com base
em uma frequência de operação característica do processador. O armazenamento dessa lista
de comandos é externo ao processador, sendo feito em uma memória externa.
O processador é o cérebro de praticamente todo dispositivo eletrônico, por exemplo:

 celulares
 computadores
 roteadores

14
  calculadoras
 televisores

4.3 INTRODUÇÃO AO MICROCONTROLADOR

Um microcontrolador nada mais é do que um computador de pequeno porte

programável. Ele é constituído de um processador, uma ou mais memórias e de diversos
periféricos. Suas principais características são a alta aplicabilidade a processos e de fácil
implementação de códigos, sendo possível escolher até mesmo a linguagem de programação a
ser utilizada nele.
Não foi utilizado um microcontrolador neste projeto, esta sessão serve para ressaltar a
diferença entre um microcontrolador e um processador, além de esclarecer que é possível sua
utilização no lugar do processador. Neste projeto, só foi utilizado um processador porque não
eram necessários os recursos oferecidos por um microcontrolador.

4.4 INTRODUÇÃO AO SERVOMOTOR

Um servomotor é um dispositivo mecânico controlado por um sinal de controle

elétrico. O sinal de controle força uma posição desejada no eixo do servomotor com altíssima
precisão. Em contra partida, a rotação está limitada a um intervalo definido ou seja, o eixo do
motor não pode dar sucessivas voltas. Apesar disso, possuem elevado torque e alta velocidade
de rotação, uma vez que internamente, o servomotor possui uma malha fechada atuando sobre
o eixo de rotação.
Suas dimensões físicas geralmente são pequenas, devido ao seu uso em aplicações de
pequeno e médio porte, como é o caso da robótica, mas também são presentes em sistemas de
grande porte, atuando no controle do leme de navios, sendo essa a aplicação que lhes deu
origem.

15
5 HARDWARE

5.1 VISÃO GERAL

Fazendo uma analogia com as partes constituintes do corpo humano, os componentes

de hardware utilizados nesse projeto podem ser classificados em 4 (quatro) grupos:

 Processador: é o pensamento do sistema;

 FPGA: é o cérebro do sistema;
 Atuadores: são os músculos do sistema;
 Sensores: são os olhos e ouvidos do sistema;

O processador é o responsável por decidir qual será a próxima ação a ser tomada pelo
sistema com base nos dados que ele recebe por intermédio do FPGA e dos sensores, então
envia de volta ao FPGA uma mensagem dizendo qual ação será feita a seguir.
No FPGA é feita a parte principal do controle. O comando recebido é interpretado
pelo FPGA e é dividido em instruções para cada atuador que implementará aquela ação. Além
disso, essas instruções são traduzidas para o protocolo utilizado para ser feita a comunicação
com cada atuador. O uso de um FPGA é, na prática, a única saída, pois não há outra forma de
se atingir os requisitos de desempenho necessários para o funcionamento do sistema. Pode-se
cogitar pelo uso de um processador de altíssima velocidade, mas essa solução seria muito
menos acessível, além de consumir muito mais energia, características que inviabilizam o uso
desse tipo de abordagem, uma vez que o objetivo deste projeto é construir uma plataforma
barata e será alimentada por uma bateria.
A figura 2 ilustra a placa DE0 – Nano, que apresenta tecnologia FPGA, utilizada no
projeto:

16
 Figura 2 – Imagem da placa com tecnologia FPGA (DE0-Nano)

Fonte: TERASIC (2014)

Se, por exemplo, o robô estiver caído de costas no chão, um sensor como o
acelerômetro fará a medição da aceleração e enviará essa informação ao FPGA. Nesse
dispositivo há um tratamento dessa informação e ela será então, enviada ao processador. O
processador, de posse da leitura, já tratada, do acelerômetro, chegará à conclusão que o robô
está caído de costas e que a próxima ação a ser tomada é “levantar”. O processador envia essa
informação ao FPGA, que por sua vez decodifica essa mensagem e envia para os servos dos
braços e pernas do robô, a sequência de instruções a ser seguida para que o robô fique
novamente em pé. Um novo ciclo de aquisição de dados do acelerômetro permitirá confirmar
se a ação foi executada com sucesso e qual a próxima ação a ser executada.
A figura 3 ilustra a placa processadora utilizada no projeto, a BeagleBone Black:

17
 Figura 3 – Imagem da placa processadora (BeagleBone Black)

Fonte: BEAGLEBOARD (2014)

No diagrama de blocos da figura 4 apresenta-se uma visão geral de como o sistema irá
trabalhar. Primeiramente, no processador há a programação de alto nível, que é a sequência de
ações que os atuadores devem realizar. Essas ações são divididas em comandos, que são
enviados, por meio de uma comunicação serial, ao FPGA que repassa essas informações aos
atuadores, que executam essa ação. Enquanto isso, no FPGA são lidas e tratadas as
informações dos sensores para, então, serem enviadas ao processador onde o ciclo se reinicia.
Além disso, observa-se que os dispositivos que estão à direita (atuador mecânico e
sensores) trabalham em tempo real, enquanto que o processador trabalha com “tempo não-
real”.

Figura 4 – Visão Geral do Sistema

Fonte: Os Autores

18
6 SOFTWARE

Esta sessão tem como objetivo apresentar os softwares desenvolvidos para este
trabalho, sem descrevê-los, o que será feito detalhadamente em sessões posteriores.
Foram desenvolvidos três softwares para a manutenção e operação do sistema, cada
um deles visando uma parte fundamental do sistema e realizando uma tarefa diferente:

 software implementado no FPGA;

 software implementado no Processador;
 máquina virtual para desenvolvimentos futuros;

6.1 SOFTWARE DO FPGA

O software que foi implementado no FPGA, na verdade, não é, formalmente, um

software, uma vez que o FPGA é um hardware puro. Mesmo assim, para implementar esse
hardware, é necessário utilizar uma linguagem de descrição de hardware (neste trabalho foi
utilizada a linguagem verilog), que se assemelha muito à linguagens de programação
convencionais (como a linguagem C). Dessa forma, tem-se a impressão de se estar escrevendo
o código fonte de um software. Na verdade o “software” em questão apenas servirá para
queimar fisicamente a matriz lógica que compõe o FPGA, criando um hardware que funciona
sem a presença de um programa executando funções passo-a-passo.
Vale lembrar que é essa a característica mais importante do FPGA para este trabalho,
uma vez que ela faz o “processamento” ocorrer em tempo real dos dispositivos de hardware, o
que atribui ao FPGA o papel de driver de todos os dispositivos de hardware.
Os detalhamentos do funcionamento do FPGA e do seu código-fonte, em verilog,
estão na sessão 5.

6.2 SOFTWARE DO PROCESSADOR

O software implementado no processador está escrito na linguagem C++, não tendo

nenhuma particularidade em especial. Através dele será possível implementar funções
inteligentes para a tomada de decisões do sistema, devido à sua característica de “alto nível”,
ou seja, à sua proximidade à linguagem humana, desempenhando, assim, a função de cérebro
de todo o sistema.

19
 O detalhamento do funcionamento do processador e do seu código-fonte, em C++,
está apresentado na sessão 6.

6.3 MÁQUINA VIRTUAL

Foi desenvolvida e configurada uma máquina virtual para auxiliar na continuidade do

trabalho com robótica. Uma vez que é muito dispendiosa a instalação e configuração dos
softwares compiladores, às vezes possuindo incompatibilidades com o sistema operacional
instalado no computador, a solução adotada foi instalar todos os aplicativos e compiladores
necessários nessa máquina virtual para que não haja a necessidade futura de serem instalados.
Dessa forma, pode-se congelar a estrutura utilizada para o desenvolvimento deste
projeto e passá-la adiante com todas as configurações já prontas, o que, além de tudo,
estimula as futuras equipes a utilizar essas ferramentas.
A descrição da máquina virtual está apresentada na sessão 8.

20
7 FPGA

7.1 VISÃO GERAL

A placa utilizada neste projeto é a DE0-Nano da Terasic, mostrada na figura 5:

Figura 5 – Imagem da Placa DE0-Nano

Fonte: TERASIC (2014)

Essa é uma placa de desenvolvimento compacta, ideal para prototipação de circuitos

com portabilidade, ou como é o caso, aplicação a robôs de pequeno porte. O FPGA
embarcado é o Cyclone IV da Altera, um dispositivo de baixo custo e baixo consumo,
possuindo 22.320 elementos lógicos disponíveis para sintetização de hardware.

7.1.1 Especificações Técnicas

Abaixo está uma lista com os itens mais relevantes para a utilização da placa DE0-
Nano neste projeto:

 22.320 Elementos Lógicos (LEs);

 594 Kbits de Memória Embutida;
 4 PLLs para propósitos gerais;
 máximo de 153 pinos de interface (I/O) com o FPGA;
 circuito USB-Blaster on-board para programação;

21
  acelerômetro de 3 eixos de alta resolução (13 bits) – ADI ADXL345;
 oscilador de 50 MHz on-board;
 alimentação através de dois pinos de 5 V do GPIO ou por 2 pinos externos
(3,6-5,7V);
 tamanho 49 mm por 75,2 mm

As características mais importantes dessa placa, que foram decisivas em sua escolha
são:

 tamanho compacto;
 preço acessível;
 baixo consumo de energia;

A figura 6 mostra em mais detalhes as características e recursos da placa:

Figura 6 – Recursos da Placa DE0-Nano

Fonte: TERASIC (2014)

22
7.2 ARQUITETURA IMPLEMENTADA

No FPGA, foi montado um sistema que realiza todo o controle dos atuadores (neste
caso, os servomotores) e sensores (sendo o acelerômetro), além de permitir que sejam
instalados mais dispositivos no futuro (a câmera), funcionando como driver de todos os
dispositivos de hardware, podendo ser modificado conforme a necessidade.
Devido à existência de várias unidades de servomotores controlados por sinais em
PWM, é necessário o trabalho com processamento paralelo para conseguir enviar todos os
sinais de controle de forma independente, ao mesmo tempo em que se faz a leitura dos
sensores e que é feita a comunicação com o processador.
A figura 7 mostra o diagrama de blocos da arquitetura do sistema implementado no
FPGA:

Figura 7 – Arquitetura Desenvolvida no FPGA

Fonte: Os Autores

7.3 MÓDULO PWM

7.3.1 Descrição

O módulo PWM nada mais é do que um driver para os servomotores utilizados no

robô. Seus parâmetros de entrada são a posição na qual cada servomotor deve estar e quais
servomotores estarão acionados. Seu parâmetro de saída é um sinal de tensão modulado em
PWM (Pulse Width Modulation) para o controle de cada servomotor do robô, com as
seguintes características:

23
  frequência: 400 Hz
 amplitude: 5 V
 largura de pulso: Variável (controlável) entre 550 e 2450 microssegundos;

7.3.2 Bloco Esquemático

Na figura 8 está representado o bloco esquemático do PWM, sintetizado no software

Quartus II:

Figura 8 – Bloco Esquemático do Módulo PWM

Fonte: Os Autores

As entradas e saídas do módulo PWM são:

 pwm_clock: entrada de 1 bit que servirá de clock para o PWM, necessário para
marcar o “passo” dele;
 pwm_val: entrada de 12 bits que define qual o valor do de largura do PWM no
instante atual;
 pwm_enable: entrada de 1 bit que habilita ou desabilita a saída do módulo;
 pwm_out: saída de 1 bit, na qual estará presente o sinal modulado em PWM
que controla o servomotor com as descritas acima;

7.3.3 Código verilog do módulo

O código em verilog do módulo PWM está na figura 9:

24
 Figura 9 – Código Fonte do Módulo PWM

Fonte: Os Autores

7.4 CONJUNTO DE MÓDULOS PWM

Uma vez que foram utilizados 16 módulos PWM, um para cada servomotor do robô,
foi criado um módulo que encapsula todos os módulos individuais, servindo para gerencia-los
de forma mais geral.

7.4.1 Bloco Esquemático

Na figura 10 está representado o bloco esquemático do módulo que agrupa os módulos

PWM, sintetizado no software Quartus II:

25
 Figura 10 – Módulo do Grupo de PWM

Fonte: Os Autores

7.5 MÓDULO INTERPRETADOR

7.5.1 Descrição

O módulo interpretador é responsável por gerenciar todas as comunicações realizadas

entre módulos internos do FPGA e o software do processador. É este bloco que interpreta os
dados recebidos na porta UART e os encaminha para os blocos adequados dentro do FPGA,
no caso o módulo PWM que comanda cada servomotor.
O módulo interpretador também é responsável por fazer a checagem e correção de
erros de comunicação da porta UART, como bits alterados gerando sinais corrompidos. Até
certo ponto, é possível decifrar a palavra corrompida para obter a ação correta, porém esse
tipo de ação não é necessária, uma vez que o sistema em questão não é de aplicação crítica.
No caso de uma aplicação crítica, deve-se melhorar a inteligência deste bloco ou melhorar a
imunidade a ruídos do meio de comunicação.

7.5.2 Bloco Esquemático

Na figura 11 está representado o bloco esquemático do interpretador, sintetizado no

software Quartus II:

26
 Figura 11 – Bloco Esquemático do Módulo Interpretador

Fonte: Os Autores

As entradas e saídas do módulo interpretador são:

 data_rx_read: entrada de 1 bit que habilita a leitura da entrada rx_data;

 rx_data: entrada de 8 bits que corresponde à mensagem enviada ao módulo;
 pos_out: saída de 16 bits que indica a posicao para a qual um determinado
motor deve se mover;
 motor_out: saída de 4 bits que indica em qual motor se aplica a saída pos_out;
 data_ready: saída de 1 bit, que habilita a leitura das saídas do módulo;

7.5.3 Código verilog

O código em verilog do módulo interpretador está na figura 12:

27
 Figura 12 – Código Fonte do Módulo Interpretador

Fonte: Os Autores

7.6 UART

7.6.1 Descrição do protocolo

UART vem do termo em inglês "Universal Asynchronous Receiver/Transmitter",

significando "Transmissão e Recepção Assíncrona Universal" e é um dos protocolos de
comunicação mais utilizados, pois tem como vantagem o envio de dados em ambos os
sentidos ao mesmo tempo e na mesma velocidade (Full Duplex).
Por se tratar de um protocolo assíncrono, tanto o emissor quanto o receptor, devem
estar configurados da mesma maneira, de modo que seja possível estabelecer um canal de
comunicação. A figura 13 ilustra a carta de tempo do protocolo UART.

28
 Figura 13 – Carta de Tempos do protocolo UART

Fonte: Os Autores

Suas características básicas são:

 1 bit para sinalizar o início da transmissão;

 5 a 8 bits de dados;
 1 bit opcional de paridade;
 1, 1.5 ou 2 bits de parada;
 Velocidade de transmissão configurável por ajuste da frequência Baudrate;

7.6.1.1 Bit de início

É um bit enviado no início da transmissão, ele tem como característica a duração de 1

período de clock em nível lógico 0.

7.6.1.2 Bits de dados

São os bits que carregam a informação e cada bit tem a duração de 1 período de clock.

7.6.1.3 Bit de paridade

É um bit de verificação de dados e pode ser configurado para modo par ou modo
ímpar. A verificação é feita por meio da soma dos bits enviados e em seguida é atribuído o
valor do bit de paridade, podendo ser 1 caso a paridade dos dados seja a mesma que o modo
selecionado ou 0, caso não seja.

7.6.1.4 Bit de parada

É um bit em nível lógico 1, com duração de 1, 1.5 ou 2 ciclos de clock e tem como
função, a sinalização do fim do envio do pacote.

29
7.6.1.5 Baudrate

Anteriormente referido como “Ciclo de Clock”, o Baudrate é a frequência de trabalho.

Essa frequência é a base para a comunicação entre o transmissor e o receptor, que deve
ocorrer em conformidade, ou seja no mesmo compasso.
Por esse motivo, tanto o emissor quanto o receptor precisam operar com o mesmo
Baudrate, podendo assim, sincronizar os dados na primeira borda de decida (indicada pelo bit
de início).

7.6.2 Bloco Esquemático

Na figura 14 está representado o bloco esquemático da porta RX da UART, sintetizado

no software Quartus II:

Figura 14 – Bloco Esquemático do Módulo RX da UART

Fonte: Os Autores

As entradas e saídas do módulo UART RX são:

 CLOCK_UART: entrada de 1 bit que habilita a leitura da entrada rx_data;

 rx_data: entrada de 8 bits que corresponde à mensagem enviada ao módulo;
 rx_done_tick: saída de 1 bit, que habilita a leitura das saídas do módulo ;
 dout: saída de 8 bits, que envia a mensagem no formato do protocolo;
 data_ready: saída de 1 bit, que sinaliza o fim da preparação das saídas do
módulo;

30
7.6.3 Código verilog

O código em verilog do módulo RX da UART está na figura 15. Por ser muito extenso,
foi apenas reproduzido uma parte do código:

Figura 15 – Código Fonte do Módulo RX da porta UART

Fonte: Os Autores

31
7.7 ACELERÔMETRO

7.7.1 Descrição

No FPGA há um acelerômetro de 3 eixos de alta resolução (13 bits), modelo

ADXL345, que pode ser utilizado livremente pelo desenvolvedor, sendo acessado através de
uma interface SPI (três fios) ou I2C (dois fios). Algumas características do acelerômetro são:

 até 13 bits de resolução;

 medição de +/- 16g;
 interface SPI e I2C;

Na figura 16 está ilustada a conexão entre o ADXL345 e o dispositivo FPGA.

Figura 16 – Conexão do acelerômetro com o FPGA

Fonte: TERASIC (2014)

Este módulo foi utilizado neste projeto para saber se o robô está de pé, caído “de
frente” ou caído “de costas” e tomar as devidas ações para ele levantar da forma correta.
Embora não seja possível visualizar isso em tempo de execução, é possível verificar os
valores medidos pelo acelerômetro através de uma interface no computador, conforme mostra
a figura 17.

32
 Figura 17 – Valores medidos pelo acelerômetro

Fonte: TERASIC (2014)

7.8 AMOSTRADOR

7.8.1 Descrição

Este módulo tem como função filtrar o ruído dos dispositivos de medição. Uma vez
que os atrasos devem ser minimizados ao máximo, foi utilizado um algoritmo simples para
sua implementação. A entrada do módulo é o valor medido pelo sensor, a saída é a média
aritmética dos 8 (oito) últimos valores recebidos pelo amostrador.

33
7.8.2 Bloco Esquemático

Na figura 18 está representado o bloco esquemático do amostrador, sintetizado no

software Quartus II:

Figura 18 – Bloco Esquemático do Módulo Amostrador

Fonte: Os Autores

Para implementar essa lógica, o módulo foi construído com duas entradas e duas
saídas:

 Read_in: entrada de 1 (um) bit que controla a aquisição de dados. No seu

bordo de subida o valor presente no barramento NewValue_in é copiado para um
registrador interno do módulo;
 NewValue_in: barramento de entrada de 16 (dezesseis) bits, no qual é lido o
valor a ser amostrado;
 NewMean_out: saída de 1(um) bit que informa uma atualização no valor
presente no barramento Mean_out.
 Mean_out: barramento de saída de 16 (dezesseis) bits, no qual é exibida a
média dos valores amostrados;

7.8.3 Código verilog

O código em verilog do módulo amostrador está na figura 19:

34
 Figura 19 – Código Fonte do Módulo Amostrador

Fonte: Os Autores

7.9 PLL

Foi utilizada uma PLL (Phase-Locked Loops) para gerar os clocks dos diferentes
módulos a partir de um clock base da placa. Esse bloco não possui código fonte, uma vez que
é configurado diretamente em uma interface própria.

7.9.1 Bloco Esquemático

Na figura 20 está representado o bloco esquemático da PLL, sintetizada no software

Quartus II:

35
 Figura 20 – Bloco Esquemático da PLL

Fonte: Os Autores

As entradas e saídas do módulo PLL são:

 CLOCK_GERAL: entrada, é o clock nominal da placa (50 MHz);

 CLOCK_PWM: saída, clock base para gerar o PWM utilizado no controle dos
servos (1 MHz);
 CLOCK_UART: saída, clock base para comunicacao UART,(94 MHz);

36
8 PROCESSADOR

8.1 VISÃO GERAL

A placa utilizada neste projeto é a placa BeagleBone Black da BeagleBoard, mostrada

na figura 21:

Figura 21 – Imagem da Placa BeagleBone Black

Fonte: BEAGLEBOARD (2014)

A BeagleBone Black é um kit de desenvolvimento embarcado de baixo custo, baseada

em um processador ARM Cortex-A8 fabricado pela Texas Instruments.
A Beaglebone Black vem de uma linhagem de placas de desenvolvimento, tais como a
Beagleboard, a Beagleboard XM e a Beaglebone. Todas essas placas usam processadores
baseados na arquitetura ARM, porém as placas Beaglebone e Beaglebone Black foram feitas
para serem aplicadas a projetos de forma embarcada, visando o uso de suas portas e interfaces
elétricas, e não de interfaces gráficas (LCDs, Displays, etc), dessa forma são mais indicadas
para projetos nos quais há interação com o usuário enquanto o código está sendo executado.

8.1.1 Especificações Técnicas

Abaixo está uma lista com as principais especificações técnicas da placa BeagleBone
Black:

 512 MB de memória RAM DDR3

 memória flash interna de 4Gb

37
  aceleração gráfica 3D
 aceleração para ponto-flutuante NEON
 2 PRU (micro controladores de 32 bits)
 USB Client
 USH Host
 ethernet
 HDMI
 2x 46 pinos para expansão

8.2 SISTEMA OPERACIONAL

Para executar programas, é necessário usar um sistema operacional. Foi escolhido o

sistema operacional Ubuntu por ser o mesmo usado no ambiente de desenvolvimento e por ser
um sistema que apresenta boa compatibilidade com a arquitetura Arm.
A sua instalação ocorre de maneira bem simples, sendo apenas necessário copiar a
imagem do sistema operacional para um cartão micro-sd, de maneira binária, inserir o cartão
na placa e liga-la segurando o botão de flash.

8.3 EXECUÇÃO DE CÓDIGO

Uma vez que a abordagem adotada neste projeto é de utilizar um ambiente

convencional e simples para desenvolver e executar os códigos que reproduzem a inteligência
do sistema, estes devem ser criados e testados pelo usuário em um ambiente familiar e de alto
nível. Isso facilita a criação de códigos complexos, bem como a integração com bibliotecas e
outros programas feitos por outras pessoas.
Em contrapartida, códigos executados na BeagleBone Black, não são executados em
tempo real, ou seja, não é possível garantir que as instruções possuem uma temporização
consistente e confiável, porém o código é executado de maneira rápida, tal como ocorre com
softwares de simulação no computador. Enquanto isso, as operações críticas, necessariamente
realizadas em tempo real, são executadas no FPGA, onde o tempo é devidamente controlado.

38
8.4 CÓDIGO FONTE DESENVOLVIDO

8.4.1 Configuração da UART

No construtor da classe responsável pela comunicação UART, são configurados os

parâmetros básicos da porta serial:

 baudrate: 11500;
 porta: tty04;
 quantidade de bits: 8;
 stop bits: 1;
 controlde de fluxo: nenhum;
 paridade: nenhuma;

Nos demais métodos, a porta configurada é utilizada para enviar dados, sendo o
processo de envio inicializado pela abertura da porta e finalizado pelo fechamento da porta.
A figura 22 mostra o código fonte em C++ do método que configura a comunicação
UART entre a BeagleBone Black e a DE0-Nano:

Figura 22 – Configuração da Comunicação das Placas

Fonte: Os Autores

39
8.4.2 Método de Controle do Servomotor

Foi desenvolvido um método para o envio do valor da posição para a qual um

determinado motor irá se posicionar. Esse método possui dois parâmetro de entrada e nenhum
parâmetro de saída, mas envia através da porta UART, os dados ao FPGA. Nesse método é
feita a conversão do valor em graus da posição do motor para o valor em microssegundos que
que deverá ter a largura de pulso do PWM:

 pos: Entrada de valor inteiro, variando de 0 à 180, que representa a posição em

graus para a qual o motor deverá se mover;
 motor: Entrada de valor inteiro, variando de 0 à 15, que representa qual o
motor deverá ir para a posição indicada por pos;
 informação enviada à porta UART: Valor da largura de puslo referente ao
ângulo indicado em pos, utilizado na sintetização do PWM e à qual motor ele se
aplica;

A figura 23 mostra o código fonte em C++ do método descrito acima:

40
 Figura 23 – Método para o controle de um motor

Fonte: Os Autores

Um segundo método foi criado para facilitar o controle simultâneo de todos os

motores, seu parâmetro de entrada é um array de 16 posições, na qual cada valor é o valor em
graus da posição a ser enviada ao motor. Esse método é um encapsulamento do método citado
acima, utilizando-o para todo o grupo de 16 motores:
A figura 24 mostra o código fonte em C++ do método executado na BeagleBone
Black:

41
 Figura 24 – Atribuição da posição do grupo de servomotores

Fonte: Os Autores

42
9 SERVOMOTORES

9.1 VISÃO GERAL

Os servomotores do ROBONOVA (IBBOTSON, 2007) são os componentes de

controle final deste projeto, uma vez que cada um deles comanda uma articulação do kit
ROBONOVA-1, sendo parte integrante do kit.
A figura 25 mostra uma foto do modelo de servomotor utilizado no robô:

Figura 25 – Imagem do Servomotor Instalado no Robô

Fonte: HITEC ROBOTICS (2007)

A interface de comunicação com o servomotor é feita por uma conexão de 3 fios,

sendo que dois deles funcionam para energia e referência (Vcc e GND) e o terceiro fio
funcionando como sinal. A tensão utilizada para alimentar o motor é de 5 V no pino Vcc e 0V
no pino GND.
Na figura 26 está um diagrama da interface elétrica do servomotor:

Figura 26 – Interface elétrica do servomotor

Fonte: Os Autores

43
 Como ilustrado na Figura 30, o RoboNova-I possui em sua estrutura 16 servomotores
digitais, modelo HSR-8498 projetados exclusivamente para operações robóticas. De acordo
com HITEC ROBOTICS (2007) os servomotores possuem as seguintes características:

 interface: protocolo HMI5(modo PWM6, modo pulso extendido e modo serial);

 tensão de operação: 4.8 V a 6.0 Vdc;
 velocidade: 0.20 s/60° a 6.0 V;
 torque: 10 kg/cm a 6.0 V;
 ângulo de operação: 180º;
 peso: 55 g;
 dimensões: 40 x 20 x 47 mm.

9.2 CONTROLE DO SERVOMOTOR

9.2.1 Controle de Posição

O controle de posição do servomotor é feito através de um sinal binário em forma de

pulso, na qual a largura do mesmo define a posição angular do servomotor segundo a
equação:

𝐿𝑎𝑟𝑔𝑢𝑟𝑎 𝑑𝑜 𝑃𝑢𝑙𝑠𝑜 [𝜇𝑠]

𝑃𝑜𝑠𝑖çã𝑜 [°] = − 150
10

Isso pode ser visualizado graficamente, conforme mostrado na figura 27:

Figura 27 – Relação entre o ângulo e a largura de pulso do sinal de controle

Fonte: HIGTEC ROBOTICS(2007)

44
 Como o servomotor fica constantemente mudando de posição, serão necessários
sucessivos pulsos enviados a intervalos regulares, o que define um PWM cujo ciclo de
trabalho (duty-cicle) define a posição do servomotor. Embora não seja utilizada para o
controle do servomotor, a posição pode ser dada em função do ciclo de trabalho do PWM pela
expressão:

𝑃𝑜𝑠𝑖çã𝑜 [°] = 25000 ∗ 𝐶𝑖𝑐𝑙𝑜 𝑑𝑒 𝑡𝑟𝑎𝑏𝑎𝑙ℎ𝑜 [%] − 150

Na figura 28, é possível conferir a forma de onda dos possíveis valores do sinal de
controle:

Figura 28 – Possíveis valores para a geração do PWM

Fonte: Os Autores

9.2.2 Leitura de Posição

O servomotor também permite a leitura de sua posição, informação essa que é muito
útil caso haja a necessidade de se fechar a malha de controle. Essa leitura é feita utilizando-se
o seguinte procedimento:

 o controlador envia um sinal em forma de pulso em nível lógico alto com 50

microssegundos de duração (Ponto A);

45
  ao terminar o pulso, o controlador muda o sinal para nível lógico baixo e o
mantém assim por um intervalo de tempo que pode variar de 2 a 20
microssegundos (Ponto B). Na sequência, o controlador deve mudar o sinal para
alta impedância (tri-state), uma vez que será lido o valor da posição;
 depois de reconhecido o vale do controlador (Ponto B), o servomotor envia um
sinal de nível lógico baixo por 125 microssegundos (Ponto C), mostrando que
reconheceu o pedido de leitura;
 após esse tempo, o servomotor enviará um pulso em nível lógico alto, cuja
largura é função da posição, variando 550 à 2450 microssegundos (Ponto D), os
mesmos tempos utilizados para o controle da posição;
 na sequência, o servomotor envia nível lógico baixo por 250 microssegundos
(Ponto E) e o controlador também muda para nível lógico baixo (Ponto F);

Todo o processo está ilustrado na figura 29:

Figura 29 – Leitura de Posição do Servomotor

Fonte: HITEC ROBOTICS(2007)

Uma vez que a largura do pulso possui o mesmo formato, seja na leitura ou no
controle, é possível usar a mesma equação para obter a posição do motor:

𝐿𝑎𝑟𝑔𝑢𝑟𝑎 𝑑𝑜 𝑃𝑢𝑙𝑠𝑜 [𝜇𝑠]

𝑃𝑜𝑠𝑖çã𝑜 [°] = − 150
10

46
10 MÁQUINA VIRTUAL

10.1 VISÃO GERAL

Para se desenvolver um software compatível com a plataforma BeagleBone Black,

existem duas abordagens:

 usar a própria placa como ambiente de desenvolvimento, compilando todos os

códigos de forma nativa;
 uso de um ambiente devidamente configurado em um computador
convencional, no qual se realiza a compilação cruzada (compilar programas em
uma arquitetura para se utilizar em outra).

Optou-se pela segunda opção, uma vez que a compilação é mais rápida e existem
diversas ferramentas que podem ser utilizadas, além do uso de ambientes de desenvolvimento
com interface gráfica.
Esse ambiente de desenvolvimento deverá rodar em uma versão de Linux. Então, para
criar um ambiente mais familiar para o usuário, optou-se pelo uso de uma máquina virtual ao
invés da instalação direta, tendo em vista que a grande maioria dos usuários tem prática
apenas com sistema operacional Windows.
Dessa forma, não é necessário o usuário ter dois sistemas operacionais distintos no
mesmo computador e também não existe a necessidade de reiniciar o computador para trocar
de sistema operacional, o que pode agilizar qualquer processo que o usuário venha a
necessitar.

10.2 SISTEMA OPERACIONAL

Foi escolhido o sistema operacional Ubuntu 14.04 LTS, por ser um sistema
operacional de código aberto, de simples utilização, com uma grande quantidade de usuários e
uma comunidade ativa. Assim, sempre que um usuário encontrar um problema, poderá buscar
respostas nas diversas comunidades e fóruns dedicados ao sistema operacional Ubuntu.
Neste sistema operacional, serão instaladas bibliotecas para compilar programas para a
arquitetura ARM (a arquitetura utilizada na construção da BeagleBone Black) e uma

47
ferramenta de programação com interface gráfica, para não existir a necessidade do uso
constante do terminal.

10.3 COMPILAÇÃO CRUZADA

Como compilador, será usado o toolchain Linaro que apresenta uma boa aceitação na
comunidade de desenvolvedores e é de código aberto. Este toolchain é importante, uma vez
que ele será utilizado para compilar todos os programas a serem executados futuramente na
plataforma “Beaglebone Black”.

10.4 QT E QT CREATOR

O Workframe Qt foi selecionado para desenvolver programas em C++, uma vez que é
muito utilizado na indústria e possui código aberto. Portanto, trata-se de uma boa plataforma
de desenvolvimento, com poucos bugs e sempre bem documentada.
Como interface gráfica de desenvolvimento, optou-se pelo Qt Creator, uma interface
gráfica feita para ser utilizada com o workframe selecionado, apresentando integração direta
com as bibliotecas.
Outra funcionalidade importante do Qt Creator é a possiblidade de compilar o
programa e envia-lo diretamente para um dispositivo móvel, no caso, a placa Beaglebone
Black e assim, possibilitando que o desenvolvimento seja mais dinâmico, uma vez que o
software será testado diretamente no ambiente embarcado e não no computador.

10.5 CONFIGURAÇÃO

Para que todo o ambiente de desenvolvimento funcione de maneira adequada, é

necessário configura-lo corretamente.
Deve-se definir uma pasta onde será instalado o toolchain Linaro, a localização da
pasta não é importante, só é necessário conhecer o caminho até ela. Para instalar o Workframe
Qt e Qt Creator basta executar o instalador.
Com os programas instalados, deve-se compilar as bibliotecas do Workframe Qt para a
arquitetura Arm, mais informações estão no Anexo 1 – Instalação Completa do ambiente da
Máquina Virtual.

48
11 CONTROLE DE MOVIMENTAÇÃO DE ROBÔ HUMANOIDE

Para avaliar a eficiência do sistema de controle desenvolvido definiu-se como

aplicação o controle de movimentação de um robô humanoide, o RoboNova-I da Hitec
Robotics que é um robô autônomo confeccionado em escala comercial que possui 16
servomotores para movimentação e atende às necessidades do projeto.
O exoesqueleto do RoboNova-I é feito de metal anodizado que é ao mesmo tempo
leve e resistente, sendo a estrutura ideal para abrigar os servomotores disponíveis. Os 16
servomotores do RoboNova-I estão distribuídos de forma a haver 3 articulações para cada
braço e 5 motores para a movimentação de cada perna. Na figura 30 vê-se a distribuição dos
servomotores na estrutura, onde os motores numerados de 1 a 3 e de 14 a 16, comandam
respectivamente a movimentação dos braços esquerdo e direito, enquanto os motores de 4 a 8
e de 9 a 13 comandam respectivamente a movimentação das pernas esquerda e direita do
robô.

Figura 30 – Disposição dos Motores no ROBONOVA-1.

Fonte: HITEC ROBOTICS (2007)

11.1 TESTE DE APLICAÇÃO

A atividade escolhida para o robô realizar a fim de testar a eficiência da plataforma é

“andar para frente”. Apesar de ser uma atividade relativamente simples para os seres

49
humanos, é muito complexa do ponto de vista robótico, uma vez que exige o posicionamento
preciso e sincronizado da todos os servomotores, assim como as articulações nos seres
humanos. Para realizar essa atividade, foi utilizado como referência um arquivo utilizado na
iniciação científica do Instituto Mauá de Tecnologia contendo um código fonte que indicava a
posição de cada servomotor para a realização do movimento de andar, mas não havia
informação de sua procedência. Esse código fonte foi utilizado apenas por ser a única
referência encontrada. Foram consultados, também, os manuais do robô a fim de interpretar o
código fonte utilizado como referência.
A figura 31 mostra o código fonte em C++ do laço que controlará o robô, realizando a
ação de andar para frente.

Figura 31 – Código fonte da ação "Andar para frente"

Fonte: Os Autores

50
 Os resultados obtidos desse teste não foram dos mais animadores: o robô se movia de
forma descoordenada e não era capaz nem de ficar em pé, quanto mais de andar. O principal
motivo para a falha neste teste é o desconhecimento dos valores corretos da posição de cada
motor em cada instante para que o robô ande. Por outro lado, foi possível o controle
simultâneo de todos os servomotores.
Para que o robô se movimente da maneira desejada, é necessário apenas o estudo e
conhecimento desses parâmetros, o que seria um ótimo ponto de partida para uma futura
iniciação científica, na qual o objetivo seria criar procedimentos para todas as movimentações
básicas para o robô, tais como “andar”, “levantar”, “chutar”, “correr”. É necessário muito
tempo para implementar, testar e validar ações como essas e esse ponto já está além do escopo
deste trabalho. O mais importante já foi comprovado: foi bem sucedida a criação de uma
interface de alto nível para controle robótico.

51
12 RESULTADOS E CONCLUSÕES

Foi possível concluir todos os objetivos do projeto: a plataforma de controle foi

construída permitindo muitos tipos de alterações em sua estrutura caso sejam necessárias e
sua interface é simples e intuitiva de se utilizar.
Embora não tenham sido implementadas funções complexas para aplicação no kit
ROBONOVA-1, foi comprovada a aplicação da plataforma, uma vez que o hardware
responde aos comandos programados, só não foi possível a realização de uma tarefa devido ao
desconhecimento dos valores dos parâmetros necessários. Além disso, o caminho está aberto
para que futuros desenvolvimentos utilizem essa plataforma por parte dos alunos que
participarem dos projetos de Iniciação Científica. Ainda há muita liberdade para que novos
periféricos sejam adicionados ao kit e muita liberdade para o uso da criatividade de quem for
utilizar essa plataforma para desenvolver algorítmos.
Com relação à aplicabilidade, a plataforma desenvolvida pode ser utilizada em
qualquer tipo de controle. Por outro lado, utiliza-se grande parte do tempo na programação do
FPGA até que ele comande corretamente o hardware a ser controlado. A boa notícia é que
atividade similar aconteceria com o uso de outras plataformas, como o PIC ou o Arduino. Isso
depende mais da habilidade do desenvolvedor em utilizar a ferramenta oferecida.
A máquina virtual desenvolvida serve principalmente para aliviar o trabalho de
configuração e utilização dos softwares, o que funciona como estímulo extra para se adotar
essa solução.
Vale lembrar que, caso a preocupação com o baixo custo não exista, ou caso seja
irrelevante, é mais vantajoso utilizar um SoC (uma placa na qual estão presentes os
componentes do processador e do FPGA), pois a única desvantagem dele em relação à
plataforma criada neste projeto é o custo. Por outro lado, uma das vantagens mais importantes
da plataforma criada é a possibilidade de se trocar uma das placas sem a necessidade de trocar
a outra. Ou seja, é possível substituir a BeagleBone Black por um Arduino com o mesmo
código, ou até mesmo por mais de uma placa para fazer o processamento de alto nível. Essa
possibilidade permite a aplicação da técnica top-down ao se dividir as tarefas que cada placa
irá processar, permitindo a implementação de algoritmos ainda mais complexos.

52
13 BIBLIOGRAFIA

CHU, Pong P. FPGA Prototyping By Verilog Examples. 1 ed. New Jersy: Wiley, 2008

Day, Robrty P J. Beaglebone Black System Reference Manual. 2014. Disponível em: <
https://github.com/CircuitCo/BeagleBone-Black/blob/master/BBB_SRM.pdf?raw=true>
Acesso em 7 de abril de 2014.

DIGIA. Qt Documentation. 2014. Disponível em: < http://doc.qt.io/> Acesso em 10 de maio

de 2014.

HITEC ROBOTICS RoboNova-I English Manual. (Versão 1.00 2051118) 2007.

IBBOTSON, R. Hitec HSR-8498HB: Digital Servo Operation and Interface. 2007. Disponível
em: <http://robosavvy.com/Builders/i-Bot/HSR8498HB%20Servo.pdf> Acesso em 10 de
dezembro de 2014.

LINARO. The Linaro Developer Wiki. 2014. Disponível em: <

https://wiki.linaro.org/FrontPage> Acesso em 10 de maio de 2014

RIZZUTI, Henrique; VILLANUEVA, Rafael Ferrari, CARMELLO, Thiago Satio Yoshida de

Camargo. Desenvolvimento de Sistema Embarcado Baseado em Processamento de Imagens
para Robô Humanoide, Trabalho de Conclusão de Curso, Centro Universitário do Instituto
Mauá de Tecnologia, São Caetano do Sul, SP, 2010.

TERASIC. DE0-Nano User Manual. 2012. Disponível em: <http://www.terasic.com.tw/cgi-

bin/page/archive_download.pl?Language=English&No=593&FID=75023fa36c9bf8639384f9
42e65a46f3> Acesso em 7 de abril de 2014.

ZANZARINI, D.; COELHO, A. D.; ASSIS, W. O. “Desenvolvimento de Visão Embarcada

para Robô Humanóide”, XVII Simpósio de Iniciação Científica da USP, São Paulo:
Universidade de São Paulo, 2009.

53
14 APÊNDICE I – INSTALAÇÃO COMPLETA DO AMBIENTE DE
MÁQUINA VIRTUAL

Para instalar corretamente todos componentes, é necessário o uso dos arquivos

fornecidos, uma vez que existem diferentes versões dos arquivos e pode existir alguma
incompatibilidade.
Para facilitar o processo, foi criado um script para a instalação. Para executa-lo, basta
abrir uma janela de terminal, navegar até a pasta onde se encontram os arquivos fornecidos
(drive de cd ou pendrive) e executar o seguinte comando: “./install.sh”
Este script copiará os arquivos para as devidas pastas, instalará todas as dependências,
realizará a extração de arquivos compactados e compilará as bibliotecas para a arquitetura
ARM.
Caso seja necessária a instalação manual, os procedimentos descritos abaixo realizam
o mesmo processo que o script:

1. Criar uma pasta chamada linaro no diretório do usuário com o comando ”mkdir
~/linaro”
2. Criar uma pasta chamada qt no diretório do usuário com o comando “mkdir ~/qt”
3. Copiar os arquivos fornecidos para o diretório do usuário, supondo o uso da unidade
de cd: “cp –r /media/cdrom/* ~”
4. Mover o arquivo “gcc-linaro-arm-linux-gnueabihf-4.8-2014.04_linux.tar.xz” para a
pasta linaro, com o comando: “mv gcc-linaro-arm-linux-gnueabihf-4.8-
2014.04_linux.tar.xz ~/linaro/”
5. Mover o arquivo “qt-everywhere-opensource-src-5.3.0.tar.gz” para a pasta qt com o
comando: “mv qt-everywhere-opensource-src-5.3.0.tar.gz ~/qt/”
6. Entrar na pasta linaro com o comando: “cd ~/linaro”
7. Extrair os aquivos usando o comando: “tar -Jxvf gcc-linaro-arm-linux-gnueabihf-4.8-
2014.04_linux.tar.xz”
8. Renomear a pasta criada com os arquivos extraídos para “linaro”, com o comando:
”mv gcc-linaro-arm-linux-gnueabihf-4.8-2014.04_linux linaro”
9. Mover a pasta “linaro” para a pasta “/usr/bin/” usando o comando: “mv linaro
/usr/local”
10. Abrir a pasta “qt” com o comando: “cd ~/qt”
11. Extrair os arquivos com o comando: “tar -xvzf qt-everywhere-opensource-src-
5.3.0.tar.gz”
12. Criar uma pasta para configurar o método para compilar as bibliotecas do Qt com o
comando: “mkdir ~/qt/qt-5.3-host”
13. Executar os seguintes comandos para baixar todas as dependências necessárias:

54
 a. apt-get update
b. apt-get install lsb
c. cd /etc/apt/sources.list.d
d. echo "deb http://old-releases.ubuntu.com/ubuntu/ raring main restricted
univers$
e. apt-get update
f. apt-get install ia32-libs
g. rm -f ia32-libs-raring.list
14. Copiar as configurações já para compilar as bibliotecas do Qt para beaglebone black
com os seguintes comandos:
a. cp -r ~/linux-beaglebone-g++ ~/qt/qt-everywhere-opensource-src-
5.4.0/qtbase/mkspecs/devices/linux-beaglebone-g++
b. cp -r ~/linux-linaro-gnueabihf-g++ ~/qt/qt-everywhere-opensource-src-
5.4.0/qtbase/mkspecs/linux-linaro-gnueabihf-g++
15. Executar os seguintes comandos para compilar e instalar as bibliotecas do Qt para a
arquitetura Arm:
a. cd ~/qt/qt-5.3-host
b. ../qt-everywhere-opensource-src-5.3.0/configure -v -opensource -confirm-
license -prefix /usr/local/qt-5.3 -no-largefile -no-accessibility -qt-zlib -no-gif -
qt-libpng -qt-libjpeg -no-nis -no-cups -device linux-beaglebone-g++ -device-
option CROSS_COMPILE=/usr/local/linaro/bin/arm-linux-gnueabihf- -opengl
es2
c. make -j4
d. apt-get remove libqt5core5
e. make install
16. Instalar o Qt Creator e as bibliotecas Qt executando o instalador correspondente ao
sistema operacional:
a. qt-opensource-linux-x64-5.3.0.run para sistemas 64 bits
b. qt-opensource-linux-x86-5.3.0.run para sistemas 32 bits

14.1 CONFIGURAÇÃO DO QT CREATOR

A interface Gráfica “Qt Creator” precisa de algumas configurações para poder fazer a
compilação cruzada, essas configurações estão descritas abaixo:

1. Criar um novo dispositivo:

a. Com o programa aberto, clicar na aba “Tools” e em seguida “Options”
b. Clicar no botão “Devices”
c. Clicar no botão “ADD”
d. Selecionar “Generic Linux Device”
e. Clicar no botão “Start Wizard”
f. Digitar um nome para o dispositivo

55
 g. Entrar com os dados de IP, login e senha
h. Clicar em “Next” e “Finish”
i. Verificar se a conexão foi bem sucedida
A figura 32 ilustra a configuração de um dispositivo:

Figura 32 – Configuração do Qt Creator

Fonte: Os Autores

2. Adicionar um novo Compilador:

a. Clicar em “Build & Run”
b. Selecionar a aba ”Compilers”
c. Clicar em “ADD”
d. Modificar o nome do compilador para “Linaro GCC”
e. Clicar em “Browse” e navegar até a pasta “/usr/local/linaro/bin”
f. Clique em “Open” e selecione o arquivo “arm-linux-gnueabihf-g++”
g. Clique em “Open” novamente e em seguia clique em “Apply”
A figura 33 mostra um compilador devidamente configurado

56
 Figura 33 – Exemplo de compilador configurado corretamente

Fonte: Os Autores

3. Adicionar uma nova versão do Qt

a. Clicar em “Qt Versions”
b. Clicar em “Add”
c. Navegar até a pasta “/usr/local/qt-5.3/bin/qmake”
d. Clicar em “Open” e depois em “Apply”
A figura 34 mostra o processo descrito:

Figura 34 – Adicionando uma nova versão do Qt

Fonte: Os Autores

4. Adicionar um novo Debugger

a. Clicar em “Debugger”
b. Clicar em “Add”
c. Modificar o nome para “Linaro GDB”
d. Clicar em “Browse”

57
 e. Selecionar “arm-linux-gnueabihf-gdb”
f. Clicar em “Open” e depois em “Apply”
A figura 35 mostra um Debugger devidamente configurado

Figura 35 – Configuração bem sucedida de um Debbuger

Fonte: Os Autores

5. Adicionar um novo Kit

a. Clicar em “Kits”
b. Clicar em “Add”
c. Modificar o nome para “BBB Kit”
d. Verificar se o tipo de dispositivo está configurado com “Generic Linux
Device”
e. Verificar se o “Device” selecionado é o que foi criado anteriormente
f. Selecionar “Linago GCC” como compilador
g. Selecionar “Linaro GDB” como debugger
h. Selecionar a versão criada anteriormente como versão do Qt e clicar em OK
A figura 36 representa a configuração final:

58
 Figura 36 – Configuração final do Qt

Fonte: Os Autores

59