Apostila Programacao Robotica Lego EV3 NB

INSTITUTO FEDERAL
Mato Grosso do Sul

Centro de Referência
em Educação a Distância Cread
PROGRAMANDO UM
ROBÔ SEGUIDOR DE
LINHA UTILIZANDO
LEGO MINDSTORMS EV3
João Couto
Leandro de Jesus
Marcia Ferreira Cristaldo
Instituto Federal de Mato Grosso do Sul - Campus Aquidauana
Autores
Estudante Egresso do Curso Técnico Integrado em Informática João Couto
joao.couto@estudante.ifms.edu.br
Professora Dra. Marcia Ferreira Cristaldo

marcia.cristaldo@ifms.edu.br
Professor Dr. Leandro de Jesus

leandro.jesus@ifms.edu.br
Programando um robô seguidor de linha utilizando LEGO Mindstorms EV3
Indicação de Ícones
Objetivos de Glossário
Aprendizagem
Subseções de Atenção!
Estudo
Fique de Olho Dica
Guarde Bem Isto Você Sabia?
Link Saiba Mais
Download Revisando...
Vídeo/Áudio Para Refletir...
Leitura Exercícios
Complementar de Fixação
3
Centro de Referência em Tecnologias Educacionais e Educação a Distância - Cread
4
Instituto Federal de Educação, Ciência e Tecnologia de Mato Grosso do Sul - IFMS
Sumário
Seção 1 - Introdução.................................................................................. 7
1.1 Instalação do Software............................................................................................ 7
Seção 2 - Primeiros Passos........................................................................ 11

2.1 Interface do Software............................................................................................... 11
2.2 Blocos: Ação............................................................................................................. 12
2.3 Blocos: Controle de Fluxo....................................................................................... 15
2.4 Blocos: Sensor.......................................................................................................... 17
2.5 Blocos: Operação de Dados................................................................................... 18
Seção 3 - Seguindo Linha........................................................................... 19

3.1 Definindo Uma Estratégia...................................................................................... 19
3.2 Implementando a Estratégia.................................................................................. 20
3.3 Tratando Erros......................................................................................................... 28
Seção 4 - Detectando Obstáculos............................................................. 31
Seção 5 - Intersecções Marcadas em Verde............................................ 33

5.1 Para a Esquerda....................................................................................................... 33
5.2 Para a Direita............................................................................................................ 36
5.3 Meia Volta................................................................................................................. 37
Referências................................................................................................. 39
5
Download
O programa completo do Seguidor de Linha que será estudado
no curso:
https://www.mediafire.com/file/b3ar92ihq213wns/Projeto.ev3/file
6
Seção 1 - Introdução
A programação de robôs seguidores de linha utilizando o kit edu-

cacional LEGO Mindstorms EV3 com foco na Olimpíada Brasileira
de Robótica (OBR) pode ser feita de diversas maneiras. Nesta apostila,
abordaremos a utilização do software baseado em blocos que acompa-
nha o kit da Lego para desenvolver um algoritmo que seja capaz de fa-
zer um robô seguir linha, desviar de obstáculos e detectar as marcações
em verde presentes na etapa prática da OBR.
1.1 Instalação do Software

Acesse a página oficial de download do LEGO Mindstorms EV3,
disponível em https://education.lego.com/en-us/downloads/retiredpro-
ducts/mindstorms-ev3-lab/software, e clique em “Download”. Após o
download do arquivo, execute-o e siga as instruções do instalador.
Figura 1. Página de download EV3 Lab Software.
7
Figura 2. Instalação Mindstorms EV3.
No passo 5, você deve escolher entre a versão para estudantes ou

para professores do software. Você conseguirá reproduzir todos os
exemplos dessa apostila em ambas versões.
8
Figura 3. Instalação Mindstorms EV3.
9
Figura 4. Finalização da instalação.
10
Seção 2 - Primeiros Passos
Nesta seção, percorreremos as principais funcionalidades do sof-

tware, aprendendo tudo que é necessário para montar um seguidor de
linha. Vamos lá!
2.1 Interface do Software

