Robótica

Prof. Reinaldo Bianchi

Centro Universitário da FEI

2007

Aula

Objetivos desta aula

Programação real de um robô móvel.

Breve introdução a programação NQC

para robôs LEGO.

Resultado esperado:

– Robô seguidor de pista reta ao final da aula.

Baseado em:

– Aula do professor Paulo Santos.

– “Programming Lego Robots”, de Mark

Overmars.

O robô a ser usado

Três sensores:

– 1 e 3 são de luz

(SENSOR_LIGHT)

– 2 é de toque

(SENSOR_TOUCH)

Dois motores:

– A e C (saída B não é

utilizada!!)

O Robô usado

O robô usado

S1 S3

outA outC

Sensor 3

Sensor 1

O LEGO Brick RCX

CPU do robô.

Permite até 5

programas

armazenados na

memória.

Permite visualizar

sensores.

Controla motores.

O LEGO Brick RCX

Visualiza Valores

dos sensores

Liga/desligaExecuta/para

programa

Escolhe o programa a

executar

A linguagem “Not Quite C”

Uma pequena introdução a NQC.

A linguagem NQC

(“not quite C”)

NQC é uma linguagem de programação

desenvolvida por Dave Baum

especialmente para robôs LEGO.

Não entre em pânico se você nunca

programou!

– Subconjunto de Linguagem C.

– NQC é fácil de usar.

– Programar um robô em NQC é muito mais

fácil do que programar um computador.

NQC: aspectos básicos

Cada programa em NQC deve ter uma

“task main()”:

– Ela inicia a execução do programa.

Um programa pode ter diversas tarefas

sendo executadas em “paralelo”:

– multitasking.

Possui dois tipos de comandos:

– De controle do robô.

– De controle do fluxo do programa.

Exemplo 1

Meu primeiro programa NQC.

– Anda para frente e para trás.task main()

{

OnFwd(OUT_A); // Liga motor A

OnFwd(OUT_C); // Liga motor B

Wait(400); // Espera 4 segundos

OnRev(OUT_A+OUT_C); // Reverte.

Wait(400); // Espera 4 segundos

Off(OUT_A+OUT_C); // Desliga motores.

}

Comandos de controle do robô

Comandos que acionam os sensores e

atuadores do robô.

– Permitem ligar e desligar os motores,

ajustar a potência dos mesmos.

– Permitem definir os sensores usados e ler

os valores dos mesmos.

Usados em conjunto com os comandos

de controle de fluxo.

Entradas e Saídas

Todo controle do robô é realizado sobre

3 entradas e 3 saídas.

OUT_A, OUT_B e OUT_C:

– São as 3 saídas de controle do robô.

SENSOR_1, SENSOR_2 E

SENSOR_3:

– São as 3 entradas de sensores do robô.

Comandos de controle do motor

OnFwd(OUT_A);

– Inicia a saída A

– Se um motor estiver conectado a porta A,

ele será ligado no sentido direto com

máxima velocidade.

OnRev(OUT_A+OUT_C);

– Reverte as saídas A e C.

– Se existirem motores ligados a estas

saídas, eles serão acionados no sentido

reverso com máxima velocidade.

Comandos de controle do motor

Off(OUT_A+OUT_C);

– Desliga os motores.

SetPower(força).

– A força é um número inteiro entre 0 e 7:

• 7 é o mais rápido.

• 0 o mais lento, mas ainda com movimento.

Comando “wait”

O comando wait faz com que a tarefa

pare por um determinado tempo, dado

em centésimos de segundos.

Wait(400);

Note que as saídas são mantidas no

mesmo estado pelo tempo em que a

espera durar.

Definindo um sensor

Para definir um sensor é necessário

especificar a porta e o tipo do sensor:– SetSensor(SENSOR_2,SENSOR_TOUCH);

• Define um sensor de toque na porta 2.

– SetSensor(SENSOR_1,SENSOR_LIGHT);

• Define um sensor de luz na porta 1.

Para usar o sensor:

– Use o nome da porta como variável:– SENSOR_2 == 1

Sensor de toque

Usado para detectar

toques ou barreiras.

Retorna:

– 0 se aberto

– 1 se pressionado.

O sensor mais

simples possível

Exemplo sensor de toque

Anda até bater em algo e o sensor de

toque for pressionado:

task main()

{ SetSensor(SENSOR_1,SENSOR_TOUCH);

OnFwd(OUT_A+OUT_C);

until (SENSOR_1 == 1);

Off(OUT_A+OUT_C);

}

Sensor de luz

Usado para cores