A imagem a seguir mostra a página inicial do programa, onde estão
localizados atalhos para as funcionalidades do software. Vamos criar
um primeiro projeto, para isso, clique no botão “+” ou em “New pro-
ject” (veja na imagem).
Figura 5. Página inicial Mindstorms EV3.
Com um novo projeto criado, já podemos começar a criar nossos

primeiros programas. Tenha em mente que um projeto abriga vários
programas, os quais podem ser “chamados” dentro de outros progra-
mas desse mesmo projeto.
11
Figura 6. Projeto em branco.
Descrição das seções do programa:

1. Aba de programas. Escolha um para trabalhar;
2. Área de trabalho. Posicione os blocos logo após o botão de play
para criar a sua lógica.
3. Blocos. Eles ditam as ações do robô;
4. Conexão e portas. Aqui você consegue fazer a conexão com o
brick e ver o status dos sensores e motores;
5. Execução. Utilize o primeiro botão para carregar o seu programa
para o brick, o segundo para carregar e executar.
2.2 Blocos: Ação
Figura 7. Seção inferior - Ação.
12
Esses blocos são responsáveis por controlar atuadores como moto-

res médios e grandes, bem como as luzes, o display e os sons emitidos
pelo brick.
Da esquerda para a direita, temos:

• Motor médio;
• Motor grande;
• Mover direção;
• Mover tanque;
• Display;
• Som;
• Luz do brick;
Figura 8. Bloco de motor médio.
Se arrastarmos um desses blocos para a frente do botão de play na

área de trabalho, poderemos ver suas opções. No caso, o bloco de mo-
tor médio foi escolhido.
Veja na Figura 8: Em 1, temos a possibilidade de selecionar a forma

que queremos trabalhar com esse motor, seja em rotações, segundos,
angulação etc. Em 2, escolhemos a quantidade de energia que que-
remos fornecer para esse motor, podendo variar de 1 até 100. Em 3,
definimos a quantidade de rotações ou o tempo em segundos para o
motor realizar a ação (este campo se modifica de acordo com a seleção
em 1). Em 4, escolhemos se o motor irá travar o movimento ou não
ao finalizar a execução do bloco. Por fim, em 5, escolhemos em qual
porta está conectado o motor.
13
Figura 9. Opções de funcionamento do bloco de motor médio.
Na Figura 9, temos as opções possíveis para a execução do bloco.

Você pode escolher entre fazer com que o motor desligue (1), ligue por
tempo indeterminado (2), ligue durante alguns segundos (3), ligue até
que atinja determinada angulação (4), ou ligue por rotações (5).
Antes de prosseguirmos, vamos dar uma olhada mais a fundo nos

blocos: mover direção e mover tanque.
Figura 10. Blocos de controle de direção e tanque.
Eles trabalham em conjunto de dois motores, partindo da ideia de

que você quer controlar ambos simultaneamente. Na esquerda, está o
bloco mover direção e o mover tanque está na direita.
14
Em 1, escolhemos quais motores queremos controlar (atente-se

para o posicionamento real deles, coloque o motor da esquerda como
a primeira letra e o motor da direita como a segunda). Em 2, defi-
nimos qual a direção que queremos que o robô se mova. Em 3 e 4,
respectivamente, escolhemos a energia dos motores esquerdo e direito.
2.3 Blocos: Controle de Fluxo

Eles são os responsáveis por ditar a forma com que o nosso progra-
ma é executado.
Figura 11. Seção inferior - Controle de Fluxo.
Na Figura 11, da esquerda para a direita:

• Play: Marca o início de todos os programas que desenvolvemos;
• Esperar: Pausa a execução do código durante algum tempo;
• Ciclo: Repete tudo que está no seu interior sob alguma condição;
• Comutação: Faz uma verificação e então executa algo com base nela;
• Interromper ciclo: Interrompe um ciclo;
Figura 12. Bloco de Ciclo.
15
Vamos arrastar o bloco de ciclo para o nosso programa. Nele, deve-

mos definir a condição para sua execução (1). No exemplo da Figura
12, o ciclo estará ativo infinitamente, mas poderíamos definir sua exe-
cução para um intervalo de tempo, por exemplo.
Figura 13. Bloco de Comutação.
Na Figura 13, temos o bloco de comutação. Definimos, em 1, o

que queremos verificar, seja o estado de um sensor, motor etc. Em 2,
definimos o valor para verificação. Caso ele seja igual ao estado do
sensor, por exemplo, os blocos contidos em 5 serão executados, caso
o estado seja diferente do valor definido, os blocos contidos em 6
serão executados. Ainda devemos definir a porta na qual este sensor/
motor está conectado, por meio do campo indicado em 4. Podemos,
ainda, alterar a visualização desse bloco clicando no botão 7 (veja a
Figura 14).
16
Figura 14. Bloco de Comutação Condensado.
Nesse caso, o escopo para as condições de verdadeiro e falso podem

ser acessados pelos botões indicados em 1 e 2, respectivamente.
2.4 Blocos: Sensor

Nesta seção, encontramos os blocos responsáveis pela leitura e controle
dos sensores, veja Figura 15. Na versão do Mindstorms para professores,
existem alguns blocos de sensores a mais, no entanto, utilizaremos apenas
os disponíveis na versão de estudantes para os exemplos desta apostila.
Figura 15. Seção inferior - Sensores.
Da esquerda para a direita:

• Botões do brick.
• Sensor de cor.
• Giroscópio.
• Infravermelho.
• Rotação do motor.
• Temperatura.
• Timer.
• Sensor de toque.
• Ultrassônico.
• Medidor de energia.
• Sensor de som NXT.
17
2.5 Blocos: Operação de Dados

Os blocos desta seção permitem a criação e manipulação de dados
dentro de um projeto, veja a Figura 16.
Figura 16. Seção inferior - Operação de dados.
Da esquerda para a direita:

• Variável: Armazena um valor, seja um número texto etc.;
• Constante: Armazena um valor da mesma forma que a variável,
porém, este só pode ser lido e não alterado;
• Operações com Arrays: Um array é um conjunto de variáveis, o
qual pode ser definido através do bloco de variável;
• Operações lógicas: Permite o uso de operadores booleanos AND,
OR, NOT;
• Operações matemáticas: Permite a execução de operações aritmé-
ticas das variáveis;
• Arredondar: Arredonda um valor;
• Comparar: Se um valor é maior, menor ou igual a outro;
• Intervalo: Verifica se um valor está dentro ou fora de um intervalo;
• Texto: Realiza operações de texto (união);
• Aleatório: Sorteia um valor.
Ainda existem mais duas seções na aba inferior do software: Avan-

çado e Meus Blocos. Não iremos utilizar os blocos da seção avançada,
no entanto, a seção Meus Blocos abrigará os blocos personalizados que
iremos construir.
18
Seção 3 - Seguindo Linha
Chegou a hora de construirmos o nosso primeiro algoritmo de

seguimento de linha, e, para isso, utilizaremos (além do Brick): dois
sensores de cor RGB e dois motores grandes.
3.1 Definindo Uma Estratégia

Antes de qualquer coisa, vamos definir uma disposição base para o
nosso robô. Ela será a seguinte:
Figura 17. Sensores e motores do robô.
Note que A, B, 1 e 2 são as portas em que os componentes devem

ser ligados no Brick, veja Figura 17 acima. Com isso em mente, já
podemos começar a elencar as dificuldades que o robô encontrará na
pista. Para isso, no Quadro 1, seguem as regras da Olimpíada Brasilei-
ra de Robótica (OBR).
19
Quadro 1. Regras da OBR.
Caso Leitura Ação

Sensor 1: Branco
1 Seguir em frente
Sensor 2: Branco
Sensor 1: Preto
2 Seguir em frente
Sensor 2: Preto
Sensor 1: Branco
3 Virar para direita
Sensor 2: Preto
Sensor 1: Preto
4 Virar para esquerda
Sensor 2: Branco
Quando os sensores detectarem branco, o robô deve estar com a