em objetos, no chao

e distâncias.

Retorna:

– 0 mínimo.

– 80 máximo.

Na prática:

– < 30 é preto

– > 50 é branco

Comandos de controle de fluxo.

NQC possui comandos de controle de

fluxo iguais as linguagens

procedimentais convencionais, como

linguagem C ou Pascal:

– if... else

– while

– do ... while

– repeat ... until

– e outras.

“repeat”

task main()

{

repeat(4)

{

OnFwd(OUT_A+OUT_C);

Wait(MOVE_TIME);

OnRev(OUT_C);

Wait(TURN_TIME);

}

Off(OUT_A+OUT_C);

}

“do ... while”int move_time, turn_time, total_time;

task main()

{

total_time = 0;

do

{

move_time = Random(100);

turn_time = Random(100);

OnFwd(OUT_A+OUT_C);

Wait(move_time);

OnRev(OUT_C);

Wait(turn_time);

total_time += move_time; total_time += turn_time;

}

while (total_time < 2000);

Off(OUT_A+OUT_C);

}

“while” e “if/else”

#define MOVE_TIME 100

#define TURN_TIME 85

task main()

{

while(true){

OnFwd(OUT_A+OUT_C);

Wait(MOVE_TIME);

if (Random(1) == 0){

OnRev(OUT_C); }

else{

OnRev(OUT_A);}

Wait(TURN_TIME);

}

}

Anda e gira aleatoriamente para esquerda ou direita

Função random

A função random () gera um número

aleatório entre 0 e o número passado

como parâmetro da função:

– Random(60)

– Gera um número aleatório entre 0 e 60.

– Números sempre inteiros.

Operadores

Operadores relacionais:

– = =, <, <=, > , >=

– != (diferente)

Operadores Booleanos:

– && (conjunção lógica)

– || (disjunção lógica)

– ! (negação)

Variáveis

#define TURN_TIME 85

int move_time;

task main()

{move_time = 20;

repeat(50)

{

OnFwd(OUT_A+OUT_C);

Wait(move_time); OnRev(OUT_C);

Wait(TURN_TIME);

move_time += 5; }

Off(OUT_A+OUT_C);

}

Só existem variáveis inteiras (35 no máximo)

#define turn_around

OnRev(OUT_C);Wait(340);OnFwd(OUT_A+OUT_C);

task main()

{

OnFwd(OUT_A+OUT_C);

Wait(100);

turn_around;

Wait(200);

turn_around;

Wait(100);

turn_around;

Off(OUT_A+OUT_C);

}

Macros

Macros 2: Mudando de direção

#define MOVE_TIME 100

#define TURN_TIME 85

task main()

{

OnFwd(OUT_A+OUT_C);

Wait(MOVE_TIME);

OnRev(OUT_C);

Wait(TURN_TIME);

Off(OUT_A+OUT_C);

}

Programando o LEGO

Utilizamos o programa BricxCC para

programar o LEGO.

Permite:

– Editar e testar o programa.

– Carregar o programa no robô.

Bricx Command Center pode ser

executado em Windows (95, 98, ME,

NT, 2K, XP).

Bricx Command Center

Templates

Aviso: não perca seu tempo!

COMPILE E DEPURE SEU

PROGRAMA ANTES DE TESTÁ-LO

NO ROBÔ!!

Caso contrário, você só descobrirá os

erros depois de um bom tempo...

Atrapalha a todos...

Tarefa da aula de hoje

Fazer o robô andar em linha reta,

seguindo a pista, corrigindo os

eventuais desvios.

Dividir a turma em equipes de 2 alunos!

– Cada dupla deve fornecer um nome para a

sua equipe.

Pista usada.

Ao final do curso (4 aulas), a equipe

que fizer o trajeto a seguir no menor

tempo será a campeã!

Exemplo básico

Exemplo de robô que anda até mudar a

cor de seu sensor#define THRESHOLD 40

task main()

{

SetSensor(SENSOR_2,SENSOR_LIGHT);

OnFwd(OUT_A+OUT_C);

while (true)

{

if (SENSOR_2 > THRESHOLD)

{

OnRev(OUT_C);

until (SENSOR_2 <= THRESHOLD);

OnFwd(OUT_A+OUT_C);

}

}

}

Conclusão

O Controle de robôs reais não é tão

complicado.

Usem material das aulas de controle

(aula 9) e das aulas de robótica móvel.

Dificuldade:

– Robô não é simplesmente diferencial, mas

possui deslizamento.

– Outros tipos de robôs nas próximas aulas.

Fim