linha centralizada entre eles ou deve estar passando por uma falha na
linha, logo deve andar para frente (caso 1). Quando os sensores detec-
tarem preto, ele também deve seguir em frente, pois estará passando
por uma intersecção de linhas. Já quando apenas o sensor da direita
detectar a cor preta, o robô deverá rotacionar para direita, tendo em
vista que essa detecção indica que a linha preta está debaixo do sensor
da direita. O mesmo ocorre para o sensor da esquerda.
3.2 Implementando a Estratégia

Agora, implementaremos o que elaboramos no passo anterior. Para
isso, arraste uma comutação para frente do bloco de Play, veja Figura 18.
Figura 18. Comutação.
20
Em seguida, altere a condição para Sensor de Cor > Medir > Cor
(Figura 19).
Figura 19. Configuração da Comutação.
Altere a porta de leitura para 1 (Figura 20), pois verificaremos pri-

meiro o sensor de cor da esquerda. Faça a alteração, também, das cores
de leitura para preto e branco. Dessa forma, determinado bloco de
código deverá ser executado apenas na detecção de preto ou branco.
Figura 20. Comutação em Cores.
21
Agora, precisamos verificar a leitura do sensor da direita. Para isso,

duplique duas vezes o bloco de comutação que configuramos ante-
riormente e altere as portas para 2, veja a Figura 21. Depois, coloque
-os dentro do escopo da comutação principal, cada um em uma seção.
Figura 21. Aninhamento de Comutações.
Devemos entender o que está acontecendo neste ponto do proje-

to. Primeiro, uma comutação verifica a cor que está sendo lida pelo
sensor da esquerda. Depois, ocorre a verificação do sensor da direita.
Com isso, já conseguimos detectar os casos de nossa estratégia (veja na
Figura 21), só faltando implementar as ações do robô.
22
Figura 22. Bloco mover direção.
Para uma melhor visualização, clique no botão de abas da comuta-

ção principal. Veja a Figura 22.
Depois, para fazer o robô seguir em frente, arraste um bloco “Mo-

ver direção” para dentro do caso onde a leitura dos sensores é: preto
no sensor da esquerda e preto no sensor da direita.
Não se esqueça de trocar as portas para A e B, definir a potência

para 30 e alternar o modo do bloco para “manter ligado” (Figura 22).
Vamos escolher o modo “manter ligado” para todos os blocos de ação
que adicionarmos nas comutações, pois não sabemos por quanto tem-
po o robô executa cada caso.
Veja a Figura 23 e adicione, também, um bloco “mover direção”

para o caso de leitura: branco no sensor da esquerda, branco no sen-
sor da direita. Assim, já conseguimos cobrir os casos em que o robô
seguirá em frente.
23
Figura 23. Bloco mover direção.
Na Figura 24 vamos adicionar um bloco “mover tanque” para den-

tro do seguinte caso de leitura dos sensores: preto no sensor da esquer-
da, branco no sensor da direita. Nesse caso, o robô deve rotacionar
para esquerda, tendo em vista que a leitura do sensor 1 indica uma
curva para esquerda.
Figura 24. Rotação para a esquerda.
24
Mude as portas para A e B, altere a potência do motor esquerdo

para-30 e a do motor direito para 30 (veja a Figura 25). Dessa forma,
o robô rotacionará em seu próprio eixo. Não se esqueça de marcar o
bloco com a opção “manter ligado”.
Figura 25. Rotação para a direita.
Arraste outro bloco “mover tanque” para dentro do caso: bran-

co no sensor da esquerda, preto no sensor da direita. Veja na Figura
26. Quando isso acontecer, o robô deve rotacionar para direita. Logo,
configure o bloco “mover tanque” da mesma maneira feita para o caso
anterior, mas mude a potência do motor esquerdo para 30 e a do mo-
tor direito para -30.
25
Figura 26. Resultado.
Feito isso, podemos ter uma visão geral do algoritmo de seguimen-

to de linha do robô.
Agora na Figura 27 vamos condensar todas essas comutações em

um único bloco. Para isso, selecione todos os blocos que estamos tra-
balhando e clique no menu Tools/Ferramentas > My Block Builder/
Meu Construtor de Bloco.
26
Figura 27. Criar um bloco personalizado.
Na caixa de diálogo que se abrir, defina um nome para o bloco. Na

Figura 28, foi utilizado “SeguirLinha”. Clique em Finish/Finalizar.
Figura 28. Construtor de Bloco.
27
Com isso, as comutações foram reduzidas ao bloco “SeguirLinha”

(Figura 29). Se clicarmos duas vezes nele, seremos direcionados para
uma aba com o programa referente a ele na qual podemos fazer altera-
ções na lógica. Também podemos encontrar nosso bloco personaliza-
do na aba da seção inferior chamada de “Meus blocos”.
Figura 29. Bloco personalizado.
Por fim, na Figura 30 vamos colocar esse nosso bloco dentro de um

ciclo que se repetirá infinitamente. Dessa forma, já temos um progra-
ma capaz de fazer o nosso robô seguir linha.
Figura 30. Ciclo/Loop.
3.3 Tratando Erros

Durante a execução do projeto que criamos anteriormente, você po-
derá notar que nossa lógica é incapaz de cobrir todos os casos de leitura
dos sensores, dado em função das alterações de luz do ambiente, dentre
outras coisas. Isso pode fazer com que o robô fique travado na pista. Va-
mos fazer uma verificação simples para manter o nosso robô rodando.
28
Como mostrado na Figura 31, adicione duas comutações no modo

de verificação de potência de motor. Defina em uma delas para verifi-
car o motor na porta A e na outra para verificar a porta B. Por fim, adi-
cione um bloco “mover direção”, com a opção “manter ligado” com a
potência de 20 para fazer o robô progredir lentamente na pista.
Figura 31. Verificação de motores.
Finalmente, transforme essas comutações em um bloco personali-

zado, veja como ficou na Figura 32, da mesma forma como foi feito
para o “SeguirLinha”, e adicione-o dentro do ciclo principal. Agora o
nosso robô não ficará travado quando não souber o que fazer.
Figura 32. Programa principal.
29
30
Seção 4 - Detectando Obstáculos
Para que o robô seja capaz de identificar e desviar de obstáculos

presentes na pista, é necessária a utilização de um sensor ultrassôni-
co ou infravermelho. Utilizaremos um sensor infravermelho para este
exemplo, contudo o código pode ser alterado para o funcionamento
com o sensor ultrassônico.
Conforme a Figura 33, faça o seguinte procedimento arraste o blo-

co de comutação para o projeto, altere a condição para: Sensor infra-
vermelho > Comparar > Proximidade. Em seguida, clique no botão de
visualização em abas para deixar o bloco mais compacto.
Figura 33. Verificação de proximidade.
Veja como fica a estrutura de Lógica de desvio na Figura 34.
Figura 34. Lógica de desvio.
31
Agora, vamos implementar as ações de desvio (veja a Figura 34).

Nos blocos, da esquerda para direita, temos:
1. Recuar uma rotação após detectar o obstáculo;
2. Rotacionar em 90° para direita (a quantidade de rotações varia
de robô para robô, nesse caso foi utilizado 1,5 rotações);
3. Avançar por 1 rotação, para sair do caminho do obstáculo;
4. Rotacionar 90° para esquerda;
5. Seguir em frente até atravessar o obstáculo;
6. Rotacionar 90° para esquerda;
7. Seguir em frente até passar a linha;
8. Rotacionar 90° para direita, alinhando com a linha;
Figura 35. Desvio do robô.
Na Figura 35 estão representados os passos citados na lista anteriormente.
Figura 36. Ciclo do programa principal.
Novamente, vamos transformar essa verificação em um bloco per-

sonalizado (Figura 36). Faça isso e adicione-o dentro do ciclo principal.
32
Seção 5 - Intersecções Marcadas em Verde
As indicações em verdes presentes na pista da OBR indicam o lado

o qual o robô deve seguir em caso de intersecção. Nesta parte da apos-
tila, vamos tratar dos possíveis casos.
5.1 Para a Esquerda

Conforme a Figura 37, adicione uma comutação, altere o modo
para “Sensor de cor > Medir > Cor”, clique no botão para alternar
para a visualização de abas, troque a cor para verde, mude a porta para
1 e adicione um bloco “mover direção” para dentro. Quando o robô
detectar a cor verde no sensor da esquerda, ele deve verificar se existe
linha após a marcação em verde para fazer a virada, por isso adicio-
namos o “mover direção”. Coloque o número de rotações suficiente
para o robô tirar o sensor da marca em verde e parar em cima da linha
preta. Não se esqueça de alterar as portas.
Figura 37. Comutação do verde.
33
(Na Figura 38) Após isso, vamos verificar a existência de linha pre-
ta. Adicione uma comutação, alterne a visualização para abas, confi-
gure “Sensor de cor > Comparar > Cor” e mude a porta para 1. Essa
porta é a mesma da verificação passada.
Figura 38. Comutação do verde.
Antes de fazermos a validação da virada, vamos verificar se existe

outra marcação em verde no sensor 2, o que caracteriza uma meia
volta. Vamos utilizar essa abordagem pois evita ela evita problemas na
detecção de meia volta. Então, adicione um bloco de variável antes
da comutação (Figura 39), defina o bloco como “Escrever > Lógica”
e marque a caixa como falso (X). Não se esqueça de definir o nome
como “meiaVolta”.
Figura 39. Variável “meiaVolta”.
34
Na sequência, vamos entender o que está acontecendo até o mo-

mento, acompanhe a Figura 40. O robô verifica a existência do verde
no sensor da esquerda, avança um pouco e verifica se existe a cor preta
(linha) após a marcação em verde.
Após isso, ele deve recuar e verificar a presença do verde no sensor

de cor oposto (sensor 2). Como queremos alterar o estado de uma
variável durante esse processo, vamos arrastar um ciclo para dentro da
comutação do preto. Coloque um bloco mover direção com potência
de-30 e marque a opção “ligado”. Em seguida, marque no bloco de
ciclo o tempo de 0.4. Esse tempo deve ser o suficiente para que o robô
recue até voltar para a posição em que o sensor detectou verde, então
procure um valor que melhor se adapte ao seu robô.
Arraste uma comutação para dentro do ciclo de 0.4s e marque-a

para verificar se o sensor na porta 2 encontrou verde. Em caso afirma-
tivo, o valor da variável “meiaVolta” deve se alterar para verdadeiro.
Figura 40. Comutação da esquerda.
Visualize a Figura 41, caso a cor verde não seja detectada no sensor
da direita, o robô deve avançar até chegar no centro da intersecção e
realizar uma rotação para a esquerda. Feito isso, ele pode voltar a exe-
cutar a lógica de seguimento de linha.
35
Figura 41. Comutação da esquerda.
5.2 Para a Direita

Na figura 42, a lógica para as marcações em verde do lado direito é a
mesma, logo, vamos copiar e colar tudo o que fizemos na etapa anterior.
Mudaremos apenas a porta da primeira verificação do verde para 2, a da
verificação do preto para 2 e a última verificação do verde para 1. Não se
esqueça de alterar a rotação do robô para a direita (30 e -30) na última
comutação. Está pronto. Posicione toda a estrutura da Figura 42 após a
verificação do verde da esquerda que construímos antes.
Figura 42. Comutação da direita.
36
5.3 Meia Volta

Por fim, temos a meia volta, veja a Figura 43. Já tratamos de sua
detecção nas etapas anteriores, logo só nos resta implementar a ação.
Para isso, arraste um bloco de variável, altere seu modo para Ler >
Lógica. Acrescente uma comutação no modo Lógica e ligue o bloco
de variável à ela. Adicione um bloco “mover tanque” com o número
de rotações necessárias para fazer o seu robô rotacionar 180º, no caso
apresentado foi utilizado o valor 3.
Figura 43. Meia volta.
Não se esqueça de transformar todas as verificações do verde em

um bloco só por meio do “Meu construtor de bloco”, veja a Figura 44
como foi finalizada.
Figura 44. Visão geral.
37
38
Referências
Lego Mindstorms Ev3. Disponível em:<https://education.lego.com/>.

Acesso em: 01 de março de 2021.
OBR (Olimpíada Brasileira de Robótica). Disponível em:<www.obr.

org.br>. Acesso em: 03 de junho de 2021.
39
40

Apostila Programacao Robotica Lego EV3 NB

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Apostila Programacao Robotica Lego EV3 NB

Enviado por

Direitos autorais:

Formatos disponíveis

INSTITUTO FEDERAL

Mato Grosso do Sul

Professora Dra. Marcia Ferreira Cristaldo

Professor Dr. Leandro de Jesus

Fique de Olho Dica

Guarde Bem Isto Você Sabia?

Link Saiba Mais

Vídeo/Áudio Para Refletir...

Seção 2 - Primeiros Passos........................................................................ 11

Seção 3 - Seguindo Linha........................................................................... 19

Seção 4 - Detectando Obstáculos............................................................. 31

Seção 5 - Intersecções Marcadas em Verde............................................ 33

A programação de robôs seguidores de linha utilizando o kit edu-

1.1 Instalação do Software

Figura 1. Página de download EV3 Lab Software.

Figura 2. Instalação Mindstorms EV3.

No passo 5, você deve escolher entre a versão para estudantes ou

Figura 3. Instalação Mindstorms EV3.

Figura 4. Finalização da instalação.

Seção 2 - Primeiros Passos

Nesta seção, percorreremos as principais funcionalidades do sof-

2.1 Interface do Software

Figura 5. Página inicial Mindstorms EV3.

Com um novo projeto criado, já podemos começar a criar nossos

Figura 6. Projeto em branco.

Descrição das seções do programa:

2.2 Blocos: Ação

Figura 7. Seção inferior - Ação.

Esses blocos são responsáveis por controlar atuadores como moto-

Da esquerda para a direita, temos:

Figura 8. Bloco de motor médio.

Se arrastarmos um desses blocos para a frente do botão de play na

Veja na Figura 8: Em 1, temos a possibilidade de selecionar a forma

Figura 9. Opções de funcionamento do bloco de motor médio.

Na Figura 9, temos as opções possíveis para a execução do bloco.

Antes de prosseguirmos, vamos dar uma olhada mais a fundo nos

Figura 10. Blocos de controle de direção e tanque.

Eles trabalham em conjunto de dois motores, partindo da ideia de

Em 1, escolhemos quais motores queremos controlar (atente-se

2.3 Blocos: Controle de Fluxo

Figura 11. Seção inferior - Controle de Fluxo.

Na Figura 11, da esquerda para a direita:

Figura 12. Bloco de Ciclo.

Vamos arrastar o bloco de ciclo para o nosso programa. Nele, deve-

Figura 13. Bloco de Comutação.

Na Figura 13, temos o bloco de comutação. Definimos, em 1, o

Figura 14. Bloco de Comutação Condensado.

Nesse caso, o escopo para as condições de verdadeiro e falso podem

2.4 Blocos: Sensor

Figura 15. Seção inferior - Sensores.

Da esquerda para a direita:

2.5 Blocos: Operação de Dados

Figura 16. Seção inferior - Operação de dados.

Da esquerda para a direita:

Ainda existem mais duas seções na aba inferior do software: Avan-

Seção 3 - Seguindo Linha

Chegou a hora de construirmos o nosso primeiro algoritmo de

3.1 Definindo Uma Estratégia

Figura 17. Sensores e motores do robô.

Note que A, B, 1 e 2 são as portas em que os componentes devem

Quadro 1. Regras da OBR.

Caso Leitura Ação

Quando os sensores detectarem branco, o robô deve estar com a